@emasoft/svg-matrix 1.2.1 → 1.3.1

package/src/transform-optimization.js

@@ -196,6 +196,97 @@ export function matricesEqual(m1, m2, tolerance = VERIFICATION_TOLERANCE) {
   return matrixMaxDifference(m1, m2).lessThan(D(tolerance));
 }
 
+/**
+ * Compute the combined matrix from a list of transform objects.
+ * Used internally for verification that optimizations preserve the transform result.
+ *
+ * @param {Array<Object>} transforms - Array of transform objects with type and params
+ * @returns {Matrix} Combined 3x3 transformation matrix
+ *
+ * @example
+ * const transforms = [
+ *   { type: 'translate', params: { tx: 10, ty: 20 } },
+ *   { type: 'rotate', params: { angle: 0.5 } }
+ * ];
+ * const combined = computeCombinedMatrix(transforms);
+ */
+export function computeCombinedMatrix(transforms) {
+  let combined = identityMatrix();
+
+  for (const t of transforms) {
+    // Validate transform object structure
+    if (
+      !t ||
+      typeof t !== "object" ||
+      !t.type ||
+      !t.params ||
+      typeof t.params !== "object"
+    ) {
+      continue; // Skip malformed transforms
+    }
+
+    let m = null;
+    switch (t.type) {
+      case "translate":
+        if (
+          t.params.tx === null ||
+          t.params.tx === undefined ||
+          t.params.ty === null ||
+          t.params.ty === undefined
+        ) {
+          continue; // Skip transforms with missing params
+        }
+        m = translationMatrix(t.params.tx, t.params.ty);
+        break;
+      case "rotate":
+        if (t.params.angle === null || t.params.angle === undefined) {
+          continue; // Skip transforms with missing angle
+        }
+        if (
+          t.params.cx !== undefined &&
+          t.params.cx !== null &&
+          t.params.cy !== undefined &&
+          t.params.cy !== null
+        ) {
+          m = rotationMatrixAroundPoint(
+            t.params.angle,
+            t.params.cx,
+            t.params.cy,
+          );
+        } else {
+          m = rotationMatrix(t.params.angle);
+        }
+        break;
+      case "scale":
+        if (
+          t.params.sx === null ||
+          t.params.sx === undefined ||
+          t.params.sy === null ||
+          t.params.sy === undefined
+        ) {
+          continue; // Skip transforms with missing params
+        }
+        m = scaleMatrix(t.params.sx, t.params.sy);
+        break;
+      case "matrix":
+        if (!t.params.matrix) {
+          continue; // Skip transforms with missing matrix
+        }
+        m = t.params.matrix;
+        break;
+      default:
+        // Skip unknown transform types
+        continue;
+    }
+
+    if (m !== null) {
+      combined = combined.mul(m);
+    }
+  }
+
+  return combined;
+}
+
 // ============================================================================
 // Transform Merging Functions
 // ============================================================================
@@ -920,77 +1011,7 @@ export function optimizeTransformList(transforms) {
   }
 
   // Calculate original combined matrix for verification
