@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/vector.js

@@ -5,8 +5,19 @@ import Decimal from 'decimal.js';
  * Accepts numbers, strings, or Decimal instances.
  * @param {number|string|Decimal} x - The value to convert
  * @returns {Decimal} The Decimal representation
+ * @throws {Error} If x is null, undefined, or cannot be converted to Decimal
  */
-const D = x => (x instanceof Decimal ? x : new Decimal(x));
+const D = x => {
+  if (x === null || x === undefined) {
+    throw new Error(`Cannot convert ${x === null ? 'null' : 'undefined'} to Decimal`);
+  }
+  if (x instanceof Decimal) return x;
+  try {
+    return new Decimal(x);
+  } catch (err) {
+    throw new Error(`Invalid numeric value: ${err.message}`);
+  }
+};
 
 /**
  * Vector - Decimal-backed vector class for arbitrary-precision vector operations.
@@ -28,11 +39,21 @@ export class Vector {
   /**
    * Create a new Vector from an array of components.
    * @param {Array<number|string|Decimal>} components - Array of vector components
-   * @throws {Error} If components is not an array
+   * @throws {Error} If components is not an array, is empty, or contains invalid values
    */
   constructor(components) {
     if (!Array.isArray(components)) throw new Error('Vector requires array');
-    this.data = components.map(c => D(c));
+    if (components.length === 0) throw new Error('Vector requires at least one component');
+    try {
+      this.data = components.map((c, i) => {
+        if (c === null || c === undefined) {
+          throw new Error(`Vector component at index ${i} is ${c === null ? 'null' : 'undefined'}`);
+        }
+        return D(c);
+      });
+    } catch (err) {
+      throw new Error(`Vector constructor failed: ${err.message}`);
+    }
     this.length = this.data.length;
   }
 
@@ -40,8 +61,12 @@ export class Vector {
    * Factory method to create a Vector from an array.
    * @param {Array<number|string|Decimal>} arr - Array of vector components
    * @returns {Vector} New Vector instance
+   * @throws {Error} If arr is null or undefined
    */
   static from(arr) {
+    if (arr === null || arr === undefined) {
+      throw new Error(`Vector.from: argument is ${arr === null ? 'null' : 'undefined'}`);
+    }
     return new Vector(arr);
   }
 
@@ -116,9 +141,18 @@ export class Vector {
    * Scalar multiplication.
    * @param {number|string|Decimal} scalar - Scalar to multiply by
    * @returns {Vector} New scaled Vector
+   * @throws {Error} If scalar is null, undefined, or invalid
    */
   scale(scalar) {
-    const s = D(scalar);
+    if (scalar === null || scalar === undefined) {
+      throw new Error(`scale: scalar is ${scalar === null ? 'null' : 'undefined'}`);
+    }
+    let s;
+    try {
+      s = D(scalar);
+    } catch (err) {
+      throw new Error(`scale: invalid scalar - ${err.message}`);
+    }
     return new Vector(this.data.map(v => v.mul(s)));
   }
 
@@ -156,12 +190,15 @@ export class Vector {
    *
    * @param {Vector} other - Vector to compute outer product with
    * @returns {Decimal[][]} 2D array of Decimals (can be passed to Matrix.from())
-   * @throws {Error} If other is not a Vector
+   * @throws {Error} If other is not a Vector or either vector is empty
    */
   outer(other) {
     if (!other || !(other instanceof Vector)) {
       throw new Error('outer: argument must be a Vector');
     }
+    if (this.length === 0 || other.length === 0) {
+      throw new Error('outer: cannot compute outer product with empty vector');
+    }
     const rows = this.length, cols = other.length;
     const out = Array.from({ length: rows }, (_, i) =>
       Array.from({ length: cols }, (_, j) => this.data[i].mul(other.data[j]))
@@ -267,8 +304,12 @@ export class Vector {
    * @throws {Error} If unable to find orthogonal vector (e.g., zero vector)
    */
   orthogonal() {
+    const n = this.norm();
+    if (n.isZero()) {
+      throw new Error('orthogonal: cannot find orthogonal vector to zero vector');
+    }
     if (this.length === 2) {
-      // 2D perpendicular: rotate 90 degrees counterclockwise
+      // 2D perpendicular: rotate 90 degrees counterclockwise [-y, x]
       return new Vector([this.data[1].negated(), this.data[0]]);
     }
     // For n > 2: find a standard basis vector not parallel to this,
@@ -282,7 +323,7 @@ export class Vector {
       const orthNorm = orth.norm();
       if (!orthNorm.isZero()) return orth.normalize();
     }
-    throw new Error('Unable to find orthogonal vector');
+    throw new Error('orthogonal: unable to find orthogonal vector (degenerate case)');
   }
 
   /**
@@ -322,11 +363,26 @@ export class Vector {
    * @param {Vector} other - Vector to compare with
    * @param {number|string|Decimal} [tolerance=0] - Maximum allowed difference per component
    * @returns {boolean} True if vectors are equal within tolerance
+   * @throws {Error} If tolerance is invalid (null, NaN, or negative)
    */
   equals(other, tolerance = 0) {
     if (!(other instanceof Vector)) return false;
     if (other.length !== this.length) return false;
-    const tol = D(tolerance);
+    if (tolerance === null) {
+      throw new Error('equals: tolerance cannot be null');
+    }
+    let tol;
+    try {
+      tol = D(tolerance);
+      if (tol.isNaN()) {
+        throw new Error('equals: tolerance cannot be NaN');
+      }
+      if (tol.isNegative()) {
+        throw new Error('equals: tolerance must be non-negative');
+      }
+    } catch (err) {
+      throw new Error(`equals: invalid tolerance - ${err.message}`);
+    }
     for (let i = 0; i < this.length; i++) {
       const diff = this.data[i].minus(other.data[i]).abs();
       if (diff.greaterThan(tol)) return false;