@danielsimonjr/mathts-core 0.3.1 → 0.4.1

package/dist/index-DpOizJsa.d.ts

@@ -0,0 +1,337 @@
+interface BigNumber {
+    isBigNumber: boolean;
+    constructor: {
+        prototype: {
+            isBigNumber: boolean;
+        };
+        isDecimal?: (x: unknown) => boolean;
+    };
+}
+interface Complex {
+    re: number;
+    im: number;
+}
+interface Fraction {
+    n: number;
+    d: number;
+}
+interface Unit$1 {
+    constructor: {
+        prototype: {
+            isUnit: boolean;
+        };
+    };
+}
+interface Matrix {
+    isMatrix?: boolean;
+    _size?: number[];
+    constructor: {
+        prototype: {
+            isMatrix: boolean;
+        };
+    };
+}
+interface DenseMatrix extends Matrix {
+    isDenseMatrix: boolean;
+}
+interface SparseMatrix extends Matrix {
+    isSparseMatrix: boolean;
+}
+interface Range {
+    start: number;
+    end: number;
+    step: number;
+    constructor: {
+        prototype: {
+            isRange: boolean;
+        };
+    };
+}
+interface IndexDimension {
+    _data?: unknown[];
+    _size: number[];
+    isRange?: boolean;
+    start?: number;
+    end?: number;
+}
+interface Index {
+    _dimensions: (IndexDimension | string)[];
+    _sourceSize?: (number | null)[];
+    constructor: {
+        prototype: {
+            isIndex: boolean;
+        };
+    };
+}
+declare function isNumber(x: unknown): x is number;
+declare function isBigNumber(x: unknown): x is BigNumber;
+declare function isBigInt(x: unknown): x is bigint;
+declare function isComplex(x: unknown): x is Complex;
+declare function isFraction(x: unknown): x is Fraction;
+declare function isUnit(x: unknown): x is Unit$1;
+declare function isString(x: unknown): x is string;
+declare const isArray: (arg: any) => arg is any[];
+declare function isMatrix(x: unknown): x is Matrix;
+/**
+ * Test whether a value is a collection: an Array or Matrix
+ * @param {*} x
+ * @returns {boolean} isCollection
+ */
+declare function isCollection(x: unknown): x is unknown[] | Matrix;
+declare function isDenseMatrix(x: unknown): x is DenseMatrix;
+declare function isSparseMatrix(x: unknown): x is SparseMatrix;
+declare function isRange(x: unknown): x is Range;
+declare function isIndex(x: unknown): x is Index;
+declare function isBoolean(x: unknown): x is boolean;
+declare function isFunction(x: unknown): x is (...args: unknown[]) => unknown;
+declare function isDate(x: unknown): x is Date;
+declare function isRegExp(x: unknown): x is RegExp;
+declare function isObject(x: unknown): x is Record<string, unknown>;
+/**
+ * Returns `true` if the passed object appears to be a Map (i.e. duck typing).
+ *
+ * Methods looked for are `get`, `set`, `keys` and `has`.
+ *
+ * @param {Map | object} object
+ * @returns
+ */
+declare function isMap(object: unknown): object is Map<unknown, unknown>;
+declare function isNull(x: unknown): x is null;
+declare function isUndefined(x: unknown): x is undefined;
+declare function typeOf(x: unknown): string;
+
+/**
+ * Shared TypeScript interfaces for the Unit factory (`Unit.ts`).
+ *
+ * The Unit type is a "function-as-class" (a constructor function whose
+ * prototype is built up imperatively) ported from mathjs. These interfaces
+ * describe the runtime shapes precisely so `Unit.ts` can be fully type-checked
+ * under strict mode without suppression directives or escape-hatch typing.
+ *
+ * @module @danielsimonjr/mathts-core/types/unit/unit-types
+ */
+
+/** A complex number value (re/im pair), as produced by the `Complex` type. */
+type ComplexValue = Complex;
+/**
+ * Minimal structural view of a BigNumber value: only the instance methods that
+ * the Unit factory actually calls when computing angle constants.
+ */
+interface BigNumberValue {
+    div(other: BigNumberValue | number | string): BigNumberValue;
+    times(other: BigNumberValue | number | string): BigNumberValue;
+}
+/** Structural view of a Fraction value (numerator/denominator/sign). */
+interface FractionValue {
+    n: number;
+    d: number;
+    s: number;
+    isFraction?: boolean;
+}
+/**
+ * Any numeric value a Unit can carry. Mirrors what `isNumeric`/`isComplex`
+ * accept at the constructor boundary (number, bigint, boolean, BigNumber,
+ * Fraction, Complex). Boolean/bigint flow through unchanged for valueless
+ * units and are coerced by the scalar operations otherwise.
+ */
+type Numeric = number | bigint | boolean | BigNumberValue | FractionValue | ComplexValue;
+/** A prefix definition such as `{ name: 'k', value: 1e3, scientific: true }`. */
+interface PrefixDef {
+    name: string;
+    value: number;
+    scientific: boolean;
+}
+/** A named table of prefixes (e.g. PREFIXES.SHORT), keyed by prefix name. */
+type PrefixTable = Record<string, PrefixDef>;
+/** A base dimension definition (the 9-element exponent vector + its key). */
+interface BaseUnitDef {
+    dimensions: number[];
+    key?: string;
+}
+/**
+ * A unit definition entry in the UNITS table. `dimensions` and `base.key` are
+ * populated after the literal is created (see the module-init loops), hence
+ * optional; `value` is `null` for angle units until `calculateAngleValues`
+ * runs at module init, before any unit is parsed.
+ */
+interface UnitDef {
+    name: string;
+    base?: BaseUnitDef;
+    prefixes?: PrefixTable;
+    value: Numeric | null;
+    offset: number;
+    dimensions?: number[];
+    reciprocal?: boolean;
+}
+/** A single component of a Unit's unit list (e.g. the `m` in `m/s^2`). */
+interface UnitComponent {
+    unit: UnitDef;
+    prefix: PrefixDef;
+    power: number;
+}
+/** An entry in a unit system, pairing a unit with a default prefix. */
+interface UnitSystemEntry {
+    unit: UnitDef;
+    prefix: PrefixDef;
+}
+/** A unit system (e.g. `si`, `cgs`, `us`, `auto`), keyed by base-dimension. */
+type UnitSystem = Record<string, UnitSystemEntry>;
+/** JSON serialization shape produced by `Unit#toJSON`. */
+interface UnitJSON {
+    mathjs: 'Unit';
+    value: Numeric | null;
+    unit: string | null;
+    fixPrefix: boolean;
+    skipSimp: boolean;
+}
+/** A numeric-type converter (number → BigNumber/Fraction/Complex/number). */
+type ConverterFn = (x: Numeric) => Numeric;
+/** The table of numeric-type converters exposed on `Unit.typeConverters`. */
+interface TypeConverters {
+    BigNumber: ConverterFn;
+    Fraction: ConverterFn;
+    Complex: ConverterFn;
+    number: ConverterFn;
+    [key: string]: ConverterFn;
+}
+/** Options accepted by `Unit.parse`. */
+interface ParseOptions {
+    allowNoUnits?: boolean;
+}
+/** Formatting options accepted by `Unit#format` / `Unit#toBest`. */
+interface UnitFormatOptions {
+    offset?: number;
+    [key: string]: unknown;
+}
+/** Options accepted by `Unit.createUnit`. */
+interface CreateUnitOptions {
+    override?: boolean;
+}
+/** Object form of a `createUnit` / `createUnitSingle` definition. */
+interface CreateUnitDefObject {
+    definition?: string | UnitInstance;
+    prefixes?: string;
+    offset?: number;
+    baseName?: string;
+    aliases?: string[];
+}
+/** Config object the Unit factory reads (`config` dep + `on('config')`). */
+interface UnitConfig {
+    number: string;
+    predictable?: boolean;
+}
+/** Constructor (with static `.I`) for Complex values. */
+interface ComplexConstructor {
+    readonly I: ComplexValue;
+}
+/** Constructor for BigNumber values. */
+interface BigNumberConstructor {
+    new (value: number | string): BigNumberValue;
+}
+/** Constructor for Fraction values. */
+interface FractionConstructor {
+    new (value: Numeric | string, denominator?: number): FractionValue;
+}
+/** `subtractScalar` is polymorphic: it also subtracts two Units (in splitUnit). */
+interface SubtractScalar {
+    (a: UnitInstance, b: UnitInstance): UnitInstance;
+    (a: Numeric, b: Numeric): Numeric;
+}
+/** A binary scalar operation (add/multiply/divide/pow). */
+type ScalarBinaryOp = (a: Numeric, b: Numeric) => Numeric;
+/** A unary scalar operation (abs/fix/round). */
+type ScalarUnaryOp = (x: Numeric) => Numeric;
+/**
+ * The dependency object injected into the Unit factory by the factory system.
+ * `on` is optional (`?on` in the dependency list). The index signature reflects that
+ * this is a factory *scope* (a string-keyed dependency record that may also carry
+ * deps beyond the ones the Unit itself reads), and lets it satisfy the `factory`
+ * helper's `Record<string, unknown>` constraint.
+ */
+interface UnitDependencies {
+    [key: string]: unknown;
+    on?: (event: string, callback: (curr: UnitConfig, prev: UnitConfig) => void) => void;
+    config: UnitConfig;
+    addScalar: ScalarBinaryOp;
+    subtractScalar: SubtractScalar;
+    multiplyScalar: ScalarBinaryOp;
+    divideScalar: ScalarBinaryOp;
+    pow: ScalarBinaryOp;
+    abs: ScalarUnaryOp;
+    fix: ScalarUnaryOp;
+    round: ScalarUnaryOp;
+    equal: (a: unknown, b: unknown) => boolean;
+    isNumeric: (x: unknown) => boolean;
+    format: (value: unknown, options?: unknown) => string;
+    number: (x: unknown) => number;
+    Complex: ComplexConstructor;
+    BigNumber: BigNumberConstructor;
+    Fraction: FractionConstructor;
+}
+/** An instance of Unit (the prototype methods + per-instance fields). */
+interface UnitInstance {
+    value: Numeric | null;
+    units: UnitComponent[];
+    dimensions: number[];
+    fixPrefix: boolean;
+    skipAutomaticSimplification: boolean;
+    type: 'Unit';
+    isUnit: boolean;
+    constructor: UnitConstructor;
+    clone(): UnitInstance;
+    valueType(): string;
+    _isDerived(): boolean;
+    _normalize(value: Numeric | null | undefined): Numeric | null;
+    _denormalize(value: Numeric | null, prefixValue?: Numeric): Numeric | null;
+    hasBase(base: BaseUnitDef | string | undefined): boolean;
+    equalBase(other: {
+        dimensions: number[];
+    }): boolean;
+    equals(other: UnitInstance): boolean;
+    multiply(other: UnitInstance | Numeric): UnitInstance | Numeric;
+    divideInto(numerator: Numeric): UnitInstance | Numeric;
+    divide(other: UnitInstance | Numeric): UnitInstance | Numeric;
+    pow(p: number): UnitInstance | Numeric;
+    abs(): UnitInstance;
+    to(valuelessUnit: string | UnitInstance): UnitInstance;
+    toNumber(valuelessUnit?: string | UnitInstance): number;
+    toNumeric(valuelessUnit?: string | UnitInstance): Numeric | null;
+    toString(): string;
+    toJSON(): UnitJSON;
+    valueOf(): string;
+    simplify(): UnitInstance;
+    toSI(): UnitInstance;
+    formatUnits(): string;
+    toBest(unitList?: Array<string | UnitInstance>, options?: UnitFormatOptions): UnitInstance;
+    format(options?: UnitFormatOptions): string;
+    _bestPrefix(offset?: number): PrefixDef;
+    splitUnit(parts: Array<string | UnitInstance>): UnitInstance[];
+    _numberConverter(): ConverterFn;
+}
+/** The Unit constructor function together with its static members. */
+interface UnitConstructor {
+    new (value?: Numeric | null, valuelessUnit?: string | UnitInstance): UnitInstance;
+    prototype: UnitInstance;
+    name: string;
+    parse(str: string, options?: ParseOptions): UnitInstance;
+    isValuelessUnit(name: string): boolean;
+    isValidAlpha(c: string): boolean;
+    fromJSON(json: UnitJSON): UnitInstance;
+    setUnitSystem(name: string): void;
+    getUnitSystem(): string | undefined;
+    createUnit(obj: Record<string, unknown>, options?: CreateUnitOptions): UnitInstance | undefined;
+    createUnitSingle(name: string, obj?: unknown): UnitInstance;
+    deleteUnit(name: string): void;
+    _getNumberConverter(type: string): ConverterFn;
+    typeConverters: TypeConverters;
+    PREFIXES: Record<string, PrefixTable>;
+    BASE_DIMENSIONS: string[];
+    BASE_UNITS: Record<string, BaseUnitDef>;
+    UNIT_SYSTEMS: Record<string, UnitSystem>;
+    UNITS: Record<string, UnitDef>;
+}
+
+/** The core `Unit` class, pre-wired to core's numeric primitives. */
+declare const Unit: UnitConstructor;
+
+export { isNull as $, type UnitSystem as A, type BaseUnitDef as B, type Complex as C, type DenseMatrix as D, type UnitSystemEntry as E, type Fraction as F, isArray as G, isBigInt as H, type Index as I, isBigNumber as J, isBoolean as K, isCollection as L, type Matrix as M, type Numeric as N, isComplex as O, type ParseOptions as P, isDate as Q, type Range as R, type ScalarBinaryOp as S, type TypeConverters as T, Unit as U, isDenseMatrix as V, isFraction as W, isFunction as X, isIndex as Y, isMap as Z, isMatrix as _, type UnitInstance as a, isNumber as a0, isObject as a1, isRange as a2, isRegExp as a3, isSparseMatrix as a4, isString as a5, isUndefined as a6, typeOf as a7, type UnitConstructor as b, type UnitDependencies as c, type BigNumber as d, type BigNumberConstructor as e, type BigNumberValue as f, type ComplexConstructor as g, type ComplexValue as h, isUnit as i, type ConverterFn as j, type CreateUnitDefObject as k, type CreateUnitOptions as l, type FractionConstructor as m, type FractionValue as n, type IndexDimension as o, type PrefixDef as p, type PrefixTable as q, type ScalarUnaryOp as r, type SparseMatrix as s, type SubtractScalar as t, type Unit$1 as u, type UnitComponent as v, type UnitConfig as w, type UnitDef as x, type UnitFormatOptions as y, type UnitJSON as z };