@remotion/paths 3.3.38 → 3.3.40

package/dist/get-bounding-box.d.ts

@@ -0,0 +1,2 @@
+import type { BoundingBox } from './helpers/types';
+export declare const getBoundingBox: (d: string) => BoundingBox;

package/dist/get-bounding-box.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBoundingBox = void 0;
+const remove_a_s_t_curves_1 = require("./helpers/remove-a-s-t-curves");
+const normalize_path_1 = require("./normalize-path");
+const parse_path_1 = require("./parse-path");
+// Precision for consider cubic polynom as quadratic one
+const CBEZIER_MINMAX_EPSILON = 0.00000001;
+// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L89
+function minmaxQ(A) {
+    const min = Math.min(A[0], A[2]);
+    const max = Math.max(A[0], A[2]);
+    if (A[1] > A[0] ? A[2] >= A[1] : A[2] <= A[1]) {
+        // if no extremum in ]0,1[
+        return [min, max];
+    }
+    // check if the extremum E is min or max
+    const E = (A[0] * A[2] - A[1] * A[1]) / (A[0] - 2 * A[1] + A[2]);
+    return E < min ? [E, max] : [min, E];
+}
+// https://github.com/kpym/SVGPathy/blob/acd1a50c626b36d81969f6e98e8602e128ba4302/lib/box.js#L127
+function minmaxC(A) {
+    const K = A[0] - 3 * A[1] + 3 * A[2] - A[3];
+    // if the polynomial is (almost) quadratic and not cubic
+    if (Math.abs(K) < CBEZIER_MINMAX_EPSILON) {
+        if (A[0] === A[3] && A[0] === A[1]) {
+            // no curve, point targeting same location
+            return [A[0], A[3]];
+        }
+        return minmaxQ([
+            A[0],
+            -0.5 * A[0] + 1.5 * A[1],
+            A[0] - 3 * A[1] + 3 * A[2],
+        ]);
+    }
+    // the reduced discriminant of the derivative
+    const T = -A[0] * A[2] +
+        A[0] * A[3] -
+        A[1] * A[2] -
+        A[1] * A[3] +
+        A[1] * A[1] +
+        A[2] * A[2];
+    // if the polynomial is monotone in [0,1]
+    if (T <= 0) {
+        return [Math.min(A[0], A[3]), Math.max(A[0], A[3])];
+    }
+    const S = Math.sqrt(T);
+    // potential extrema
+    let min = Math.min(A[0], A[3]);
+    let max = Math.max(A[0], A[3]);
+    const L = A[0] - 2 * A[1] + A[2];
+    // check local extrema
+    for (let R = (L + S) / K, i = 1; i <= 2; R = (L - S) / K, i++) {
+        if (R > 0 && R < 1) {
+            // if the extrema is for R in [0,1]
+            const Q = A[0] * (1 - R) * (1 - R) * (1 - R) +
+                A[1] * 3 * (1 - R) * (1 - R) * R +
+                A[2] * 3 * (1 - R) * R * R +
+                A[3] * R * R * R;
+            if (Q < min) {
+                min = Q;
+            }
+            if (Q > max) {
+                max = Q;
+            }
+        }
+    }
+    return [min, max];
+}
+const getBoundingBox = (d) => {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    const parsed = (0, parse_path_1.parsePath)((0, normalize_path_1.normalizePath)(d));
+    const unarced = (0, remove_a_s_t_curves_1.removeATSHVInstructions)(parsed);
+    let x = 0;
+    let y = 0;
+    for (const seg of unarced) {
+        switch (seg.type) {
+            case 'M':
+            case 'L': {
+                if (minX > seg.x) {
+                    minX = seg.x;
+                }
+                if (minY > seg.y) {
+                    minY = seg.y;
+                }
+                if (maxX < seg.x) {
+                    maxX = seg.x;
+                }
+                if (maxY < seg.y) {
+                    maxY = seg.y;
+                }
+                x = seg.x;
+                y = seg.y;
+                break;
+            }
+            case 'C': {
+                const cxMinMax = minmaxC([x, seg.cp1x, seg.cp2x, seg.x]);
+                if (minX > cxMinMax[0]) {
+                    minX = cxMinMax[0];
+                }
+                if (maxX < cxMinMax[1]) {
+                    maxX = cxMinMax[1];
+                }
+                const cyMinMax = minmaxC([y, seg.cp1y, seg.cp2y, seg.y]);
+                if (minY > cyMinMax[0]) {
+                    minY = cyMinMax[0];
+                }
+                if (maxY < cyMinMax[1]) {
+                    maxY = cyMinMax[1];
+                }
+                x = seg.x;
+                y = seg.y;
+                break;
+            }
+            case 'Q': {
+                const qxMinMax = minmaxQ([x, seg.cpx, seg.x]);
+                if (minX > qxMinMax[0]) {
+                    minX = qxMinMax[0];
+                }
+                if (maxX < qxMinMax[1]) {
+                    maxX = qxMinMax[1];
+                }
+                const qyMinMax = minmaxQ([y, seg.cpy, seg.y]);
+                if (minY > qyMinMax[0]) {
+                    minY = qyMinMax[0];
+                }
+                if (maxY < qyMinMax[1]) {
+                    maxY = qyMinMax[1];
+                }
+                x = seg.x;
+                y = seg.y;
+                break;
+            }
+            case 'Z':
+                break;
+            default:
+                // @ts-expect-error
+                throw new Error(`Unknown instruction ${seg.type}`);
+        }
+    }
+    return { x1: minX, y1: minY, x2: maxX, y2: maxY };
+};
+exports.getBoundingBox = getBoundingBox;

package/dist/get-subpaths.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSubpaths = void 0;
 const construct_1 = require("./helpers/construct");
+const serialize_instructions_1 = require("./serialize-instructions");
 /**
  * Splits a valid SVG path into it's parts.
  * @param {string} path A valid SVG path
@@ -9,10 +10,8 @@ const construct_1 = require("./helpers/construct");
  */
 const getSubpaths = (path) => {
     const { segments } = (0, construct_1.construct)(path);
-    return segments
-        .map((seg) => {
-        return seg.map((s) => s.join(' '));
-    })
-        .map((_s) => _s.join(' '));
+    return segments.map((seg) => {
+        return (0, serialize_instructions_1.serializeInstructions)(seg);
+    });
 };
 exports.getSubpaths = getSubpaths;

package/dist/helpers/construct.d.ts

@@ -1,5 +1,4 @@
-import type { Instruction } from './parse';
-import type { Point, Properties } from './types';
+import type { Instruction, Point, Properties } from './types';
 export declare const construct: (string: string) => {
     segments: Instruction[][];
     initial_point: Point | null;