@emasoft/svg-matrix 1.0.30 → 1.0.31

package/src/clip-path-resolver.js

@@ -94,6 +94,10 @@ export function pathToPolygon(
   pathData,
   samplesPerCurve = DEFAULT_CURVE_SAMPLES,
 ) {
+  if (typeof pathData !== 'string') throw new Error('pathToPolygon: pathData must be a string');
+  if (typeof samplesPerCurve !== 'number' || samplesPerCurve <= 0 || !Number.isFinite(samplesPerCurve)) {
+    throw new Error(`pathToPolygon: samplesPerCurve must be a positive finite number, got ${samplesPerCurve}`);
+  }
   const points = [];
   let currentX = D(0),
     currentY = D(0);
@@ -101,12 +105,19 @@ export function pathToPolygon(
     startY = D(0);
 
   const commands = parsePathCommands(pathData);
+  if (!Array.isArray(commands)) {
+    throw new Error('pathToPolygon: parsePathCommands must return an array');
+  }
 
   for (const cmd of commands) {
     const { type, args } = cmd;
+    if (!Array.isArray(args)) {
+      throw new Error(`pathToPolygon: command args must be an array for command ${type}`);
+    }
 
     switch (type) {
       case "M":
+        if (args.length < 2) throw new Error(`pathToPolygon: M command requires 2 arguments, got ${args.length}`);
         currentX = D(args[0]);
         currentY = D(args[1]);
         startX = currentX;
@@ -114,6 +125,7 @@ export function pathToPolygon(
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "m":
+        if (args.length < 2) throw new Error(`pathToPolygon: m command requires 2 arguments, got ${args.length}`);
         currentX = currentX.plus(args[0]);
         currentY = currentY.plus(args[1]);
         startX = currentX;
@@ -121,32 +133,39 @@ export function pathToPolygon(
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "L":
+        if (args.length < 2) throw new Error(`pathToPolygon: L command requires 2 arguments, got ${args.length}`);
         currentX = D(args[0]);
         currentY = D(args[1]);
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "l":
+        if (args.length < 2) throw new Error(`pathToPolygon: l command requires 2 arguments, got ${args.length}`);
         currentX = currentX.plus(args[0]);
         currentY = currentY.plus(args[1]);
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "H":
+        if (args.length < 1) throw new Error(`pathToPolygon: H command requires 1 argument, got ${args.length}`);
         currentX = D(args[0]);
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "h":
+        if (args.length < 1) throw new Error(`pathToPolygon: h command requires 1 argument, got ${args.length}`);
         currentX = currentX.plus(args[0]);
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "V":
+        if (args.length < 1) throw new Error(`pathToPolygon: V command requires 1 argument, got ${args.length}`);
         currentY = D(args[0]);
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "v":
+        if (args.length < 1) throw new Error(`pathToPolygon: v command requires 1 argument, got ${args.length}`);
         currentY = currentY.plus(args[0]);
         points.push(PolygonClip.point(currentX, currentY));
         break;
       case "C":
+        if (args.length < 6) throw new Error(`pathToPolygon: C command requires 6 arguments, got ${args.length}`);
         sampleCubicBezier(
           points,
           currentX,
@@ -163,6 +182,7 @@ export function pathToPolygon(
         currentY = D(args[5]);
         break;
       case "c":
+        if (args.length < 6) throw new Error(`pathToPolygon: c command requires 6 arguments, got ${args.length}`);
         sampleCubicBezier(
           points,
           currentX,
@@ -179,6 +199,7 @@ export function pathToPolygon(
         currentY = currentY.plus(args[5]);
         break;
       case "Q":
+        if (args.length < 4) throw new Error(`pathToPolygon: Q command requires 4 arguments, got ${args.length}`);
         sampleQuadraticBezier(
           points,
           currentX,
@@ -193,6 +214,7 @@ export function pathToPolygon(
         currentY = D(args[3]);
         break;
       case "q":
+        if (args.length < 4) throw new Error(`pathToPolygon: q command requires 4 arguments, got ${args.length}`);
         sampleQuadraticBezier(
           points,
           currentX,
@@ -207,6 +229,7 @@ export function pathToPolygon(
         currentY = currentY.plus(args[3]);
         break;
       case "A":
+        if (args.length < 7) throw new Error(`pathToPolygon: A command requires 7 arguments, got ${args.length}`);
         sampleArc(
           points,
           currentX,
@@ -224,6 +247,7 @@ export function pathToPolygon(
         currentY = D(args[6]);
         break;
       case "a":
+        if (args.length < 7) throw new Error(`pathToPolygon: a command requires 7 arguments, got ${args.length}`);
         sampleArc(
           points,
           currentX,
@@ -245,6 +269,8 @@ export function pathToPolygon(
         currentX = startX;
         currentY = startY;
         break;
+      default:
+        break;
     }
   }
 
@@ -267,6 +293,9 @@ export function pathToPolygon(
  * // Returns: [{type: 'M', args: [10, 20]}, {type: 'L', args: [30, 40]}]
  */
 function parsePathCommands(pathData) {
+  if (typeof pathData !== 'string') {
+    throw new Error(`parsePathCommands: pathData must be a string, got ${typeof pathData}`);
+  }
   const commands = [];
   const regex = /([MmLlHhVvCcSsQqTtAaZz])([^MmLlHhVvCcSsQqTtAaZz]*)/g;
   let match;
@@ -310,6 +339,16 @@ function parsePathCommands(pathData) {
  * // points now contains 20 sampled points along the cubic Bezier curve
  */
 function sampleCubicBezier(points, x0, y0, x1, y1, x2, y2, x3, y3, samples) {
+  if (!Array.isArray(points)) {
+    throw new Error('sampleCubicBezier: points must be an array');
+  }
+  if (typeof samples !== 'number' || samples <= 0 || !Number.isFinite(samples)) {
+    throw new Error(`sampleCubicBezier: samples must be a positive finite number, got ${samples}`);
+  }
+  if (!(x0 instanceof Decimal) || !(y0 instanceof Decimal) || !(x1 instanceof Decimal) || !(y1 instanceof Decimal) ||
+      !(x2 instanceof Decimal) || !(y2 instanceof Decimal) || !(x3 instanceof Decimal) || !(y3 instanceof Decimal)) {
+    throw new Error('sampleCubicBezier: all coordinate parameters must be Decimal instances');
+  }
   for (let i = 1; i <= samples; i++) {
     const t = D(i).div(samples);
     const mt = D(1).minus(t);
@@ -353,6 +392,16 @@ function sampleCubicBezier(points, x0, y0, x1, y1, x2, y2, x3, y3, samples) {
  * // points now contains 20 sampled points along the quadratic Bezier curve
  */
 function sampleQuadraticBezier(points, x0, y0, x1, y1, x2, y2, samples) {
+  if (!Array.isArray(points)) {
+    throw new Error('sampleQuadraticBezier: points must be an array');
+  }
+  if (typeof samples !== 'number' || samples <= 0 || !Number.isFinite(samples)) {
+    throw new Error(`sampleQuadraticBezier: samples must be a positive finite number, got ${samples}`);
+  }
+  if (!(x0 instanceof Decimal) || !(y0 instanceof Decimal) || !(x1 instanceof Decimal) ||
+      !(y1 instanceof Decimal) || !(x2 instanceof Decimal) || !(y2 instanceof Decimal)) {
+    throw new Error('sampleQuadraticBezier: all coordinate parameters must be Decimal instances');
+  }
   for (let i = 1; i <= samples; i++) {
     const t = D(i).div(samples);
     const mt = D(1).minus(t);
@@ -401,6 +450,22 @@ function sampleArc(
   y1,
   samples,
 ) {
+  if (!Array.isArray(points)) {
+    throw new Error('sampleArc: points must be an array');
+  }
+  if (typeof samples !== 'number' || samples <= 0 || !Number.isFinite(samples)) {
+    throw new Error(`sampleArc: samples must be a positive finite number, got ${samples}`);
+  }
+  if (!(x0 instanceof Decimal) || !(y0 instanceof Decimal) || !(rx instanceof Decimal) || !(ry instanceof Decimal) ||
+      !(xAxisRotation instanceof Decimal) || !(x1 instanceof Decimal) || !(y1 instanceof Decimal)) {
+    throw new Error('sampleArc: all coordinate and angle parameters must be Decimal instances');
+  }
+  if (typeof largeArc !== 'number' || (largeArc !== 0 && largeArc !== 1)) {
+    throw new Error(`sampleArc: largeArc must be 0 or 1, got ${largeArc}`);
+  }
+  if (typeof sweep !== 'number' || (sweep !== 0 && sweep !== 1)) {
+    throw new Error(`sampleArc: sweep must be 0 or 1, got ${sweep}`);
+  }
   if (rx.eq(0) || ry.eq(0)) {
     points.push(PolygonClip.point(x1, y1));
     return;
@@ -447,10 +512,20 @@ function sampleArc(
   const vx = x1p.neg().minus(cxp).div(rx),
     vy = y1p.neg().minus(cyp).div(ry);
   const n1 = ux.mul(ux).plus(uy.mul(uy)).sqrt();
+  if (n1.eq(0)) {
+    // Degenerate arc: start and end points are the same after transformation
+    points.push(PolygonClip.point(x1, y1));
+    return;
+  }
   let theta1 = Decimal.acos(ux.div(n1));
   if (uy.lt(0)) theta1 = theta1.neg();
 
   const n2 = n1.mul(vx.mul(vx).plus(vy.mul(vy)).sqrt());
+  if (n2.eq(0)) {
+    // Degenerate arc: endpoints coincide
+    points.push(PolygonClip.point(x1, y1));
+    return;
+  }
   let dtheta = Decimal.acos(ux.mul(vx).plus(uy.mul(vy)).div(n2));
   if (ux.mul(vy).minus(uy.mul(vx)).lt(0)) dtheta = dtheta.neg();
 
@@ -493,6 +568,9 @@ function sampleArc(
  * // Returns: [{x: D(0), y: D(0)}, {x: D(1), y: D(1)}]
  */
 function removeDuplicateConsecutive(points) {
+  if (!Array.isArray(points)) {
+    throw new Error('removeDuplicateConsecutive: points must be an array');
+  }
   if (points.length < 2) return points;
   const result = [points[0]];
   for (let i = 1; i < points.length; i++) {
@@ -545,6 +623,21 @@ export function shapeToPolygon(
   samples = DEFAULT_CURVE_SAMPLES,
   bezierArcs = 4,
 ) {
+  if (!element || typeof element !== 'object') {
+    throw new Error('shapeToPolygon: element must be an object');
+  }
+  if (!element.type || typeof element.type !== 'string') {
+    throw new Error('shapeToPolygon: element.type must be a string');
+  }
+  if (typeof samples !== 'number' || samples <= 0 || !Number.isFinite(samples)) {
+    throw new Error(`shapeToPolygon: samples must be a positive finite number, got ${samples}`);
+  }
+  if (typeof bezierArcs !== 'number' || bezierArcs <= 0 || !Number.isFinite(bezierArcs)) {
+    throw new Error(`shapeToPolygon: bezierArcs must be a positive finite number, got ${bezierArcs}`);
+  }
+  if (ctm !== null && !(ctm instanceof Matrix)) {
+    throw new Error('shapeToPolygon: ctm must be null or a Matrix instance');
+  }
   let pathData;
   switch (element.type) {
     case "circle":
@@ -687,7 +780,19 @@ export function resolveClipPath(
   ctm = null,
   options = {},
 ) {
+  if (!clipPathDef || typeof clipPathDef !== 'object') {
+    throw new Error('resolveClipPath: clipPathDef must be an object');
+  }
+  if (ctm !== null && !(ctm instanceof Matrix)) {
+    throw new Error('resolveClipPath: ctm must be null or a Matrix instance');
+  }
+  if (typeof options !== 'object' || options === null) {
+    throw new Error('resolveClipPath: options must be an object');
+  }
   const { samples = DEFAULT_CURVE_SAMPLES } = options;
+  if (typeof samples !== 'number' || samples <= 0 || !Number.isFinite(samples)) {
+    throw new Error(`resolveClipPath: samples must be a positive finite number, got ${samples}`);
+  }
   const clipPathUnits = clipPathDef.clipPathUnits || "userSpaceOnUse";
   let clipTransform = ctm ? ctm.clone() : Matrix.identity(3);
 
@@ -746,6 +851,18 @@ export function resolveClipPath(
  * @returns {Array} Clipped polygon(s), or array of polygon arrays for multi-region results
  */
 function clipPolygonWithRule(elementPolygon, clipPolygon, clipRule) {
+  if (!Array.isArray(elementPolygon)) {
+    throw new Error('clipPolygonWithRule: elementPolygon must be an array');
+  }
+  if (!Array.isArray(clipPolygon)) {
+    throw new Error('clipPolygonWithRule: clipPolygon must be an array');
+  }
+  if (clipRule !== 'nonzero' && clipRule !== 'evenodd') {
+    throw new Error(`clipPolygonWithRule: clipRule must be 'nonzero' or 'evenodd', got ${clipRule}`);
+  }
+  if (elementPolygon.length < 3 || clipPolygon.length < 3) {
+    return [];
+  }
   // For nonzero rule, standard intersection works correctly
   // because polygonIntersection uses the winding number test internally
   if (clipRule === "nonzero") {
@@ -789,6 +906,12 @@ function clipPolygonWithRule(elementPolygon, clipPolygon, clipRule) {
  * @private
  */
 function computeCentroid(polygon) {
+  if (!Array.isArray(polygon)) {
+    throw new Error('computeCentroid: polygon must be an array');
+  }
+  if (polygon.length === 0) {
+    throw new Error('computeCentroid: polygon must not be empty');
+  }
   let cx = new Decimal(0);
   let cy = new Decimal(0);
   let area = new Decimal(0);
@@ -874,7 +997,25 @@ function computeCentroid(polygon) {
  * const clipped = applyClipPath(ellipse, clipDef, null, { samples: 50 });
  */
 export function applyClipPath(element, clipPathDef, ctm = null, options = {}) {
+  if (!element || typeof element !== 'object') {
+    throw new Error('applyClipPath: element must be an object');
+  }
+  if (!clipPathDef || typeof clipPathDef !== 'object') {
+    throw new Error('applyClipPath: clipPathDef must be an object');
+  }
+  if (ctm !== null && !(ctm instanceof Matrix)) {
+    throw new Error('applyClipPath: ctm must be null or a Matrix instance');
+  }
+  if (typeof options !== 'object' || options === null) {
+    throw new Error('applyClipPath: options must be an object');
+  }
   const { samples = DEFAULT_CURVE_SAMPLES, clipRule = "nonzero" } = options;
+  if (typeof samples !== 'number' || samples <= 0 || !Number.isFinite(samples)) {
+    throw new Error(`applyClipPath: samples must be a positive finite number, got ${samples}`);
+  }
+  if (clipRule !== 'nonzero' && clipRule !== 'evenodd') {
+    throw new Error(`applyClipPath: clipRule must be 'nonzero' or 'evenodd', got ${clipRule}`);
+  }
   const clipPolygon = resolveClipPath(clipPathDef, element, ctm, options);
   if (clipPolygon.length < 3) return [];
 
@@ -910,6 +1051,12 @@ export function applyClipPath(element, clipPathDef, ctm = null, options = {}) {
  * // Returns: {x: Decimal(25), y: Decimal(25), width: Decimal(50), height: Decimal(50)}
  */
 function getElementBoundingBox(element) {
+  if (!element || typeof element !== 'object') {
+    throw new Error('getElementBoundingBox: element must be an object');
+  }
+  if (!element.type || typeof element.type !== 'string') {
+    throw new Error('getElementBoundingBox: element.type must be a string');
+  }
   switch (element.type) {
     case "rect":
       return {
@@ -988,6 +1135,12 @@ function getElementBoundingBox(element) {
  * // Returns: "M 0.12345679 0.98765432 Z"
  */
 export function polygonToPathData(polygon, precision = 6) {
+  if (!Array.isArray(polygon)) {
+    throw new Error('polygonToPathData: polygon must be an array');
+  }
+  if (typeof precision !== 'number' || precision < 0 || !Number.isFinite(precision)) {
+    throw new Error(`polygonToPathData: precision must be a non-negative finite number, got ${precision}`);
+  }
   if (polygon.length < 2) return "";
   const fmt = (n) =>
     (n instanceof Decimal ? n : D(n)).toFixed(precision).replace(/\.?0+$/, "");
@@ -1054,6 +1207,21 @@ export function resolveNestedClipPath(
   visited = new Set(),
   options = {},
 ) {
+  if (!clipPathDef || typeof clipPathDef !== 'object') {
+    throw new Error('resolveNestedClipPath: clipPathDef must be an object');
+  }
+  if (!(defsMap instanceof Map)) {
+    throw new Error('resolveNestedClipPath: defsMap must be a Map');
+  }
+  if (ctm !== null && !(ctm instanceof Matrix)) {
+    throw new Error('resolveNestedClipPath: ctm must be null or a Matrix instance');
+  }
+  if (!(visited instanceof Set)) {
+    throw new Error('resolveNestedClipPath: visited must be a Set');
+  }
+  if (typeof options !== 'object' || options === null) {
+    throw new Error('resolveNestedClipPath: options must be an object');
+  }
   const clipId = clipPathDef.id;
   if (clipId && visited.has(clipId)) {
     Logger.warn(`Circular clipPath reference detected: ${clipId}`);