@danielsimonjr/mathts-core 0.3.1 → 0.4.0

package/dist/index-qMNYDTSO.d.ts

@@ -0,0 +1,440 @@
+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;
+        };
+    };
+}
+interface ResultSet {
+    entries: unknown[];
+    constructor: {
+        prototype: {
+            isResultSet: boolean;
+        };
+    };
+}
+interface Help {
+    constructor: {
+        prototype: {
+            isHelp: boolean;
+        };
+    };
+}
+interface Chain {
+    constructor: {
+        prototype: {
+            isChain: boolean;
+        };
+    };
+}
+interface Node {
+    isNode: boolean;
+    constructor: {
+        prototype: {
+            isNode: boolean;
+        };
+    };
+}
+interface AccessorNode extends Node {
+    isAccessorNode: boolean;
+}
+interface ArrayNode extends Node {
+    isArrayNode: boolean;
+}
+interface AssignmentNode extends Node {
+    isAssignmentNode: boolean;
+}
+interface BlockNode extends Node {
+    isBlockNode: boolean;
+}
+interface ConditionalNode extends Node {
+    isConditionalNode: boolean;
+}
+interface ConstantNode extends Node {
+    isConstantNode: boolean;
+}
+interface FunctionAssignmentNode extends Node {
+    isFunctionAssignmentNode: boolean;
+}
+interface FunctionNode extends Node {
+    isFunctionNode: boolean;
+}
+interface IndexNode extends Node {
+    isIndexNode: boolean;
+}
+interface ObjectNode extends Node {
+    isObjectNode: boolean;
+}
+interface OperatorNode extends Node {
+    isOperatorNode: boolean;
+    op: string;
+    args: Node[];
+}
+interface ParenthesisNode extends Node {
+    isParenthesisNode: boolean;
+}
+interface RangeNode extends Node {
+    isRangeNode: boolean;
+}
+interface RelationalNode extends Node {
+    isRelationalNode: boolean;
+}
+interface SymbolNode extends Node {
+    isSymbolNode: boolean;
+}
+interface PartitionedMap {
+    a: Map<unknown, unknown>;
+    b: Map<unknown, unknown>;
+}
+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 isResultSet(x: unknown): x is ResultSet;
+declare function isHelp(x: unknown): x is Help;
+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 isPartitionedMap(object: unknown): object is PartitionedMap;
+declare function isObjectWrappingMap(object: unknown): boolean;
+declare function isNull(x: unknown): x is null;
+declare function isUndefined(x: unknown): x is undefined;
+declare function isAccessorNode(x: unknown): x is AccessorNode;
+declare function isArrayNode(x: unknown): x is ArrayNode;
+declare function isAssignmentNode(x: unknown): x is AssignmentNode;
+declare function isBlockNode(x: unknown): x is BlockNode;
+declare function isConditionalNode(x: unknown): x is ConditionalNode;
+declare function isConstantNode(x: unknown): x is ConstantNode;
+declare function rule2Node(node: Node): boolean;
+declare function isFunctionAssignmentNode(x: unknown): x is FunctionAssignmentNode;
+declare function isFunctionNode(x: unknown): x is FunctionNode;
+declare function isIndexNode(x: unknown): x is IndexNode;
+declare function isNode(x: unknown): x is Node;
+declare function isObjectNode(x: unknown): x is ObjectNode;
+declare function isOperatorNode(x: unknown): x is OperatorNode;
+declare function isParenthesisNode(x: unknown): x is ParenthesisNode;
+declare function isRangeNode(x: unknown): x is RangeNode;
+declare function isRelationalNode(x: unknown): x is RelationalNode;
+declare function isSymbolNode(x: unknown): x is SymbolNode;
+declare function isChain(x: unknown): x is Chain;
+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 { type UnitComponent as $, type AccessorNode as A, type BaseUnitDef as B, type Chain as C, type DenseMatrix as D, type ParseOptions as E, type Fraction as F, type PartitionedMap as G, type Help as H, type Index as I, type PrefixDef as J, type PrefixTable as K, type RangeNode as L, type Matrix as M, type Node as N, type ObjectNode as O, type ParenthesisNode as P, type RelationalNode as Q, type Range as R, type ResultSet as S, type ScalarBinaryOp as T, Unit as U, type ScalarUnaryOp as V, type SparseMatrix as W, type SubtractScalar as X, type SymbolNode as Y, type TypeConverters as Z, type Unit$1 as _, type UnitInstance as a, type UnitConfig as a0, type UnitDef as a1, type UnitFormatOptions as a2, type UnitJSON as a3, type UnitSystem as a4, type UnitSystemEntry as a5, isAccessorNode as a6, isArray as a7, isArrayNode as a8, isAssignmentNode as a9, isOperatorNode as aA, isParenthesisNode as aB, isPartitionedMap as aC, isRange as aD, isRangeNode as aE, isRegExp as aF, isRelationalNode as aG, isResultSet as aH, isSparseMatrix as aI, isString as aJ, isSymbolNode as aK, isUndefined as aL, rule2Node as aM, typeOf as aN, isBigInt as aa, isBigNumber as ab, isBlockNode as ac, isBoolean as ad, isChain as ae, isCollection as af, isComplex as ag, isConditionalNode as ah, isConstantNode as ai, isDate as aj, isDenseMatrix as ak, isFraction as al, isFunction as am, isFunctionAssignmentNode as an, isFunctionNode as ao, isHelp as ap, isIndex as aq, isIndexNode as ar, isMap as as, isMatrix as at, isNode as au, isNull as av, isNumber as aw, isObject as ax, isObjectNode as ay, isObjectWrappingMap as az, type UnitConstructor as b, type UnitDependencies as c, type ArrayNode as d, type AssignmentNode as e, type BigNumber as f, type BigNumberConstructor as g, type BigNumberValue as h, isUnit as i, type BlockNode as j, type Complex as k, type ComplexConstructor as l, type ComplexValue as m, type ConditionalNode as n, type ConstantNode as o, type ConverterFn as p, type CreateUnitDefObject as q, type CreateUnitOptions as r, type FractionConstructor as s, type FractionValue as t, type FunctionAssignmentNode as u, type FunctionNode as v, type IndexDimension as w, type IndexNode as x, type Numeric as y, type OperatorNode as z };