@remotion/paths 4.0.0-newpaths.13 → 4.0.0-newpaths.40

package/dist/get-bounding-box.js

@@ -1,9 +1,9 @@
-'use strict';
+"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 unarc_1 = require("./unarc");
-const unshort_1 = require("./unshort");
+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
@@ -72,91 +72,93 @@ const getBoundingBox = (d) => {
     let minY = Infinity;
     let maxX = -Infinity;
     let maxY = -Infinity;
-    const abs = (0, normalize_path_1.normalizePath)(d);
-    const unarced = (0, unarc_1.unarc)(abs);
-    const unshortened = (0, unshort_1.unshort)(unarced);
+    const parsed = (0, parse_path_1.parsePath)((0, normalize_path_1.normalizePath)(d));
+    const unarced = (0, remove_a_s_t_curves_1.removeATSInstructions)(parsed);
     let x = 0;
     let y = 0;
-    for (const seg of unshortened) {
-        switch (seg[0]) {
+    for (const seg of unarced) {
+        switch (seg.type) {
             case 'M':
             case 'L': {
-                if (minX > seg[1]) {
-                    minX = seg[1];
+                if (minX > seg.x) {
+                    minX = seg.x;
                 }
-                if (minY > seg[2]) {
-                    minY = seg[2];
+                if (minY > seg.y) {
+                    minY = seg.y;
                 }
-                if (maxX < seg[1]) {
-                    maxX = seg[1];
+                if (maxX < seg.x) {
+                    maxX = seg.x;
                 }
-                if (maxY < seg[2]) {
-                    maxY = seg[2];
+                if (maxY < seg.y) {
+                    maxY = seg.y;
                 }
-                x = seg[1];
-                y = seg[2];
+                x = seg.x;
+                y = seg.y;
                 break;
             }
             case 'V': {
-                if (minY > seg[1]) {
-                    minY = seg[1];
+                if (minY > seg.y) {
+                    minY = seg.y;
                 }
-                if (maxY < seg[1]) {
-                    maxY = seg[1];
+                if (maxY < seg.y) {
+                    maxY = seg.y;
                 }
-                y = seg[1];
+                y = seg.y;
                 break;
             }
             case 'H': {
-                if (minX > seg[1]) {
-                    minX = seg[1];
+                if (minX > seg.x) {
+                    minX = seg.x;
                 }
-                if (maxX < seg[1]) {
-                    maxX = seg[1];
+                if (maxX < seg.x) {
+                    maxX = seg.x;
                 }
-                x = seg[1];
+                x = seg.x;
                 break;
             }
             case 'C': {
-                const cxMinMax = minmaxC([x, seg[1], seg[3], seg[5]]);
+                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[2], seg[4], seg[6]]);
+                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[5];
-                y = seg[6];
+                x = seg.x;
+                y = seg.y;
                 break;
             }
             case 'Q': {
-                const qxMinMax = minmaxQ([x, seg[1], seg[3]]);
+                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[2], seg[4]]);
+                const qyMinMax = minmaxQ([y, seg.cpy, seg.y]);
                 if (minY > qyMinMax[0]) {
                     minY = qyMinMax[0];
                 }
                 if (maxY < qyMinMax[1]) {
                     maxY = qyMinMax[1];
                 }
-                x = seg[3];
-                y = seg[4];
+                x = seg.x;
+                y = seg.y;
                 break;
             }
+            case 'Z':
+                break;
             default:
-                throw new Error(`Unknown instruction ${seg[0]}`);
+                // @ts-expect-error
+                throw new Error(`Unknown instruction ${seg.type}`);
         }
     }
     return { x1: minX, y1: minY, x2: maxX, y2: maxY };

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;