-  let originalMatrix = identityMatrix();
-  for (const t of transforms) {
-    // Validate transform object structure
-    if (
-      !t ||
-      typeof t !== "object" ||
-      !t.type ||
-      !t.params ||
-      typeof t.params !== "object"
-    ) {
-      continue; // Skip malformed transforms
-    }
-
-    let m = null; // Initialize m to null to catch missing assignments
-    switch (t.type) {
-      case "translate":
-        if (
-          t.params.tx === null ||
-          t.params.tx === undefined ||
-          t.params.ty === null ||
-          t.params.ty === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = translationMatrix(t.params.tx, t.params.ty);
-        break;
-      case "rotate":
-        if (t.params.angle === null || t.params.angle === undefined) {
-          continue; // Skip transforms with missing angle
-        }
-        if (
-          t.params.cx !== undefined &&
-          t.params.cx !== null &&
-          t.params.cy !== undefined &&
-          t.params.cy !== null
-        ) {
-          m = rotationMatrixAroundPoint(
-            t.params.angle,
-            t.params.cx,
-            t.params.cy,
-          );
-        } else {
-          m = rotationMatrix(t.params.angle);
-        }
-        break;
-      case "scale":
-        if (
-          t.params.sx === null ||
-          t.params.sx === undefined ||
-          t.params.sy === null ||
-          t.params.sy === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = scaleMatrix(t.params.sx, t.params.sy);
-        break;
-      case "matrix":
-        if (!t.params.matrix) {
-          continue; // Skip transforms with missing matrix
-        }
-        m = t.params.matrix;
-        break;
-      default:
-        // Skip unknown transform types, but don't try to multiply null matrix
-        continue;
-    }
-    // Only multiply if m was successfully assigned (prevents undefined matrix multiplication)
-    if (m !== null) {
-      originalMatrix = originalMatrix.mul(m);
-    }
-  }
+  const originalMatrix = computeCombinedMatrix(transforms);
 
   // Step 1: Remove identity transforms
   const { transforms: step1, removedCount: _removedCount } =
@@ -1210,77 +1231,7 @@ export function optimizeTransformList(transforms) {
   const { transforms: final } = removeIdentityTransforms(optimized);
 
   // Calculate optimized combined matrix for verification
-  let optimizedMatrix = identityMatrix();
-  for (const t of final) {
-    // Validate transform object structure
-    if (
-      !t ||
-      typeof t !== "object" ||
-      !t.type ||
-      !t.params ||
-      typeof t.params !== "object"
-    ) {
-      continue; // Skip malformed transforms
-    }
-
-    let m = null; // Initialize m to null to catch missing assignments
-    switch (t.type) {
-      case "translate":
-        if (
-          t.params.tx === null ||
-          t.params.tx === undefined ||
-          t.params.ty === null ||
-          t.params.ty === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = translationMatrix(t.params.tx, t.params.ty);
-        break;
-      case "rotate":
-        if (t.params.angle === null || t.params.angle === undefined) {
-          continue; // Skip transforms with missing angle
-        }
-        if (
-          t.params.cx !== undefined &&
-          t.params.cx !== null &&
-          t.params.cy !== undefined &&
-          t.params.cy !== null
-        ) {
-          m = rotationMatrixAroundPoint(
-            t.params.angle,
-            t.params.cx,
-            t.params.cy,
-          );
-        } else {
-          m = rotationMatrix(t.params.angle);
-        }
-        break;
-      case "scale":
-        if (
-          t.params.sx === null ||
-          t.params.sx === undefined ||
-          t.params.sy === null ||
-          t.params.sy === undefined
-        ) {
-          continue; // Skip transforms with missing params
-        }
-        m = scaleMatrix(t.params.sx, t.params.sy);
-        break;
-      case "matrix":
-        if (!t.params.matrix) {
-          continue; // Skip transforms with missing matrix
-        }
-        m = t.params.matrix;
-        break;
-      default:
-        // Skip unknown transform types, but don't try to multiply null matrix
-        continue;
-    }
-    // Only multiply if m was successfully assigned (prevents undefined matrix multiplication)
-    if (m !== null) {
-      optimizedMatrix = optimizedMatrix.mul(m);
-    }
-  }
+  const optimizedMatrix = computeCombinedMatrix(final);
 
   // VERIFICATION: Combined matrices must be equal
   const maxError = matrixMaxDifference(originalMatrix, optimizedMatrix);

package/src/verification.js

@@ -15,8 +15,6 @@
  */
 
 import Decimal from "decimal.js";
-import { Matrix as _Matrix } from "./matrix.js";
-import { Vector as _Vector } from "./vector.js";
 import * as Transforms2D from "./transforms2d.js";
 
 // Use high precision for verifications

package/templates/svgm_replacement_map.yml

@@ -0,0 +1,53 @@
+# SVG Font Replacement Map
+# ========================
+# This file defines font replacements for SVG processing.
+#
+# Format:
+#   original_font: replacement_font
+#
+# Examples:
+#   "Arial": "Inter"           # Replace Arial with Inter
+#   "Times New Roman": "Noto Serif"
+#
+# Font sources (in priority order):
+#   1. Local system fonts
+#   2. Google Fonts (default, free)
+#   3. FontGet (npm: fontget)
+#   4. fnt (brew: alexmyczko/fnt/fnt)
+#
+# Options per font:
+#   embed: true                # Embed as base64 (default: true)
+#   subset: true               # Only include used glyphs (default: true)
+#   source: "google"           # Force specific source
+#   weight: "400,700"          # Specific weights to include
+#   style: "normal,italic"     # Specific styles
+#
+# Advanced format:
+#   "Arial":
+#     replacement: "Inter"
+#     embed: true
+#     subset: true
+#     source: "google"
+#     weights: ["400", "500", "700"]
+
+replacements:
+  # Common font replacements
+  # "Arial": "Inter"
+  # "Helvetica": "Inter"
+  # "Times New Roman": "Noto Serif"
+  # "Times": "Noto Serif"
+  # "Courier New": "Fira Code"
+  # "Courier": "Fira Code"
+  # "Georgia": "Merriweather"
+  # "Verdana": "Open Sans"
+  # "Comic Sans MS": "Comic Neue"
+
+  # Icon fonts
+  # "Font Awesome": "Font Awesome 6 Free"
+  # "Material Icons": "Material Symbols Outlined"
+
+options:
+  default_embed: true
+  default_subset: true
+  fallback_source: "google"
+  auto_download: true