@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/animation-optimization.js

@@ -44,6 +44,22 @@ export const STANDARD_EASINGS = {
  * @returns {string} Optimized number string
  */
 export function formatSplineValue(value, precision = 3) {
+  // Validate value parameter
+  if (value === null || value === undefined) {
+    throw new Error('formatSplineValue: value parameter is required');
+  }
+
+  // Validate precision parameter
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error('formatSplineValue: precision must be a non-negative finite number');
+  }
+
+  // Check for NaN/Infinity before creating Decimal
+  const numValue = typeof value === 'number' ? value : parseFloat(value);
+  if (!Number.isFinite(numValue)) {
+    throw new Error(`formatSplineValue: value must be a finite number, got ${value}`);
+  }
+
   const num = new Decimal(value);
 
   // Round to precision
@@ -82,11 +98,20 @@ export function parseKeySplines(keySplines) {
   // Split by semicolon to get individual splines
   const splines = keySplines.split(';').map(s => s.trim()).filter(s => s);
 
-  return splines.map(spline => {
-    // Split by whitespace or comma to get control points
-    const values = spline.split(/[\s,]+/).map(v => parseFloat(v));
-    return values;
-  });
+  return splines
+    .map(spline => {
+      // Split by whitespace or comma to get control points
+      const values = spline.split(/[\s,]+/)
+        .map(v => parseFloat(v))
+        .filter(v => Number.isFinite(v)); // Filter out NaN and Infinity
+
+      // Each spline must have exactly 4 control points
+      if (values.length !== 4) {
+        throw new Error(`parseKeySplines: invalid spline "${spline}", expected 4 values, got ${values.length}`);
+      }
+
+      return values;
+    });
 }
 
 /**
@@ -96,7 +121,25 @@ export function parseKeySplines(keySplines) {
  * @returns {string} keySplines attribute value
  */
 export function serializeKeySplines(splines, precision = 3) {
-  return splines.map(spline => {
+  // Validate splines parameter
+  if (!Array.isArray(splines)) {
+    throw new Error('serializeKeySplines: splines must be an array');
+  }
+
+  // Validate precision parameter
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error('serializeKeySplines: precision must be a non-negative finite number');
+  }
+
+  return splines.map((spline, index) => {
+    // Validate each spline is an array with 4 values
+    if (!Array.isArray(spline)) {
+      throw new Error(`serializeKeySplines: spline at index ${index} must be an array`);
+    }
+    if (spline.length !== 4) {
+      throw new Error(`serializeKeySplines: spline at index ${index} must have exactly 4 values, got ${spline.length}`);
+    }
+
     return spline.map(v => formatSplineValue(v, precision)).join(' ');
   }).join('; ');
 }
@@ -108,9 +151,21 @@ export function serializeKeySplines(splines, precision = 3) {
  * @returns {boolean} True if spline is linear
  */
 export function isLinearSpline(spline, tolerance = 0.001) {
-  if (!spline || spline.length !== 4) return false;
+  // Validate spline parameter
+  if (!Array.isArray(spline) || spline.length !== 4) return false;
+
+  // Validate tolerance parameter
+  if (typeof tolerance !== 'number' || tolerance < 0 || !Number.isFinite(tolerance)) {
+    throw new Error('isLinearSpline: tolerance must be a non-negative finite number');
+  }
 
   const [x1, y1, x2, y2] = spline;
+
+  // Check for NaN values in spline
+  if (!Number.isFinite(x1) || !Number.isFinite(y1) || !Number.isFinite(x2) || !Number.isFinite(y2)) {
+    return false;
+  }
+
   return (
     Math.abs(x1) < tolerance &&
     Math.abs(y1) < tolerance &&
@@ -138,7 +193,16 @@ export function areAllSplinesLinear(keySplines) {
  * @returns {string|null} Easing name or null if not standard
  */
 export function identifyStandardEasing(spline, tolerance = 0.01) {
-  if (!spline || spline.length !== 4) return null;
+  // Validate spline parameter
+  if (!Array.isArray(spline) || spline.length !== 4) return null;
+
+  // Validate tolerance parameter
+  if (typeof tolerance !== 'number' || tolerance < 0 || !Number.isFinite(tolerance)) {
+    throw new Error('identifyStandardEasing: tolerance must be a non-negative finite number');
+  }
+
+  // Check for NaN values in spline
+  if (!spline.every(val => Number.isFinite(val))) return null;
 
   for (const [name, standard] of Object.entries(STANDARD_EASINGS)) {
     const matches = spline.every((val, i) => Math.abs(val - standard[i]) < tolerance);
@@ -189,7 +253,7 @@ export function optimizeKeySplines(keySplines, options = {}) {
  */
 export function parseKeyTimes(keyTimes) {
   if (!keyTimes || typeof keyTimes !== 'string') return [];
-  return keyTimes.split(';').map(s => parseFloat(s.trim())).filter(v => !isNaN(v));
+  return keyTimes.split(';').map(s => parseFloat(s.trim())).filter(v => Number.isFinite(v));
 }
 
 /**
@@ -199,6 +263,19 @@ export function parseKeyTimes(keyTimes) {
  * @returns {string} keyTimes attribute value
  */
 export function serializeKeyTimes(times, precision = 3) {
+  // Validate times parameter
+  if (!Array.isArray(times)) {
+    throw new Error('serializeKeyTimes: times must be an array');
+  }
+
+  // Validate precision parameter
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error('serializeKeyTimes: precision must be a non-negative finite number');
+  }
+
+  // Return empty string for empty array
+  if (times.length === 0) return '';
+
   return times.map(t => formatSplineValue(t, precision)).join('; ');
 }
 
@@ -209,6 +286,16 @@ export function serializeKeyTimes(times, precision = 3) {
  * @returns {string} Optimized keyTimes value
  */
 export function optimizeKeyTimes(keyTimes, precision = 3) {
+  // Validate keyTimes parameter
+  if (keyTimes === null || keyTimes === undefined) {
+    throw new Error('optimizeKeyTimes: keyTimes parameter is required');
+  }
+
+  // Validate precision parameter
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error('optimizeKeyTimes: precision must be a non-negative finite number');
+  }
+
   const times = parseKeyTimes(keyTimes);
   if (times.length === 0) return keyTimes;
   return serializeKeyTimes(times, precision);
@@ -224,9 +311,17 @@ export function optimizeKeyTimes(keyTimes, precision = 3) {
 export function optimizeAnimationValues(values, precision = 3) {
   if (!values || typeof values !== 'string') return values;
 
+  // Validate precision parameter
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error('optimizeAnimationValues: precision must be a non-negative finite number');
+  }
+
   // Split by semicolon
   const parts = values.split(';');
 
+  // Handle empty values string
+  if (parts.length === 0) return values;
+
   const optimized = parts.map(part => {
     const trimmed = part.trim();
 
@@ -236,10 +331,10 @@ export function optimizeAnimationValues(values, precision = 3) {
     }
 
     // Try to parse as numbers (could be space-separated like "0 0" for translate)
-    const nums = trimmed.split(/[\s,]+/);
+    const nums = trimmed.split(/[\s,]+/).filter(n => n); // Filter empty strings
     const optimizedNums = nums.map(n => {
       const num = parseFloat(n);
-      if (isNaN(num)) return n; // Not a number, preserve as-is
+      if (!Number.isFinite(num)) return n; // Not a finite number, preserve as-is
       return formatSplineValue(num, precision);
     });
 
@@ -256,10 +351,23 @@ export function optimizeAnimationValues(values, precision = 3) {
  * @returns {{modified: boolean, changes: string[]}}
  */
 export function optimizeElementTiming(el, options = {}) {
+  // Validate el parameter
+  if (!el || typeof el !== 'object') {
+    throw new Error('optimizeElementTiming: el parameter must be a valid element');
+  }
+  if (typeof el.getAttribute !== 'function' || typeof el.setAttribute !== 'function' || typeof el.removeAttribute !== 'function') {
+    throw new Error('optimizeElementTiming: el parameter must have getAttribute, setAttribute, and removeAttribute methods');
+  }
+
   const precision = options.precision ?? 3;
   const removeLinearSplines = options.removeLinearSplines !== false;
   const optimizeValues = options.optimizeValues !== false;
 
+  // Validate precision from options
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error('optimizeElementTiming: options.precision must be a non-negative finite number');
+  }
+
   const changes = [];
   let modified = false;
 
@@ -295,11 +403,10 @@ export function optimizeElementTiming(el, options = {}) {
     }
   }
 
-  // Optimize values (only numeric, preserve ID refs)
+  // Optimize values (optimizeAnimationValues internally preserves ID refs)
   if (optimizeValues) {
     const values = el.getAttribute('values');
-    if (values && !values.includes('#')) {
-      // Only optimize if no ID references
+    if (values) {
       const optimized = optimizeAnimationValues(values, precision);
       if (optimized !== values) {
         el.setAttribute('values', optimized);
@@ -309,10 +416,10 @@ export function optimizeElementTiming(el, options = {}) {
     }
   }
 
-  // Optimize from/to
+  // Optimize from/to/by (optimizeAnimationValues internally preserves ID refs)
   for (const attr of ['from', 'to', 'by']) {
     const val = el.getAttribute(attr);
-    if (val && !val.includes('#')) {
+    if (val) {
       const optimized = optimizeAnimationValues(val, precision);
       if (optimized !== val) {
         el.setAttribute(attr, optimized);
@@ -338,13 +445,24 @@ export const ANIMATION_ELEMENTS = ['animate', 'animatetransform', 'animatemotion
  * @returns {{elementsModified: number, totalChanges: number, details: Array}}
  */
 export function optimizeDocumentAnimationTiming(root, options = {}) {
+  // Validate root parameter
+  if (!root || typeof root !== 'object') {
+    throw new Error('optimizeDocumentAnimationTiming: root parameter must be a valid element');
+  }
+
   let elementsModified = 0;
   let totalChanges = 0;
   const details = [];
 
   const processElement = (el) => {
+    // Skip if not a valid element
+    if (!el || typeof el !== 'object') return;
+
     const tagName = el.tagName?.toLowerCase();
 
+    // Skip if no tagName
+    if (!tagName) return;
+
     if (ANIMATION_ELEMENTS.includes(tagName)) {
       const result = optimizeElementTiming(el, options);
       if (result.modified) {
@@ -358,7 +476,9 @@ export function optimizeDocumentAnimationTiming(root, options = {}) {
       }
     }
 
-    for (const child of el.children || []) {
+    // Process children safely
+    const children = el.children || [];
+    for (const child of children) {
       processElement(child);
     }
   };

package/src/animation-references.js

@@ -197,6 +197,20 @@ export function parseJavaScriptIds(js) {
  * @returns {{static: Set<string>, animation: Set<string>, css: Set<string>, js: Set<string>}}
  */
 export function collectElementReferences(el) {
+  // Validate input parameter
+  if (!el || typeof el !== "object" || !(el instanceof SVGElement)) {
+    throw new TypeError(
+      "collectElementReferences: el must be a valid SVGElement",
+    );
+  }
+
+  // Validate element has required methods
+  if (typeof el.getAttributeNames !== "function") {
+    throw new TypeError(
+      "collectElementReferences: el must have getAttributeNames method",
+    );
+  }
+
   const refs = {
     static: new Set(),
     animation: new Set(),
@@ -207,7 +221,14 @@ export function collectElementReferences(el) {
   const tagName = el.tagName?.toLowerCase() || "";
   const isAnimationElement = ANIMATION_ELEMENTS.includes(tagName);
 
-  for (const attrName of el.getAttributeNames()) {
+  const attributeNames = el.getAttributeNames();
+  if (!Array.isArray(attributeNames)) {
+    throw new TypeError(
+      "collectElementReferences: getAttributeNames must return an array",
+    );
+  }
+
+  for (const attrName of attributeNames) {
     const value = el.getAttribute(attrName);
     if (!value) continue;
 
@@ -253,8 +274,22 @@ export function collectElementReferences(el) {
 
   // Check <mpath> element inside <animateMotion>
   if (tagName === "animatemotion") {
+    if (typeof el.getElementsByTagName !== "function") {
+      throw new TypeError(
+        "collectElementReferences: el must have getElementsByTagName method",
+      );
+    }
     const mpaths = el.getElementsByTagName("mpath");
+    // Validate mpaths is iterable
+    if (!mpaths || typeof mpaths[Symbol.iterator] !== "function") {
+      throw new TypeError(
+        "collectElementReferences: getElementsByTagName must return an iterable",
+      );
+    }
     for (const mpath of mpaths) {
+      // Validate mpath has getAttribute method
+      if (!mpath || typeof mpath.getAttribute !== "function") continue;
+
       for (const attr of HREF_ATTRIBUTES) {
         const value = mpath.getAttribute(attr);
         const id = parseHrefId(value);
@@ -281,6 +316,13 @@ export function collectElementReferences(el) {
  * }}
  */
 export function collectAllReferences(root) {
+  // Validate input parameter
+  if (!root || typeof root !== "object" || !(root instanceof SVGElement)) {
+    throw new TypeError(
+      "collectAllReferences: root must be a valid SVGElement",
+    );
+  }
+
   const result = {
     all: new Set(),
     static: new Set(),
@@ -339,9 +381,11 @@ export function collectAllReferences(root) {
     }
 
     // Recurse to children
-    for (const child of el.children) {
-      if (child instanceof SVGElement) {
-        processElement(child, currentPath);
+    if (el.children && typeof el.children[Symbol.iterator] === "function") {
+      for (const child of el.children) {
+        if (child instanceof SVGElement) {
+          processElement(child, currentPath);
+        }
       }
     }
   };
@@ -358,6 +402,14 @@ export function collectAllReferences(root) {
  * @returns {boolean} True if the ID is referenced
  */
 export function isIdReferenced(root, id) {
+  // Validate input parameters
+  if (!root || typeof root !== "object" || !(root instanceof SVGElement)) {
+    throw new TypeError("isIdReferenced: root must be a valid SVGElement");
+  }
+  if (!id || typeof id !== "string") {
+    throw new TypeError("isIdReferenced: id must be a non-empty string");
+  }
+
   const refs = collectAllReferences(root);
   return refs.all.has(id);
 }
@@ -369,6 +421,14 @@ export function isIdReferenced(root, id) {
  * @returns {{referenced: boolean, type: string|null, sources: string[]}}
  */
 export function getIdReferenceInfo(root, id) {
+  // Validate input parameters
+  if (!root || typeof root !== "object" || !(root instanceof SVGElement)) {
+    throw new TypeError("getIdReferenceInfo: root must be a valid SVGElement");
+  }
+  if (!id || typeof id !== "string") {
+    throw new TypeError("getIdReferenceInfo: id must be a non-empty string");
+  }
+
   const refs = collectAllReferences(root);
   const details = refs.details.get(id);
 
@@ -387,6 +447,11 @@ export function getIdReferenceInfo(root, id) {
  * @returns {{safeToRemove: string[], referenced: string[], animationReferenced: string[]}}
  */
 export function findUnreferencedDefs(root) {
+  // Validate input parameter
+  if (!root || typeof root !== "object" || !(root instanceof SVGElement)) {
+    throw new TypeError("findUnreferencedDefs: root must be a valid SVGElement");
+  }
+
   const refs = collectAllReferences(root);
 
   const safeToRemove = [];
@@ -394,8 +459,26 @@ export function findUnreferencedDefs(root) {
   const animationReferenced = [];
 
   // Scan all defs
+  if (typeof root.getElementsByTagName !== "function") {
+    throw new TypeError(
+      "findUnreferencedDefs: root must have getElementsByTagName method",
+    );
+  }
+
   const defsElements = root.getElementsByTagName("defs");
+  // Validate defsElements is iterable
+  if (!defsElements || typeof defsElements[Symbol.iterator] !== "function") {
+    throw new TypeError(
+      "findUnreferencedDefs: getElementsByTagName must return an iterable",
+    );
+  }
+
   for (const defs of defsElements) {
+    // Validate defs.children exists and is iterable
+    if (!defs.children || typeof defs.children[Symbol.iterator] !== "function") {
+      continue; // Skip this defs element if children is not iterable
+    }
+
     for (const child of defs.children) {
       if (child instanceof SVGElement) {
         const id = child.getAttribute("id");
@@ -423,20 +506,54 @@ export function findUnreferencedDefs(root) {
  * @returns {{removed: string[], kept: string[], keptForAnimation: string[]}}
  */
 export function removeUnreferencedDefsSafe(root) {
+  // Validate input parameter
+  if (!root || typeof root !== "object" || !(root instanceof SVGElement)) {
+    throw new TypeError(
+      "removeUnreferencedDefsSafe: root must be a valid SVGElement",
+    );
+  }
+
   const { safeToRemove, referenced, animationReferenced } =
     findUnreferencedDefs(root);
 
   const removed = [];
 
   // Only remove elements that are truly unreferenced
+  if (typeof root.getElementsByTagName !== "function") {
+    throw new TypeError(
+      "removeUnreferencedDefsSafe: root must have getElementsByTagName method",
+    );
+  }
+
   const defsElements = root.getElementsByTagName("defs");
+  // Validate defsElements is iterable
+  if (!defsElements || typeof defsElements[Symbol.iterator] !== "function") {
+    throw new TypeError(
+      "removeUnreferencedDefsSafe: getElementsByTagName must return an iterable",
+    );
+  }
+
   for (const defs of defsElements) {
+    // Validate defs.children exists and is iterable before spreading
+    if (!defs.children || typeof defs.children[Symbol.iterator] !== "function") {
+      continue; // Skip this defs element if children is not iterable
+    }
+
     for (const child of [...defs.children]) {
       if (child instanceof SVGElement) {
         const id = child.getAttribute("id");
         if (id && safeToRemove.includes(id)) {
-          defs.removeChild(child);
-          removed.push(id);
+          try {
+            defs.removeChild(child);
+            removed.push(id);
+          } catch (error) {
+            // If removeChild fails (child not a direct child of defs), skip it
+            // This prevents the function from crashing on edge cases
+            console.warn(
+              `removeUnreferencedDefsSafe: Failed to remove child with id="${id}":`,
+              error.message,
+            );
+          }
         }
       }
     }