@danielsimonjr/mathts-core 0.14.3 → 0.15.1

package/dist/string.d.ts

@@ -0,0 +1,70 @@
+import { type FormatOptions } from './number.js';
+/**
+ * Formatting options accepted by the generic `format` helper. Extends the
+ * numeric {@link FormatOptions} with the string-level `truncate` and the
+ * fraction rendering mode, or is a precision number, or a custom formatter.
+ */
+export type GeneralFormatOptions = number | ((value: unknown) => string) | (FormatOptions & {
+    truncate?: number;
+    fraction?: 'ratio' | 'decimal';
+});
+/**
+ * Format a value of any type into a string.
+ *
+ * Usage:
+ *     math.format(value)
+ *     math.format(value, precision)
+ *     math.format(value, options)
+ *
+ * When value is a function:
+ *
+ * - When the function has a property `syntax`, it returns this
+ *   syntax description.
+ * - In other cases, a string `'function'` is returned.
+ *
+ * When `value` is an Object:
+ *
+ * - When the object contains a property `format` being a function, this
+ *   function is invoked as `value.format(options)` and the result is returned.
+ * - When the object has its own `toString` method, this method is invoked
+ *   and the result is returned.
+ * - In other cases the function will loop over all object properties and
+ *   return JSON object notation like '{"a": 2, "b": 3}'.
+ *
+ * Example usage:
+ *     math.format(2/7)                // '0.2857142857142857'
+ *     math.format(math.pi, 3)         // '3.14'
+ *     math.format(new Complex(2, 3))  // '2 + 3i'
+ *     math.format('hello')            // '"hello"'
+ *
+ * @param value - Value to be stringified
+ * @param options - Optional.
+ *     Formatting options. See src/utils/number.js:format for a
+ *     description of the available options controlling number output.
+ *     This generic "format" also supports the option property `truncate: NN`
+ *     giving the maximum number NN of characters to return (if there would
+ *     have been more, they are deleted and replaced by an ellipsis).
+ * @return {string} str
+ */
+export declare function format(value: unknown, options?: unknown): string;
+/**
+ * Stringify a value into a string enclosed in double quotes.
+ * Unescaped double quotes and backslashes inside the value are escaped.
+ * @param value
+ * @return {string}
+ */
+export declare function stringify(value: unknown): string;
+/**
+ * Escape special HTML characters
+ * @param value
+ * @return {string}
+ */
+export declare function escape(value: unknown): string;
+/**
+ * Compare two strings
+ * @param x
+ * @param y
+ * @returns {number}
+ */
+export declare function compareText(x: unknown, y: unknown): number;
+//# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAoBA,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAGzE;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,GAC5B,CAAC,aAAa,GAAG;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,CAAC,CAAC;AASP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAShE;AA2DD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAWhD;AAYD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAU7C;AA8CD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAoB1D"}

