@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/browser-verify.js

@@ -59,6 +59,9 @@ export class BrowserVerifier {
    * @throws {Error} If Playwright is not installed
    */
   async init(options = {}) {
+    if (options !== null && typeof options !== "object") {
+      throw new Error("options must be an object");
+    }
     await loadPlaywright();
     this.browser = await chromium.launch(options);
     this.page = await this.browser.newPage();
@@ -93,6 +96,23 @@ export class BrowserVerifier {
     if (!this.page) {
       throw new Error("BrowserVerifier not initialized. Call init() first.");
     }
+    if (!config || typeof config !== "object") {
+      throw new Error("config must be a valid object");
+    }
+    if (
+      typeof config.width !== "number" ||
+      !isFinite(config.width) ||
+      config.width <= 0
+    ) {
+      throw new Error("config.width must be a positive finite number");
+    }
+    if (
+      typeof config.height !== "number" ||
+      !isFinite(config.height) ||
+      config.height <= 0
+    ) {
+      throw new Error("config.height must be a positive finite number");
+    }
 
     return await this.page.evaluate((cfg) => {
       const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
@@ -117,6 +137,9 @@ export class BrowserVerifier {
       const ctm = rect.getCTM();
       document.body.removeChild(svg);
 
+      if (!ctm) {
+        throw new Error("getCTM() returned null");
+      }
       return { a: ctm.a, b: ctm.b, c: ctm.c, d: ctm.d, e: ctm.e, f: ctm.f };
     }, config);
   }
@@ -131,6 +154,23 @@ export class BrowserVerifier {
     if (!this.page) {
       throw new Error("BrowserVerifier not initialized. Call init() first.");
     }
+    if (!config || typeof config !== "object") {
+      throw new Error("config must be a valid object");
+    }
+    if (
+      typeof config.width !== "number" ||
+      !isFinite(config.width) ||
+      config.width <= 0
+    ) {
+      throw new Error("config.width must be a positive finite number");
+    }
+    if (
+      typeof config.height !== "number" ||
+      !isFinite(config.height) ||
+      config.height <= 0
+    ) {
+      throw new Error("config.height must be a positive finite number");
+    }
 
     return await this.page.evaluate((cfg) => {
       const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
@@ -155,6 +195,9 @@ export class BrowserVerifier {
       const ctm = rect.getScreenCTM();
       document.body.removeChild(svg);
 
+      if (!ctm) {
+        throw new Error("getScreenCTM() returned null");
+      }
       return { a: ctm.a, b: ctm.b, c: ctm.c, d: ctm.d, e: ctm.e, f: ctm.f };
     }, config);
   }
@@ -171,6 +214,29 @@ export class BrowserVerifier {
     if (!this.page) {
       throw new Error("BrowserVerifier not initialized. Call init() first.");
     }
+    if (!config || typeof config !== "object") {
+      throw new Error("config must be a valid object");
+    }
+    if (
+      typeof config.width !== "number" ||
+      !isFinite(config.width) ||
+      config.width <= 0
+    ) {
+      throw new Error("config.width must be a positive finite number");
+    }
+    if (
+      typeof config.height !== "number" ||
+      !isFinite(config.height) ||
+      config.height <= 0
+    ) {
+      throw new Error("config.height must be a positive finite number");
+    }
+    if (typeof x !== "number" || !isFinite(x)) {
+      throw new Error("x must be a finite number");
+    }
+    if (typeof y !== "number" || !isFinite(y)) {
+      throw new Error("y must be a finite number");
+    }
 
     return await this.page.evaluate(
       ({ cfg, px, py }) => {
@@ -194,6 +260,9 @@ export class BrowserVerifier {
         document.body.appendChild(svg);
 
         const ctm = rect.getCTM();
+        if (!ctm) {
+          throw new Error("getCTM() returned null");
+        }
         const point = svg.createSVGPoint();
         point.x = px;
         point.y = py;
@@ -216,6 +285,40 @@ export class BrowserVerifier {
    * @returns {Promise<{matches: boolean, browserCTM: Object, libraryCTM: Object, differences: Object}>}
    */
   async verifyMatrix(matrix, config, tolerance = 1e-10) {
+    if (!matrix || typeof matrix !== "object") {
+      throw new Error("matrix must be a valid Matrix object");
+    }
+    if (!matrix.data || !Array.isArray(matrix.data)) {
+      throw new Error("matrix.data must be a valid array");
+    }
+    if (
+      matrix.data.length < 2 ||
+      !Array.isArray(matrix.data[0]) ||
+      matrix.data[0].length < 3 ||
+      !Array.isArray(matrix.data[1]) ||
+      matrix.data[1].length < 3
+    ) {
+      throw new Error(
+        "matrix.data must have at least 2 rows with at least 3 columns each",
+      );
+    }
+    if (typeof tolerance !== "number" || !isFinite(tolerance) || tolerance < 0) {
+      throw new Error("tolerance must be a non-negative finite number");
+    }
+    // Validate that matrix.data contains Decimal objects with toNumber() method
+    if (
+      typeof matrix.data[0][0].toNumber !== "function" ||
+      typeof matrix.data[1][0].toNumber !== "function" ||
+      typeof matrix.data[0][1].toNumber !== "function" ||
+      typeof matrix.data[1][1].toNumber !== "function" ||
+      typeof matrix.data[0][2].toNumber !== "function" ||
+      typeof matrix.data[1][2].toNumber !== "function"
+    ) {
+      throw new Error(
+        "matrix.data elements must have toNumber() method (Decimal objects)",
+      );
+    }
+
     const browserCTM = await this.getBrowserCTM(config);
 
     const libraryCTM = {
@@ -258,9 +361,41 @@ export class BrowserVerifier {
     preserveAspectRatio = "xMidYMid meet",
     tolerance = 1e-10,
   ) {
-    const vb = SVGFlatten.parseViewBox(viewBox);
-    const par = SVGFlatten.parsePreserveAspectRatio(preserveAspectRatio);
-    const matrix = SVGFlatten.computeViewBoxTransform(vb, width, height, par);
+    if (typeof width !== "number" || !isFinite(width) || width <= 0) {
+      throw new Error("width must be a positive finite number");
+    }
+    if (typeof height !== "number" || !isFinite(height) || height <= 0) {
+      throw new Error("height must be a positive finite number");
+    }
+    if (typeof viewBox !== "string" || viewBox.trim().length === 0) {
+      throw new Error("viewBox must be a non-empty string");
+    }
+    if (
+      typeof preserveAspectRatio !== "string" ||
+      preserveAspectRatio.trim().length === 0
+    ) {
+      throw new Error("preserveAspectRatio must be a non-empty string");
+    }
+    if (typeof tolerance !== "number" || !isFinite(tolerance) || tolerance < 0) {
+      throw new Error("tolerance must be a non-negative finite number");
+    }
+
+    let vb, par, matrix;
+    try {
+      vb = SVGFlatten.parseViewBox(viewBox);
+    } catch (e) {
+      throw new Error(`Failed to parse viewBox: ${e.message}`);
+    }
+    try {
+      par = SVGFlatten.parsePreserveAspectRatio(preserveAspectRatio);
+    } catch (e) {
+      throw new Error(`Failed to parse preserveAspectRatio: ${e.message}`);
+    }
+    try {
+      matrix = SVGFlatten.computeViewBoxTransform(vb, width, height, par);
+    } catch (e) {
+      throw new Error(`Failed to compute viewBox transform: ${e.message}`);
+    }
 
     return await this.verifyMatrix(
       matrix,
@@ -282,7 +417,19 @@ export class BrowserVerifier {
    * @returns {Promise<{matches: boolean, browserCTM: Object, libraryCTM: Object, differences: Object}>}
    */
   async verifyTransformAttribute(transform, tolerance = 1e-10) {
-    const matrix = SVGFlatten.parseTransformAttribute(transform);
+    if (typeof transform !== "string" || transform.trim().length === 0) {
+      throw new Error("transform must be a non-empty string");
+    }
+    if (typeof tolerance !== "number" || !isFinite(tolerance) || tolerance < 0) {
+      throw new Error("tolerance must be a non-negative finite number");
+    }
+
+    let matrix;
+    try {
+      matrix = SVGFlatten.parseTransformAttribute(transform);
+    } catch (e) {
+      throw new Error(`Failed to parse transform attribute: ${e.message}`);
+    }
 
     // Use a simple 100x100 SVG without viewBox to test just the transform
     return await this.verifyMatrix(
@@ -307,9 +454,35 @@ export class BrowserVerifier {
    * @returns {Promise<{matches: boolean, browserPoint: Object, libraryPoint: Object, difference: number}>}
    */
   async verifyPointTransform(matrix, x, y, config, tolerance = 1e-10) {
+    if (!matrix || typeof matrix !== "object") {
+      throw new Error("matrix must be a valid Matrix object");
+    }
+    if (typeof x !== "number" || !isFinite(x)) {
+      throw new Error("x must be a finite number");
+    }
+    if (typeof y !== "number" || !isFinite(y)) {
+      throw new Error("y must be a finite number");
+    }
+    if (!config || typeof config !== "object") {
+      throw new Error("config must be a valid object");
+    }
+    if (typeof tolerance !== "number" || !isFinite(tolerance) || tolerance < 0) {
+      throw new Error("tolerance must be a non-negative finite number");
+    }
+
     const browserPoint = await this.transformPoint(config, x, y);
     const libraryPoint = SVGFlatten.applyToPoint(matrix, x, y);
 
+    if (
+      !libraryPoint ||
+      !libraryPoint.x ||
+      !libraryPoint.y ||
+      typeof libraryPoint.x.toNumber !== "function" ||
+      typeof libraryPoint.y.toNumber !== "function"
+    ) {
+      throw new Error("applyToPoint returned invalid result");
+    }
+
     const libPt = {
       x: libraryPoint.x.toNumber(),
       y: libraryPoint.y.toNumber(),
@@ -336,11 +509,38 @@ export class BrowserVerifier {
    * @returns {Promise<{passed: number, failed: number, results: Array}>}
    */
   async runBatch(testCases, tolerance = 1e-10) {
+    if (!Array.isArray(testCases)) {
+      throw new Error("testCases must be an array");
+    }
+    if (typeof tolerance !== "number" || !isFinite(tolerance) || tolerance < 0) {
+      throw new Error("tolerance must be a non-negative finite number");
+    }
+
     const results = [];
     let passed = 0;
     let failed = 0;
 
     for (const tc of testCases) {
+      if (!tc || typeof tc !== "object") {
+        throw new Error("Each test case must be a valid object");
+      }
+      if (
+        typeof tc.width !== "number" ||
+        !isFinite(tc.width) ||
+        tc.width <= 0
+      ) {
+        throw new Error("Each test case must have a positive finite width");
+      }
+      if (
+        typeof tc.height !== "number" ||
+        !isFinite(tc.height) ||
+        tc.height <= 0
+      ) {
+        throw new Error("Each test case must have a positive finite height");
+      }
+      if (typeof tc.viewBox !== "string" || tc.viewBox.trim().length === 0) {
+        throw new Error("Each test case must have a non-empty viewBox string");
+      }
       const result = await this.verifyViewBoxTransform(
         tc.width,
         tc.height,
@@ -372,6 +572,16 @@ export class BrowserVerifier {
  * @returns {Promise<boolean>} True if matrix matches browser's CTM
  */
 export async function quickVerify(matrix, config, tolerance = 1e-10) {
+  if (!matrix || typeof matrix !== "object") {
+    throw new Error("matrix must be a valid Matrix object");
+  }
+  if (!config || typeof config !== "object") {
+    throw new Error("config must be a valid object");
+  }
+  if (typeof tolerance !== "number" || !isFinite(tolerance) || tolerance < 0) {
+    throw new Error("tolerance must be a non-negative finite number");
+  }
+
   const verifier = new BrowserVerifier();
   await verifier.init({ headless: true });
 
@@ -398,6 +608,22 @@ export async function verifyViewBox(
   viewBox,
   preserveAspectRatio = "xMidYMid meet",
 ) {
+  if (typeof width !== "number" || !isFinite(width) || width <= 0) {
+    throw new Error("width must be a positive finite number");
+  }
+  if (typeof height !== "number" || !isFinite(height) || height <= 0) {
+    throw new Error("height must be a positive finite number");
+  }
+  if (typeof viewBox !== "string" || viewBox.trim().length === 0) {
+    throw new Error("viewBox must be a non-empty string");
+  }
+  if (
+    typeof preserveAspectRatio !== "string" ||
+    preserveAspectRatio.trim().length === 0
+  ) {
+    throw new Error("preserveAspectRatio must be a non-empty string");
+  }
+
   const verifier = new BrowserVerifier();
   await verifier.init({ headless: true });
 
@@ -420,6 +646,10 @@ export async function verifyViewBox(
  * @returns {Promise<{matches: boolean, browserCTM: Object, libraryCTM: Object}>}
  */
 export async function verifyTransform(transform) {
+  if (typeof transform !== "string" || transform.trim().length === 0) {
+    throw new Error("transform must be a non-empty string");
+  }
+
   const verifier = new BrowserVerifier();
   await verifier.init({ headless: true });
 
@@ -439,6 +669,9 @@ export async function verifyTransform(transform) {
  * @returns {Promise<{passed: number, failed: number, results: Array}>}
  */
 export async function runStandardTests(options = { verbose: true }) {
+  if (!options || typeof options !== "object") {
+    throw new Error("options must be a valid object");
+  }
   const testCases = [
     // W3C SVG WG issue #215 cases
     {