mathjs 14.7.0 → 14.8.0

package/lib/esm/expression/transform/nullish.transform.js

@@ -0,0 +1,37 @@
+import { createNullish } from '../../function/logical/nullish.js';
+import { factory } from '../../utils/factory.js';
+import { isCollection } from '../../utils/is.js';
+var name = 'nullish';
+var dependencies = ['typed', 'matrix', 'size', 'flatten', 'deepEqual'];
+export var createNullishTransform = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    size,
+    flatten,
+    deepEqual
+  } = _ref;
+  var nullish = createNullish({
+    typed,
+    matrix,
+    size,
+    flatten,
+    deepEqual
+  });
+  function nullishTransform(args, math, scope) {
+    var left = args[0].compile().evaluate(scope);
+
+    // If left is not a collection and not nullish, short-circuit and return it
+    if (!isCollection(left) && left != null && left !== undefined) {
+      return left;
+    }
+
+    // Otherwise evaluate right and apply full nullish semantics (incl. element-wise)
+    var right = args[1].compile().evaluate(scope);
+    return nullish(left, right);
+  }
+  nullishTransform.rawArgs = true;
+  return nullishTransform;
+}, {
+  isTransformFunction: true
+});

package/lib/esm/factoriesAny.js

@@ -66,6 +66,7 @@ export { createConj } from './function/complex/conj.js';
 export { createIm } from './function/complex/im.js';
 export { createRe } from './function/complex/re.js';
 export { createNot } from './function/logical/not.js';
+export { createNullish } from './function/logical/nullish.js';
 export { createOr } from './function/logical/or.js';
 export { createXor } from './function/logical/xor.js';
 export { createConcat } from './function/matrix/concat.js';
@@ -294,5 +295,6 @@ export { createVarianceTransform } from './expression/transform/variance.transfo
 export { createPrintTransform } from './expression/transform/print.transform.js';
 export { createAndTransform } from './expression/transform/and.transform.js';
 export { createOrTransform } from './expression/transform/or.transform.js';
+export { createNullishTransform } from './expression/transform/nullish.transform.js';
 export { createBitAndTransform } from './expression/transform/bitAnd.transform.js';
 export { createBitOrTransform } from './expression/transform/bitOr.transform.js';

package/lib/esm/function/logical/nullish.js

@@ -0,0 +1,81 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
+import { createMatAlgo13xDD } from '../../type/matrix/utils/matAlgo13xDD.js';
+import { DimensionError } from '../../error/DimensionError.js';
+var name = 'nullish';
+var dependencies = ['typed', 'matrix', 'size', 'flatten', 'deepEqual'];
+export var createNullish = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    size,
+    flatten,
+    deepEqual
+  } = _ref;
+  var matAlgo03xDSf = createMatAlgo03xDSf({
+    typed
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  var matAlgo13xDD = createMatAlgo13xDD({
+    typed
+  });
+
+  /**
+   * Nullish coalescing operator (??). Returns the right-hand side operand
+   * when the left-hand side operand is null or undefined, and otherwise
+   * returns the left-hand side operand.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.nullish(x, y)
+   *
+   * Examples:
+   *
+   *    math.nullish(null, 42)        // returns 42
+   *    math.nullish(undefined, 42)   // returns 42
+   *    math.nullish(0, 42)           // returns 0
+   *    math.nullish(false, 42)       // returns false
+   *    math.nullish('', 42)          // returns ''
+   *
+   *    // Object property access with fallback
+   *    const obj = {foo: 7, bar: 3}
+   *    math.nullish(obj.baz, 0)      // returns 0
+   *
+   * See also:
+   *
+   *    and, or, not
+   *
+   * @param  {*} x First value to check
+   * @param  {*} y Fallback value
+   * @return {*} Returns y when x is null or undefined, otherwise returns x
+   */
+
+  return typed(name, {
+    // Scalar and SparseMatrix-first short-circuit handlers
+    'number|bigint|Complex|BigNumber|Fraction|Unit|string|boolean|SparseMatrix, any': (x, _y) => x,
+    'null, any': (_x, y) => y,
+    'undefined, any': (_x, y) => y,
+    // SparseMatrix-first with collection RHS: enforce exact shape match
+    'SparseMatrix, Array | Matrix': (x, y) => {
+      var sx = flatten(size(x).valueOf()); // work around #3529/#3530
+      var sy = flatten(size(y).valueOf());
+      if (deepEqual(sx, sy)) return x;
+      throw new DimensionError(sx, sy);
+    },
+    // DenseMatrix-first handlers (no broadcasting between collections)
+    'DenseMatrix, DenseMatrix': typed.referToSelf(self => (x, y) => matAlgo13xDD(x, y, self)),
+    'DenseMatrix, SparseMatrix': typed.referToSelf(self => (x, y) => matAlgo03xDSf(x, y, self, false)),
+    'DenseMatrix, Array': typed.referToSelf(self => (x, y) => matAlgo13xDD(x, matrix(y), self)),
+    'DenseMatrix, any': typed.referToSelf(self => (x, y) => matAlgo14xDs(x, y, self, false)),
+    // Array-first handlers (bridge via matrix() where needed)
+    'Array, Array': typed.referToSelf(self => (x, y) => matAlgo13xDD(matrix(x), matrix(y), self).valueOf()),
+    'Array, DenseMatrix': typed.referToSelf(self => (x, y) => matAlgo13xDD(matrix(x), y, self)),
+    'Array, SparseMatrix': typed.referToSelf(self => (x, y) => matAlgo03xDSf(matrix(x), y, self, false)),
+    'Array, any': typed.referToSelf(self => (x, y) => matAlgo14xDs(matrix(x), y, self, false).valueOf())
+  });
+});

package/lib/esm/version.js

@@ -1,3 +1,3 @@
-export var version = '14.7.0';
+export var version = '14.8.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "14.7.0",
+  "version": "14.8.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -36,7 +36,7 @@
     "typed-function": "^4.2.1"
   },
   "devDependencies": {
-    "@babel/core": "7.28.3",
+    "@babel/core": "7.28.4",
     "@babel/plugin-transform-object-assign": "7.27.1",
     "@babel/plugin-transform-optional-catch-binding": "7.27.1",
     "@babel/plugin-transform-runtime": "7.28.3",
@@ -44,13 +44,13 @@
     "@babel/register": "7.28.3",
     "@types/assert": "1.5.11",
     "@types/mocha": "10.0.10",
-    "@typescript-eslint/eslint-plugin": "8.42.0",
-    "@typescript-eslint/parser": "8.42.0",
+    "@typescript-eslint/eslint-plugin": "8.44.1",
+    "@typescript-eslint/parser": "8.44.1",
     "assert": "2.1.0",
     "babel-loader": "10.0.0",
     "c8": "10.1.3",
     "codecov": "3.8.3",
-    "del": "8.0.0",
+    "del": "8.0.1",
     "eigen": "0.2.2",
     "es-check": "9.3.1",
     "eslint": "8.57.1",