Export quantity types for function signatures

packages/dim-si/README.md

@@ -95,6 +95,31 @@ const speed = divide(kilometer(100), hour(2));
 _<a id="affine">\*</a> [Affine quantity](../dim-unit/README.md#affine-units) —
 zero point is arbitrary, which restricts valid operations._
 
+## Type Annotations
+
+Each quantity module exports a type for use in function signatures:
+
+```typescript
+import type { Length } from "@isentropic/dim-si/length";
+import type { Time } from "@isentropic/dim-si/time";
+import type { Velocity } from "@isentropic/dim-si/velocity";
+import { divide } from "@isentropic/dim-si/ops";
+
+function speed(d: Length, t: Time): Velocity {
+  return divide(d, t);
+}
+```
+
+Temperature has two types — `Temperature` for absolute values (affine) and
+`TemperatureDifference` for deltas (linear):
+
+```typescript
+import type {
+  Temperature,
+  TemperatureDifference,
+} from "@isentropic/dim-si/temperature";
+```
+
 ## Custom Scaled Units
 
 Use SI prefixes to create units not provided out of the box:
@@ -127,15 +152,18 @@ dimension:
     * @module
     */
 
-   import type { Jerk } from "@isentropic/dim-isq";
+   import type { Jerk as JerkDim } from "@isentropic/dim-isq";
+   import type { Linear } from "@isentropic/dim-unit";
    import { jerk } from "@isentropic/dim-isq";
-   import type { BaseUnit } from "./system.ts";
+   import type { BaseUnit } from "./types.ts";
+   import type { Si } from "./system.ts";
    import { si } from "./system.ts";
 
-   export type { Jerk } from "@isentropic/dim-isq";
+   /** An SI jerk quantity. */
+   export type Jerk = Linear<JerkDim, Si>;
 
    /** Meter per second cubed (m/s³) — SI unit of jerk. */
-   export const meterPerSecondCubed: BaseUnit<Jerk> = si.unit(jerk);
+   export const meterPerSecondCubed: BaseUnit<JerkDim> = si.unit(jerk);
    ```
 
    > **Note:** The quantity (`jerk`) must exist in `dim-isq` first. See the

packages/dim-si/src/absorbed-dose.ts

@@ -17,15 +17,18 @@
  * @module
  */
 
-import type { AbsorbedDose } from "@isentropic/dim-isq";
+import type { AbsorbedDose as AbsorbedDoseDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { absorbedDose } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { AbsorbedDose } from "@isentropic/dim-isq";
+/** An SI absorbed dose quantity. */
+export type AbsorbedDose = Linear<AbsorbedDoseDim, Si>;
 
 /** Gray (Gy) — SI unit of absorbed dose. */
-export const gray: BaseUnit<AbsorbedDose> = si.unit(absorbedDose);
+export const gray: BaseUnit<AbsorbedDoseDim> = si.unit(absorbedDose);
 
 /** Sievert (Sv) — SI unit of equivalent dose (same dimension as gray). */
-export const sievert: BaseUnit<AbsorbedDose> = si.unit(absorbedDose);
+export const sievert: BaseUnit<AbsorbedDoseDim> = si.unit(absorbedDose);

packages/dim-si/src/acceleration.ts

@@ -13,14 +13,17 @@
  * @module
  */
 
-import type { Acceleration } from "@isentropic/dim-isq";
+import type { Acceleration as AccelerationDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { acceleration } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Acceleration } from "@isentropic/dim-isq";
+/** An SI acceleration quantity. */
+export type Acceleration = Linear<AccelerationDim, Si>;
 
 /** Meter per second squared (m/s²) — SI unit of acceleration. */
-export const meterPerSecondSquared: BaseUnit<Acceleration> = si.unit(
+export const meterPerSecondSquared: BaseUnit<AccelerationDim> = si.unit(
   acceleration,
 );

packages/dim-si/src/amount.ts

@@ -15,19 +15,22 @@
  * @module
  */
 
-import type { Amount } from "@isentropic/dim-isq";
+import type { Amount as AmountDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { amount } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI } from "./prefixes.ts";
 
-export type { Amount } from "@isentropic/dim-isq";
+/** An SI amount quantity. */
+export type Amount = Linear<AmountDim, Si>;
 
 /** Mole (mol) — SI unit of amount of substance. */
-export const mole: BaseUnit<Amount> = si.unit(amount);
+export const mole: BaseUnit<AmountDim> = si.unit(amount);
 
 /** Millimole (mmol) — 10⁻³ moles. */
-export const millimole: ScaledUnit<Amount> = mole.scaled(MILLI);
+export const millimole: ScaledUnit<AmountDim> = mole.scaled(MILLI);
 
 /** Micromole (μmol) — 10⁻⁶ moles. */
-export const micromole: ScaledUnit<Amount> = mole.scaled(MICRO);
+export const micromole: ScaledUnit<AmountDim> = mole.scaled(MICRO);

packages/dim-si/src/area.ts

@@ -15,15 +15,18 @@
  * @module
  */
 
-import type { Area } from "@isentropic/dim-isq";
+import type { Area as AreaDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { area } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Area } from "@isentropic/dim-isq";
+/** An SI area quantity. */
+export type Area = Linear<AreaDim, Si>;
 
 /** Square meter (m²) — SI unit of area. */
-export const squareMeter: BaseUnit<Area> = si.unit(area);
+export const squareMeter: BaseUnit<AreaDim> = si.unit(area);
 
 /** Hectare (ha) — 10000 square meters. */
-export const hectare: ScaledUnit<Area> = squareMeter.scaled(10000);
+export const hectare: ScaledUnit<AreaDim> = squareMeter.scaled(10000);

packages/dim-si/src/capacitance.ts

@@ -16,22 +16,25 @@
  * @module
  */
 
-import type { Capacitance } from "@isentropic/dim-isq";
+import type { Capacitance as CapacitanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { capacitance } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, NANO, PICO } from "./prefixes.ts";
 
-export type { Capacitance } from "@isentropic/dim-isq";
+/** An SI capacitance quantity. */
+export type Capacitance = Linear<CapacitanceDim, Si>;
 
 /** Farad (F) — SI unit of capacitance. */
-export const farad: BaseUnit<Capacitance> = si.unit(capacitance);
+export const farad: BaseUnit<CapacitanceDim> = si.unit(capacitance);
 
 /** Microfarad (μF) — 10⁻⁶ farads. */
-export const microfarad: ScaledUnit<Capacitance> = farad.scaled(MICRO);
+export const microfarad: ScaledUnit<CapacitanceDim> = farad.scaled(MICRO);
 
 /** Nanofarad (nF) — 10⁻⁹ farads. */
-export const nanofarad: ScaledUnit<Capacitance> = farad.scaled(NANO);
+export const nanofarad: ScaledUnit<CapacitanceDim> = farad.scaled(NANO);
 
 /** Picofarad (pF) — 10⁻¹² farads. */
-export const picofarad: ScaledUnit<Capacitance> = farad.scaled(PICO);
+export const picofarad: ScaledUnit<CapacitanceDim> = farad.scaled(PICO);

packages/dim-si/src/catalytic-activity.ts

@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { CatalyticActivity } from "@isentropic/dim-isq";
+import type { CatalyticActivity as CatalyticActivityDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { catalyticActivity } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { CatalyticActivity } from "@isentropic/dim-isq";
+/** An SI catalytic activity quantity. */
+export type CatalyticActivity = Linear<CatalyticActivityDim, Si>;
 
 /** Katal (kat) — SI unit of catalytic activity. */
-export const katal: BaseUnit<CatalyticActivity> = si.unit(catalyticActivity);
+export const katal: BaseUnit<CatalyticActivityDim> = si.unit(catalyticActivity);

packages/dim-si/src/charge.ts

@@ -17,12 +17,15 @@
  * @module
  */
 
-import type { Charge } from "@isentropic/dim-isq";
+import type { Charge as ChargeDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { charge } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Charge } from "@isentropic/dim-isq";
+/** An SI charge quantity. */
+export type Charge = Linear<ChargeDim, Si>;
 
 /** Coulomb (C) — SI unit of electric charge. */
-export const coulomb: BaseUnit<Charge> = si.unit(charge);
+export const coulomb: BaseUnit<ChargeDim> = si.unit(charge);

packages/dim-si/src/conductance.ts

@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { Conductance } from "@isentropic/dim-isq";
+import type { Conductance as ConductanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { conductance } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Conductance } from "@isentropic/dim-isq";
+/** An SI conductance quantity. */
+export type Conductance = Linear<ConductanceDim, Si>;
 
 /** Siemens (S) — SI unit of electrical conductance. */
-export const siemens: BaseUnit<Conductance> = si.unit(conductance);
+export const siemens: BaseUnit<ConductanceDim> = si.unit(conductance);

packages/dim-si/src/current.ts

@@ -15,19 +15,22 @@
  * @module
  */
 
-import type { Current } from "@isentropic/dim-isq";
+import type { Current as CurrentDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { current } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI } from "./prefixes.ts";
 
-export type { Current } from "@isentropic/dim-isq";
+/** An SI current quantity. */
+export type Current = Linear<CurrentDim, Si>;
 
 /** Ampere (A) — SI unit of electric current. */
-export const ampere: BaseUnit<Current> = si.unit(current);
+export const ampere: BaseUnit<CurrentDim> = si.unit(current);
 
 /** Milliampere (mA) — 10⁻³ amperes. */
-export const milliampere: ScaledUnit<Current> = ampere.scaled(MILLI);
+export const milliampere: ScaledUnit<CurrentDim> = ampere.scaled(MILLI);
 
 /** Microampere (μA) — 10⁻⁶ amperes. */
-export const microampere: ScaledUnit<Current> = ampere.scaled(MICRO);
+export const microampere: ScaledUnit<CurrentDim> = ampere.scaled(MICRO);

packages/dim-si/src/energy.ts

@@ -16,27 +16,30 @@
  * @module
  */
 
-import type { Energy } from "@isentropic/dim-isq";
+import type { Energy as EnergyDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { energy } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { KILO, MEGA } from "./prefixes.ts";
 import { kilowatt } from "./power.ts";
 import { hour } from "./time.ts";
 
-export type { Energy } from "@isentropic/dim-isq";
+/** An SI energy quantity. */
+export type Energy = Linear<EnergyDim, Si>;
 
 /** Joule (J) — SI unit of energy. */
-export const joule: BaseUnit<Energy> = si.unit(energy);
+export const joule: BaseUnit<EnergyDim> = si.unit(energy);
 
 /** Kilojoule (kJ) — 1000 joules. */
-export const kilojoule: ScaledUnit<Energy> = joule.scaled(KILO);
+export const kilojoule: ScaledUnit<EnergyDim> = joule.scaled(KILO);
 
 /** Megajoule (MJ) — 10⁶ joules. */
-export const megajoule: ScaledUnit<Energy> = joule.scaled(MEGA);
+export const megajoule: ScaledUnit<EnergyDim> = joule.scaled(MEGA);
 
 /** Kilowatt-hour (kWh) — 3.6 megajoules. */
 // 1 kWh = 1 kW × 1 hour = 3.6 MJ
-export const kilowattHour: ScaledUnit<Energy> = joule.scaled(
+export const kilowattHour: ScaledUnit<EnergyDim> = joule.scaled(
   kilowatt.scale * hour.scale,
 );

packages/dim-si/src/force.ts

@@ -17,12 +17,15 @@
  * @module
  */
 
-import type { Force } from "@isentropic/dim-isq";
+import type { Force as ForceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { force } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Force } from "@isentropic/dim-isq";
+/** An SI force quantity. */
+export type Force = Linear<ForceDim, Si>;
 
 /** Newton (N) — SI unit of force. */
-export const newton: BaseUnit<Force> = si.unit(force);
+export const newton: BaseUnit<ForceDim> = si.unit(force);

packages/dim-si/src/frequency.ts

@@ -19,25 +19,28 @@
  * @module
  */
 
-import type { Frequency } from "@isentropic/dim-isq";
+import type { Frequency as FrequencyDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { frequency } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { GIGA, KILO, MEGA } from "./prefixes.ts";
 
-export type { Frequency } from "@isentropic/dim-isq";
+/** An SI frequency quantity. */
+export type Frequency = Linear<FrequencyDim, Si>;
 
 /** Hertz (Hz) — SI unit of frequency. */
-export const hertz: BaseUnit<Frequency> = si.unit(frequency);
+export const hertz: BaseUnit<FrequencyDim> = si.unit(frequency);
 
 /** Becquerel (Bq) — SI unit of radioactivity (same dimension as hertz). */
-export const becquerel: BaseUnit<Frequency> = si.unit(frequency);
+export const becquerel: BaseUnit<FrequencyDim> = si.unit(frequency);
 
 /** Kilohertz (kHz) — 1000 hertz. */
-export const kilohertz: ScaledUnit<Frequency> = hertz.scaled(KILO);
+export const kilohertz: ScaledUnit<FrequencyDim> = hertz.scaled(KILO);
 
 /** Megahertz (MHz) — 10⁶ hertz. */
-export const megahertz: ScaledUnit<Frequency> = hertz.scaled(MEGA);
+export const megahertz: ScaledUnit<FrequencyDim> = hertz.scaled(MEGA);
 
 /** Gigahertz (GHz) — 10⁹ hertz. */
-export const gigahertz: ScaledUnit<Frequency> = hertz.scaled(GIGA);
+export const gigahertz: ScaledUnit<FrequencyDim> = hertz.scaled(GIGA);

packages/dim-si/src/illuminance.ts

@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { Illuminance } from "@isentropic/dim-isq";
+import type { Illuminance as IlluminanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { illuminance } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Illuminance } from "@isentropic/dim-isq";
+/** An SI illuminance quantity. */
+export type Illuminance = Linear<IlluminanceDim, Si>;
 
 /** Lux (lx) — SI unit of illuminance. */
-export const lux: BaseUnit<Illuminance> = si.unit(illuminance);
+export const lux: BaseUnit<IlluminanceDim> = si.unit(illuminance);