package/dist/switch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transpose a 2D array. Private helper used only by `core/src/collection.ts`'s
+ * `_reduce` (Bucket B slice 2 canonical) — mirrors `expression/src/utils/switch.ts`
+ * / `functions/src/utils/switch.ts`, which remain in place unchanged for now
+ * (not part of this slice's named scope). Not exported from `internal.ts`.
+ * @private
+ */
+export declare function _switch<T>(mat: T[][]): T[][];
+//# sourceMappingURL=switch.d.ts.map

package/dist/switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.d.ts","sourceRoot":"","sources":["../src/switch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAa5C"}

package/dist/typed/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * typed-function integration exports
+ */
+export { mathTyped, createMathTSTyped, typed, create, createTypedFunction, TypeRegistry, MATHTS_TYPES, MATHTS_CONVERSIONS, isNumber, isBoolean, isString, isBigInt, isArray, isFunction, isObject, isNull, isUndefined, isComplex, isFraction, isBigNumber, isFloat64Array, isFloat32Array, isInt32Array, isUint32Array, isUint8Array, isMatrix, isDenseMatrix, isSparseMatrix, isUnit, initTypedWasm, isTypedWasmAvailable, } from './mathts-typed.js';
+export type { TypedFunction, TypedInstance, TypeDef, ConversionDef, SignatureFunction, ReferTo, ReferToSelf, } from './mathts-typed.js';
+export { registerNativeTypes } from './type-bridge.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAEL,SAAS,EACT,iBAAiB,EACjB,KAAK,EACL,MAAM,EACN,mBAAmB,EACnB,YAAY,EAGZ,YAAY,EACZ,kBAAkB,EAGlB,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,UAAU,EACV,QAAQ,EACR,MAAM,EACN,WAAW,EAGX,SAAS,EACT,UAAU,EACV,WAAW,EAGX,cAAc,EACd,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EAGZ,QAAQ,EACR,aAAa,EACb,cAAc,EAGd,MAAM,EAGN,aAAa,EACb,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,aAAa,EACb,aAAa,EACb,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/typed/mathts-typed.d.ts

@@ -0,0 +1,246 @@
+/**
+ * MathTS typed-function Integration
+ *
+ * Creates a configured typed-function instance with MathTS types
+ * for runtime type dispatch across numeric types, matrices, and more.
+ *
+ * This module directly uses the typed-function library API without
+ * any intermediate abstraction layers.
+ *
+ * Supports WASM-accelerated dispatch when available.
+ *
+ * @packageDocumentation
+ */
+import typed, { create } from 'typed-function';
+import type { TypedFunction, TypedInstance, SignatureFunction, ReferTo, ReferToSelf } from 'typed-function';
+/**
+ * Initialize WASM dispatch for typed-function (optional, improves performance)
+ *
+ * Uses the unified typed.init() API to enable WASM-accelerated dispatch
+ * with automatic fallback to pure JS when WASM is unavailable.
+ *
+ * @param options - Initialization options
+ * @returns Promise resolving to true if WASM was initialized successfully
+ */
+export declare function initTypedWasm(options?: {
+    preferWasm?: boolean;
+}): Promise<boolean>;
+/**
+ * Check if WASM dispatch is available
+ */
+export declare function isTypedWasmAvailable(): boolean;
+import { Complex } from '../types/complex.js';
+import { Fraction } from '../types/fraction.js';
+import { BigNumber } from '../types/bignumber.js';
+export type { TypedFunction, TypedInstance, SignatureFunction, ReferTo, ReferToSelf };
+/**
+ * Any concrete implementation accepted when *declaring* a typed signature.
+ *
+ * typed-function's published `SignatureFunction` is `(...args: unknown[]) =>
+ * unknown`, which is correct for *internal/output* positions (where the stored
+ * impl is later CALLED with validated args) but wrong as an *input* type:
+ * under `strictFunctionTypes`, function parameters are contravariant, so a
+ * concrete impl such as `(a: number, b: number) => number` is NOT assignable
+ * to an `unknown[]` parameter list (`unknown` is not assignable to `number`).
+ * The correct top-type for "any function" in an input position uses `never`
+ * parameters — every function is assignable to it because `never` is
+ * assignable to every parameter type. This is exactly the set of values
+ * typed-function genuinely accepts when declaring signatures.
+ */
+export type SignatureImpl = (...args: never[]) => unknown;
+/** Signature record accepted by the MathTS typed factory (see {@link SignatureImpl}). */
+export type SignatureRecord = Record<string, SignatureImpl | ReferTo | ReferToSelf>;
+/**
+ * The MathTS typed-function factory type.
+ *
+ * Structurally identical to typed-function's {@link TypedInstance} except its
+ * call signatures accept implementations declared with concrete parameter
+ * types (see {@link SignatureImpl}). All instance methods are inherited
+ * unchanged via `Omit<TypedInstance, never>` (a mapped type, which drops the
+ * overly-strict published call signatures while preserving every method).
+ */
+export interface MathTSTyped extends Omit<TypedInstance, never> {
+    (name: string, signatures: SignatureRecord): TypedFunction;
+    (signatures: SignatureRecord): TypedFunction;
+    (...args: Array<string | SignatureRecord | TypedFunction | (SignatureImpl & {
+        signature: string;
+    })>): TypedFunction;
+    referToSelf: (callback: (self: TypedFunction) => SignatureImpl) => ReferToSelf;
+    referTo: (...args: [...string[], (...fns: SignatureFunction[]) => SignatureImpl]) => ReferTo;
+}
+/**
+ * Type definition for typed-function
+ */
+export interface TypeDef {
+    name: string;
+    test: (x: unknown) => boolean;
+}
+/**
+ * Conversion definition for typed-function
+ */
+export interface ConversionDef {
+    from: string;
+    to: string;
+    convert: (value: unknown) => unknown;
+}
+export declare const isNumber: (x: unknown) => x is number;
+export declare const isBoolean: (x: unknown) => x is boolean;
+export declare const isString: (x: unknown) => x is string;
+export declare const isBigInt: (x: unknown) => x is bigint;
+export declare const isArray: (x: unknown) => x is unknown[];
+export declare const isFunction: (x: unknown) => x is (...args: unknown[]) => unknown;
+export declare const isObject: (x: unknown) => x is object;
+export declare const isNull: (x: unknown) => x is null;
+export declare const isUndefined: (x: unknown) => x is undefined;
+export declare const isFloat64Array: (x: unknown) => x is Float64Array;
+export declare const isFloat32Array: (x: unknown) => x is Float32Array;
+export declare const isInt32Array: (x: unknown) => x is Int32Array;
+export declare const isUint32Array: (x: unknown) => x is Uint32Array;
+export declare const isUint8Array: (x: unknown) => x is Uint8Array;
+/**
+ * Check if value is a Complex number
+ */
+export declare const isComplex: (x: unknown) => x is Complex;
+/**
+ * Check if value is a Fraction
+ */
+export declare const isFraction: (x: unknown) => x is Fraction;
+/**
+ * Check if value is a BigNumber
+ */
+export declare const isBigNumber: (x: unknown) => x is BigNumber;
+/**
+ * Check if value is a Matrix (duck typing until Matrix class is implemented)
+ */
+export declare const isMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a DenseMatrix
+ */
+export declare const isDenseMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a SparseMatrix
+ */
+export declare const isSparseMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a Unit
+ *
+ * Recognises both the native {@link Unit} class (which exposes `value`,
+ * `dimensions`, and `notation`) and the legacy duck-typed shape used by
+ * mathjs-compatibility shims (`{ value, unit, type }`).
+ */
+export declare const isUnit: (x: unknown) => boolean;
+/**
+ * Extended type definition with optional WASM mask support
+ */
+export interface MathTSTypeDef extends TypeDef {
+    /** Optional WASM type mask for accelerated dispatch (auto-registered when WASM available) */
+    wasmMask?: number;
+}
+/**
+ * MathTS-specific types to add to typed-function.
+ * Note: Most primitive types (number, boolean, string, etc.) are already built into typed-function
+ *
+ * When WASM is available, custom type masks are automatically registered for efficient dispatch.
+ */
+export declare const MATHTS_TYPES: MathTSTypeDef[];
+export declare const MATHTS_CONVERSIONS: ConversionDef[];
+/**
+ * Create a new MathTS typed instance
+ *
+ * This creates an isolated typed universe with MathTS types and conversions.
+ * Uses typed-function's addType() API which automatically registers WASM
+ * type masks when available.
+ *
+ * @returns A new typed-function instance configured for MathTS
+ *
+ * @example
+ * ```typescript
+ * const myTyped = createMathTSTyped();
+ *
+ * const add = myTyped('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'Complex, Complex': (a, b) => a.add(b),
+ *   'Fraction, Fraction': (a, b) => a.add(b),
+ *   'BigNumber, BigNumber': (a, b) => a.add(b),
+ * });
+ * ```
+ */
+export declare function createMathTSTyped(): TypedInstance;
+/**
+ * Default MathTS typed instance
+ *
+ * This is the primary typed-function instance used throughout MathTS.
+ * It comes pre-configured with all MathTS types and conversions.
+ *
+ * @example
+ * ```typescript
+ * import { mathTyped, Complex, Fraction, BigNumber } from '@danielsimonjr/mathts-core';
+ *
+ * // Create a polymorphic add function
+ * const add = mathTyped('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'Complex, Complex': (a, b) => a.add(b),
+ *   'Fraction, Fraction': (a, b) => a.add(b),
+ *   'BigNumber, BigNumber': (a, b) => a.add(b),
+ * });
+ *
+ * // Works with automatic type coercion
+ * add(1, 2);                              // 3
+ * add(new Complex(1, 2), new Complex(3, 4)); // Complex(4, 6)
+ * add(new Fraction(1, 2), new Fraction(1, 3)); // Fraction(5, 6)
+ * add(1, new Complex(2, 3));              // Complex(3, 3) - auto-converts
+ * ```
+ */
+export declare const mathTyped: MathTSTyped;
+/**
+ * The default typed-function export (for creating functions without MathTS types)
+ */
+export { typed };
+/**
+ * Create a new typed-function instance (typed-function's create)
+ */
+export { create };
+/**
+ * TypeRegistry class for managing custom type registrations
+ * This is a MathTS utility, not from typed-function
+ */
+export declare class TypeRegistry {
+    private types;
+    private conversions;
+    private instance;
+    /**
+     * Register a new type
+     */
+    registerType<T>(name: string, test: (x: unknown) => x is T): this;
+    /**
+     * Register a type conversion
+     */
+    registerConversion<From, To>(from: string, to: string, convert: (value: From) => To): this;
+    /**
+     * Check if a type is registered
+     */
+    hasType(name: string): boolean;
+    /**
+     * Check if a conversion is registered
+     */
+    hasConversion(from: string, to: string): boolean;
+    /**
+     * Get all registered type names
+     */
+    getTypeNames(): string[];
+    /**
+     * Build a typed-function instance from the registry
+     */
+    build(): TypedInstance;
+    /**
+     * Clear all registered types and conversions
+     */
+    clear(): void;
+}
+/**
+ * Helper to create a typed function with the MathTS typed instance
+ */
+export declare function createTypedFunction<T>(name: string, signatures: {
+    [signature: string]: (...args: unknown[]) => T;
+}, typedInstance?: TypedInstance): (...args: unknown[]) => T;
+//# sourceMappingURL=mathts-typed.d.ts.map

package/dist/typed/mathts-typed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mathts-typed.d.ts","sourceRoot":"","sources":["../../src/typed/mathts-typed.ts"],"names":[],"mappings":"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"}

package/dist/typed/type-bridge.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Add duck-typing markers to the prototypes of the native Complex, Fraction and BigNumber classes.
+ *
+ * The function adds each marker only when the prototype does not have it.
+ * The markers are not writable, not enumerable and not configurable.
+ * Calls after the first call do nothing.
+ */
+export declare function registerNativeTypes(): void;
+//# sourceMappingURL=type-bridge.d.ts.map

package/dist/typed/type-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-bridge.d.ts","sourceRoot":"","sources":["../../src/typed/type-bridge.ts"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAyD1C"}