@danielsimonjr/mathts-core 0.10.0 → 0.11.0

package/dist/{chunk-2WW76EEF.js → chunk-PALIR4V6.js}

@@ -1342,6 +1342,127 @@ function isPath(str) {
   return str.includes(".");
 }
 
+// src/error/MathjsError.ts
+var MathjsError = class _MathjsError extends Error {
+  isMathjsError = true;
+  /**
+   * Create a MathjsError
+   * @param message  Error message
+   */
+  constructor(message) {
+    super(message);
+    this.name = "MathjsError";
+    const errorCtor = Error;
+    if (errorCtor.captureStackTrace) {
+      errorCtor.captureStackTrace(this, _MathjsError);
+    }
+  }
+};
+
+// src/factory.ts
+function factory(name2, dependencies2, create2, meta) {
+  function assertAndCreate(scope) {
+    const deps = pickShallow(scope, dependencies2.map(stripOptionalNotation));
+    assertDependencies(name2, dependencies2, scope);
+    return create2(deps);
+  }
+  assertAndCreate.isFactory = true;
+  assertAndCreate.fn = name2;
+  assertAndCreate.dependencies = dependencies2.slice().sort();
+  if (meta) {
+    assertAndCreate.meta = meta;
+  }
+  return assertAndCreate;
+}
+function sortFactories(factories) {
+  const factoriesByName = {};
+  factories.forEach((factory2) => {
+    const name2 = isFactory(factory2) ? factory2.fn : factory2.name;
+    factoriesByName[name2] = factory2;
+  });
+  const checkedForCycles = /* @__PURE__ */ new Set();
+  function checkCycles(fact, visiting, visited) {
+    if (isFactory(fact)) {
+      const factName = fact.fn;
+      if (visiting.has(factName)) {
+        throw new Error(`Circular dependency detected: ${factName}`);
+      }
+      if (visited.has(factName)) {
+        return;
+      }
+      visiting.add(factName);
+      fact.dependencies.forEach((d) => {
+        const depFactory = factoriesByName[d];
+        if (depFactory) {
+          checkCycles(depFactory, visiting, visited);
+        }
+      });
+      visiting.delete(factName);
+      visited.add(factName);
+    }
+  }
+  factories.forEach((factory2) => {
+    if (isFactory(factory2)) {
+      checkCycles(factory2, /* @__PURE__ */ new Set(), checkedForCycles);
+    }
+  });
+  function containsDependency(factory2, dependency) {
+    if (isFactory(factory2)) {
+      const depName = isFactory(dependency) ? dependency.fn : dependency.name;
+      if (factory2.dependencies.includes(depName)) {
+        return true;
+      }
+      if (factory2.dependencies.some((d) => {
+        const depFactory = factoriesByName[d];
+        return depFactory && containsDependency(depFactory, dependency);
+      })) {
+        return true;
+      }
+    }
+    return false;
+  }
+  const sorted = [];
+  function addFactory(factory2) {
+    let index = 0;
+    while (index < sorted.length && !containsDependency(sorted[index], factory2)) {
+      index++;
+    }
+    sorted.splice(index, 0, factory2);
+  }
+  factories.filter(isFactory).forEach(addFactory);
+  factories.filter((factory2) => !isFactory(factory2)).forEach(addFactory);
+  return sorted;
+}
+function create(factories, scope = {}) {
+  sortFactories(factories).forEach((factory2) => {
+    if (isFactory(factory2)) {
+      factory2(scope);
+    }
+  });
+  return scope;
+}
+function isFactory(obj) {
+  const f = obj;
+  return typeof obj === "function" && typeof f.fn === "string" && Array.isArray(f.dependencies);
+}
+function assertDependencies(name2, dependencies2, scope) {
+  const allDefined = dependencies2.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
+  if (!allDefined) {
+    const missingDependencies = dependencies2.filter(
+      (dependency) => scope[dependency] === void 0
+    );
+    throw new MathjsError(
+      `Cannot create function "${name2}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
+    );
+  }
+}
+function isOptionalDependency(dependency) {
+  return dependency[0] === "?";
+}
+function stripOptionalNotation(dependency) {
+  return dependency && dependency[0] === "?" ? dependency.slice(1) : dependency;
+}
+
 // src/types/fraction.ts
 function isFraction2(value) {
   return value instanceof Fraction;
@@ -3199,56 +3320,6 @@ var DimensionMismatchError = class extends Error {
   }
 };
 
-// src/error/MathjsError.ts
-var MathjsError = class _MathjsError extends Error {
-  isMathjsError = true;
-  /**
-   * Create a MathjsError
-   * @param message  Error message
-   */
-  constructor(message) {
-    super(message);
-    this.name = "MathjsError";
-    const errorCtor = Error;
-    if (errorCtor.captureStackTrace) {
-      errorCtor.captureStackTrace(this, _MathjsError);
-    }
-  }
-};
-
-// src/factory.ts
-function factory(name2, dependencies2, create, meta) {
-  function assertAndCreate(scope) {
-    const deps = pickShallow(scope, dependencies2.map(stripOptionalNotation));
-    assertDependencies(name2, dependencies2, scope);
-    return create(deps);
-  }
-  assertAndCreate.isFactory = true;
-  assertAndCreate.fn = name2;
-  assertAndCreate.dependencies = dependencies2.slice().sort();
-  if (meta) {
-    assertAndCreate.meta = meta;
-  }
-  return assertAndCreate;
-}
-function assertDependencies(name2, dependencies2, scope) {
-  const allDefined = dependencies2.filter((dependency) => !isOptionalDependency(dependency)).every((dependency) => scope[dependency] !== void 0);
-  if (!allDefined) {
-    const missingDependencies = dependencies2.filter(
-      (dependency) => scope[dependency] === void 0
-    );
-    throw new MathjsError(
-      `Cannot create function "${name2}", some dependencies are missing: ${missingDependencies.map((d) => `"${d}"`).join(", ")}.`
-    );
-  }
-}
-function isOptionalDependency(dependency) {
-  return dependency[0] === "?";
-}
-function stripOptionalNotation(dependency) {
-  return dependency && dependency[0] === "?" ? dependency.slice(1) : dependency;
-}
-
 // src/types/unit/Unit.ts
 function normalizeDegreeSymbols(s) {
   return s.replace(/°C/g, "degC").replace(/°F/g, "degF").replace(/°/g, "deg");
@@ -6335,7 +6406,14 @@ export {
   set,
   pick,
   pickShallow,
+  MathjsError,
   factory,
+  sortFactories,
+  create,
+  isFactory,
+  assertDependencies,
+  isOptionalDependency,
+  stripOptionalNotation,
   isFraction2,
   Fraction,
   FRACTION_ZERO,

package/dist/{index-zKEDY9aj.d.ts → index-B4LIOfHN.d.ts}

@@ -8,6 +8,17 @@ interface FactoryFunction<TResult = unknown> {
     dependencies: string[];
     meta?: FactoryMeta;
 }
+/**
+ * Type for legacy factory objects (old-style factories)
+ */
+interface LegacyFactory {
+    type?: string;
+    name: string;
+    factory: (...args: unknown[]) => unknown;
+    math?: boolean;
+    dependencies?: string[];
+    meta?: FactoryMeta;
+}
 /**
  * Meta information that can be attached to a factory
  */
@@ -25,6 +36,79 @@ interface FactoryMeta {
      */
     [key: string]: unknown;
 }
+/**
+ * Type for dependency names, which can be optional (prefixed with '?')
+ */
+type DependencyName = string;
+/**
+ * Type for the create callback function
+ */
+type CreateFunction<TDeps extends Record<string, unknown>, TResult> = (dependencies: TDeps) => TResult;
+/**
+ * Create a factory function, which can be used to inject dependencies.
+ *
+ * The created functions are memoized, a consecutive call of the factory
+ * with the exact same inputs will return the same function instance.
+ * The memoized cache is exposed on `factory.cache` and can be cleared
+ * if needed.
+ *
+ * Example:
+ *
+ *     const name = 'log'
+ *     const dependencies = ['config', 'typed', 'divideScalar', 'Complex']
+ *
+ *     export const createLog = factory(name, dependencies, ({ typed, config, divideScalar, Complex }) => {
+ *       // ... create the function log here and return it
+ *     }
+ *
+ * @param name           Name of the function to be created
+ * @param dependencies   The names of all required dependencies
+ * @param create         Callback function called with an object with all dependencies
+ * @param meta           Optional object with meta information that will be attached
+ *                       to the created factory function as property `meta`. For explanation
+ *                       of what meta properties can be specified and what they mean, see
+ *                       docs/core/extension.md.
+ * @returns The factory function
+ */
+declare function factory<TDeps extends Record<string, unknown> = Record<string, unknown>, TResult = unknown>(name: string, dependencies: DependencyName[], create: CreateFunction<TDeps, TResult>, meta?: FactoryMeta): FactoryFunction<TResult>;
+/**
+ * Sort all factories such that when loading in order, the dependencies are resolved.
+ *
+ * @param factories Array of factory functions or legacy factories
+ * @returns Returns a new array with the sorted factories
+ */
+declare function sortFactories(factories: Array<FactoryFunction | LegacyFactory>): Array<FactoryFunction | LegacyFactory>;
+declare function create(factories: Array<FactoryFunction | LegacyFactory>, scope?: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Test whether an object is a factory. This is the case when it has
+ * properties name, dependencies, and a function create.
+ * @param obj Any value to test
+ * @returns true if obj is a factory function
+ */
+declare function isFactory(obj: unknown): obj is FactoryFunction;
+/**
+ * Assert that all dependencies of a list with dependencies are available in the provided scope.
+ *
+ * Will throw an exception when there are dependencies missing.
+ *
+ * @param name         Name for the function to be created. Used to generate a useful error message
+ * @param dependencies Array of dependency names
+ * @param scope        Object containing the available dependencies
+ * @throws Error if required dependencies are missing
+ */
+declare function assertDependencies(name: string, dependencies: DependencyName[], scope: Record<string, unknown>): void;
+/**
+ * Check if a dependency is optional (starts with '?')
+ * @param dependency The dependency name to check
+ * @returns true if the dependency is optional
+ */
+declare function isOptionalDependency(dependency: DependencyName): boolean;
+/**
+ * Remove the optional notation '?' from a dependency name
+ * @param dependency The dependency name
+ * @returns The dependency name without optional notation
+ */
+declare function stripOptionalNotation(dependency: DependencyName): string;
 
 interface BigNumber {
     isBigNumber: boolean;
@@ -362,4 +446,4 @@ interface UnitConstructor {
 /** The core `Unit` class, pre-wired to core's numeric primitives. */
 declare const Unit: UnitConstructor;
 
-export { isMatrix as $, type UnitJSON as A, type BaseUnitDef as B, type Complex as C, type DenseMatrix as D, type UnitSystem as E, type FactoryFunction as F, type UnitSystemEntry as G, isArray as H, type Index as I, isBigInt as J, isBigNumber as K, isBoolean as L, type Matrix as M, type Numeric as N, isCollection as O, type ParseOptions as P, isComplex as Q, type Range as R, type ScalarBinaryOp as S, type TypeConverters as T, Unit as U, isDate as V, isDenseMatrix as W, isFraction as X, isFunction as Y, isIndex as Z, isMap as _, type UnitInstance as a, isNull as a0, isNumber as a1, isObject as a2, isRange as a3, isRegExp as a4, isSparseMatrix as a5, isString as a6, isUndefined as a7, typeOf as a8, 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 Fraction as m, type FractionConstructor as n, type FractionValue as o, type IndexDimension as p, type PrefixDef as q, type PrefixTable as r, type ScalarUnaryOp as s, type SparseMatrix as t, type SubtractScalar as u, type Unit$1 as v, type UnitComponent as w, type UnitConfig as x, type UnitDef as y, type UnitFormatOptions as z };
+export { isDate as $, type UnitDef as A, type BaseUnitDef as B, type Complex as C, type DenseMatrix as D, type UnitFormatOptions as E, type FactoryFunction as F, type UnitJSON as G, type UnitSystem as H, type Index as I, type UnitSystemEntry as J, assertDependencies as K, type LegacyFactory as L, type Matrix as M, type Numeric as N, create as O, type ParseOptions as P, factory as Q, type Range as R, type ScalarBinaryOp as S, type TypeConverters as T, Unit as U, isArray as V, isBigInt as W, isBigNumber as X, isBoolean as Y, isCollection as Z, isComplex as _, type UnitInstance as a, isDenseMatrix as a0, isFactory as a1, isFraction as a2, isFunction as a3, isIndex as a4, isMap as a5, isMatrix as a6, isNull as a7, isNumber as a8, isObject as a9, isOptionalDependency as aa, isRange as ab, isRegExp as ac, isSparseMatrix as ad, isString as ae, isUndefined as af, sortFactories as ag, stripOptionalNotation as ah, typeOf as ai, type UnitConstructor as b, type UnitDependencies as c, type BigNumber as d, type BigNumberConstructor as e, type ComplexConstructor as f, type ComplexValue as g, type ConverterFn as h, isUnit as i, type CreateFunction as j, type CreateUnitDefObject as k, type CreateUnitOptions as l, type DependencyName as m, type FactoryMeta as n, type Fraction as o, type FractionConstructor as p, type FractionValue as q, type IndexDimension as r, type PrefixDef as s, type PrefixTable as t, type ScalarUnaryOp as u, type SparseMatrix as v, type SubtractScalar as w, type Unit$1 as x, type UnitComponent as y, type UnitConfig as z };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { F as FactoryFunction$1 } from './index-zKEDY9aj.js';
-export { U as Unit, a as UnitInstance, i as isUnitValue } from './index-zKEDY9aj.js';
+import { F as FactoryFunction$1 } from './index-B4LIOfHN.js';
+export { U as Unit, a as UnitInstance, i as isUnitValue } from './index-B4LIOfHN.js';
 import { TypedInstance, ReferTo, ReferToSelf, TypedFunction, SignatureFunction } from 'typed-function';
 export { ReferTo, ReferToSelf, SignatureFunction, TypedFunction, TypedInstance, create, default as typed } from 'typed-function';
 

package/dist/index.js

@@ -44,7 +44,7 @@ import {
   round,
   sign,
   subtractScalar
-} from "./chunk-2WW76EEF.js";
+} from "./chunk-PALIR4V6.js";
 
 // src/types/matrix/Range.ts
 var name = "Range";