@remotion/paths 4.0.50 → 4.0.51

package/dist/helpers/arc.js

@@ -221,6 +221,7 @@ const makeArc = ({ x0, y0, rx, ry, xAxisRotate, LargeArcFlag, SweepFlag, x1, y1,
         getPointAtLength,
         getTangentAtLength,
         getTotalLength,
+        type: 'arc',
     };
 };
 exports.makeArc = makeArc;

package/dist/helpers/bezier-functions.d.ts

@@ -1,6 +1,10 @@
 import type { Point } from './types';
 export declare const cubicPoint: (xs: number[], ys: number[], t: number) => Point;
-export declare const getCubicArcLength: (xs: number[], ys: number[], t: number) => number;
+export declare const getCubicArcLength: ({ sx, sy, t, }: {
+    sx: number[];
+    sy: number[];
+    t: number;
+}) => number;
 export declare const quadraticPoint: (xs: number[], ys: number[], t: number) => Point;
 export declare const cubicDerivative: (xs: number[], ys: number[], t: number) => Point;
 export declare const getQuadraticArcLength: (xs: number[], ys: number[], t: number) => number;
@@ -8,4 +12,8 @@ export declare const quadraticDerivative: (xs: number[], ys: number[], t: number
     x: number;
     y: number;
 };
-export declare const t2length: (length: number, totalLength: number, func: (t: number) => number) => number;
+export declare const t2length: ({ length, totalLength, func, }: {
+    length: number;
+    totalLength: number;
+    func: (t: number) => number;
+}) => number;

package/dist/helpers/bezier-functions.js

@@ -46,14 +46,14 @@ function bFunc(xs, ys, t) {
     const combined = xbase * xbase + ybase * ybase;
     return Math.sqrt(combined);
 }
-const getCubicArcLength = (xs, ys, t) => {
+const getCubicArcLength = ({ sx, sy, t, }) => {
     let correctedT;
     const n = 20;
     const z = t / 2;
     let sum = 0;
     for (let i = 0; i < n; i++) {
         correctedT = z * bezier_values_1.tValues[n][i] + z;
-        sum += bezier_values_1.cValues[n][i] * bFunc(xs, ys, correctedT);
+        sum += bezier_values_1.cValues[n][i] * bFunc(sx, sy, correctedT);
     }
     return z * sum;
 };
@@ -102,7 +102,7 @@ const quadraticDerivative = (xs, ys, t) => {
     };
 };
 exports.quadraticDerivative = quadraticDerivative;
-const t2length = (length, totalLength, func) => {
+const t2length = ({ length, totalLength, func, }) => {
     let error = 1;
     let t = length / totalLength;
     let step = (length - func(t)) / totalLength;

package/dist/helpers/bezier.d.ts

@@ -1,26 +1,25 @@
-import type { Point } from './types';
-export declare const makeBezier: ({ ax, ay, bx, by, cx, cy, dx, dy, }: {
-    ax: number;
-    ay: number;
-    bx: number;
-    by: number;
-    cx: number;
-    cy: number;
-    dx: number | null;
-    dy: number | null;
-}) => {
-    getPointAtLength: (len: number) => Point;
-    getPropertiesAtLength: (len: number) => {
-        x: number;
-        y: number;
-        tangentX: number;
-        tangentY: number;
-    };
-    getTangentAtLength: (len: number) => Point;
-    getTotalLength: () => number;
-    getC: () => {
-        x: number;
-        y: number;
-    };
+import type { Point, Properties } from './types';
+export declare const makeQuadratic: ({ startX, startY, cpx, cpy, x, y, }: {
+    startX: number;
+    startY: number;
+    cpx: number;
+    cpy: number;
+    x: number;
+    y: number;
+}) => Properties & {
+    getC: () => Point;
+    getD: () => Point;
+};
+export declare const makeCubic: ({ startX, startY, cp1x, cp1y, cp2x, cp2y, x, y, }: {
+    startX: number;
+    startY: number;
+    cp1x: number;
+    cp1y: number;
+    cp2x: number;
+    cp2y: number;
+    x: number;
+    y: number;
+}) => Properties & {
+    getC: () => Point;
     getD: () => Point;
 };

package/dist/helpers/bezier.js

@@ -1,43 +1,35 @@
 "use strict";
 // Copied from: https://github.com/rveciana/svg-path-properties
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeBezier = void 0;
+exports.makeCubic = exports.makeQuadratic = void 0;
 const bezier_functions_1 = require("./bezier-functions");
-const makeBezier = ({ ax, ay, bx, by, cx, cy, dx, dy, }) => {
-    let d;
-    let getArcLength;
-    let getPoint;
-    let getDerivative;
-    const a = { x: ax, y: ay };
-    const b = { x: bx, y: by };
-    const c = { x: cx, y: cy };
-    if (dx !== null && dy !== null) {
-        getArcLength = bezier_functions_1.getCubicArcLength;
-        getPoint = bezier_functions_1.cubicPoint;
-        getDerivative = bezier_functions_1.cubicDerivative;
-        d = { x: dx, y: dy };
-    }
-    else {
-        getArcLength = bezier_functions_1.getQuadraticArcLength;
-        getPoint = bezier_functions_1.quadraticPoint;
-        getDerivative = bezier_functions_1.quadraticDerivative;
-        d = { x: 0, y: 0 };
-    }
-    const length = getArcLength([a.x, b.x, c.x, d.x], [a.y, b.y, c.y, d.y], 1);
+const makeQuadratic = ({ startX, startY, cpx, cpy, x, y, }) => {
+    const a = { x: startX, y: startY };
+    const b = { x: cpx, y: cpy };
+    const c = { x, y };
+    const length = (0, bezier_functions_1.getQuadraticArcLength)([a.x, b.x, c.x, 0], [a.y, b.y, c.y, 0], 1);
     const getTotalLength = () => {
         return length;
     };
     const getPointAtLength = (len) => {
-        const xs = [a.x, b.x, c.x, d.x];
-        const xy = [a.y, b.y, c.y, d.y];
-        const t = (0, bezier_functions_1.t2length)(len, len, (i) => getArcLength(xs, xy, i));
-        return getPoint(xs, xy, t);
+        const xs = [a.x, b.x, c.x, 0];
+        const xy = [a.y, b.y, c.y, 0];
+        const t = (0, bezier_functions_1.t2length)({
+            length: len,
+            totalLength: length,
+            func: (i) => (0, bezier_functions_1.getQuadraticArcLength)(xs, xy, i),
+        });
+        return (0, bezier_functions_1.quadraticPoint)(xs, xy, t);
     };
     const getTangentAtLength = (len) => {
-        const xs = [a.x, b.x, c.x, d.x];
-        const xy = [a.y, b.y, c.y, d.y];
-        const t = (0, bezier_functions_1.t2length)(len, len, (i) => getArcLength(xs, xy, i));
-        const derivative = getDerivative(xs, xy, t);
+        const xs = [a.x, b.x, c.x, 0];
+        const xy = [a.y, b.y, c.y, 0];
+        const t = (0, bezier_functions_1.t2length)({
+            length: len,
+            totalLength: length,
+            func: (i) => (0, bezier_functions_1.getQuadraticArcLength)(xs, xy, i),
+        });
+        const derivative = (0, bezier_functions_1.quadraticDerivative)(xs, xy, t);
         const mdl = Math.sqrt(derivative.x * derivative.x + derivative.y * derivative.y);
         let tangent;
         if (mdl > 0) {
@@ -48,11 +40,53 @@ const makeBezier = ({ ax, ay, bx, by, cx, cy, dx, dy, }) => {
         }
         return tangent;
     };
-    const getPropertiesAtLength = (len) => {
+    const getC = () => {
+        return c;
+    };
+    return {
+        getPointAtLength,
+        getTangentAtLength,
+        getTotalLength,
+        getC,
+        type: 'quadratic-bezier',
+        getD: () => ({ x: 0, y: 0 }),
+    };
+};
+exports.makeQuadratic = makeQuadratic;
+const makeCubic = ({ startX, startY, cp1x, cp1y, cp2x, cp2y, x, y, }) => {
+    const a = { x: startX, y: startY };
+    const b = { x: cp1x, y: cp1y };
+    const c = { x: cp2x, y: cp2y };
+    const d = { x, y };
+    const length = (0, bezier_functions_1.getCubicArcLength)({
+        sx: [a.x, b.x, c.x, d.x],
+        sy: [a.y, b.y, c.y, d.y],
+        t: 1,
+    });
+    const getTotalLength = () => {
+        return length;
+    };
+    const getPointAtLength = (len) => {
+        const sx = [a.x, b.x, c.x, d.x];
+        const sy = [a.y, b.y, c.y, d.y];
+        const t = (0, bezier_functions_1.t2length)({
+            length: len,
+            totalLength: length,
+            func: (i) => {
+                return (0, bezier_functions_1.getCubicArcLength)({ sx, sy, t: i });
+            },
+        });
+        return (0, bezier_functions_1.cubicPoint)(sx, sy, t);
+    };
+    const getTangentAtLength = (len) => {
         const xs = [a.x, b.x, c.x, d.x];
         const xy = [a.y, b.y, c.y, d.y];
-        const t = (0, bezier_functions_1.t2length)(len, len, (i) => getArcLength(xs, xy, i));
-        const derivative = getDerivative(xs, xy, t);
+        const t = (0, bezier_functions_1.t2length)({
+            length: len,
+            totalLength: length,
+            func: (i) => (0, bezier_functions_1.getCubicArcLength)({ sx: xs, sy: xy, t: i }),
+        });
+        const derivative = (0, bezier_functions_1.cubicDerivative)(xs, xy, t);
         const mdl = Math.sqrt(derivative.x * derivative.x + derivative.y * derivative.y);
         let tangent;
         if (mdl > 0) {
@@ -61,8 +95,7 @@ const makeBezier = ({ ax, ay, bx, by, cx, cy, dx, dy, }) => {
         else {
             tangent = { x: 0, y: 0 };
         }
-        const point = getPoint(xs, xy, t);
-        return { x: point.x, y: point.y, tangentX: tangent.x, tangentY: tangent.y };
+        return tangent;
     };
     const getC = () => {
         return c;
@@ -72,11 +105,11 @@ const makeBezier = ({ ax, ay, bx, by, cx, cy, dx, dy, }) => {
     };
     return {
         getPointAtLength,
-        getPropertiesAtLength,
         getTangentAtLength,
         getTotalLength,
         getC,
         getD,
+        type: 'cubic-bezier',
     };
 };
-exports.makeBezier = makeBezier;
+exports.makeCubic = makeCubic;

package/dist/helpers/construct.js

@@ -113,30 +113,30 @@ const constructFromInstructions = (instructions) => {
             // Cubic Bezier curves
         }
         else if (instruction.type === 'C') {
-            curve = (0, bezier_1.makeBezier)({
-                ax: cur[0],
-                ay: cur[1],
-                bx: instruction.cp1x,
-                by: instruction.cp1y,
-                cx: instruction.cp2x,
-                cy: instruction.cp2y,
-                dx: instruction.x,
-                dy: instruction.y,
+            curve = (0, bezier_1.makeCubic)({
+                startX: cur[0],
+                startY: cur[1],
+                cp1x: instruction.cp1x,
+                cp1y: instruction.cp1y,
+                cp2x: instruction.cp2x,
+                cp2y: instruction.cp2y,
+                x: instruction.x,
+                y: instruction.y,
             });
             length += curve.getTotalLength();
             cur = [instruction.x, instruction.y];
             functions.push(curve);
         }
         else if (instruction.type === 'c') {
-            curve = (0, bezier_1.makeBezier)({
-                ax: cur[0],
-                ay: cur[1],
-                bx: cur[0] + instruction.cp1dx,
-                by: cur[1] + instruction.cp1dy,
-                cx: cur[0] + instruction.cp2dx,
-                cy: cur[1] + instruction.cp2dy,
-                dx: cur[0] + instruction.dx,
-                dy: cur[1] + instruction.dy,
+            curve = (0, bezier_1.makeCubic)({
+                startX: cur[0],
+                startY: cur[1],
+                cp1x: cur[0] + instruction.cp1dx,
+                cp1y: cur[1] + instruction.cp1dy,
+                cp2x: cur[0] + instruction.cp2dx,
+                cp2y: cur[1] + instruction.cp2dy,
+                x: cur[0] + instruction.dx,
+                y: cur[1] + instruction.dy,
             });
             if (curve.getTotalLength() > 0) {
                 length += curve.getTotalLength();
@@ -156,28 +156,28 @@ const constructFromInstructions = (instructions) => {
             if (i > 0 && prevWasCurve) {
                 if (curve) {
                     const c = curve.getC();
-                    curve = (0, bezier_1.makeBezier)({
-                        ax: cur[0],
-                        ay: cur[1],
-                        bx: 2 * cur[0] - c.x,
-                        by: 2 * cur[1] - c.y,
-                        cx: instruction.cpx,
-                        cy: instruction.cpy,
-                        dx: instruction.x,
-                        dy: instruction.y,
+                    curve = (0, bezier_1.makeCubic)({
+                        startX: cur[0],
+                        startY: cur[1],
+                        cp1x: 2 * cur[0] - c.x,
+                        cp1y: 2 * cur[1] - c.y,
+                        cp2x: instruction.cpx,
+                        cp2y: instruction.cpy,
+                        x: instruction.x,
+                        y: instruction.y,
                     });
                 }
             }
             else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: cur[0],
-                    by: cur[1],
-                    cx: instruction.cpx,
-                    cy: instruction.cpy,
-                    dx: instruction.x,
-                    dy: instruction.y,
+                curve = (0, bezier_1.makeCubic)({
+                    startX: cur[0],
+                    startY: cur[1],
+                    cp1x: cur[0],
+                    cp1y: cur[1],
+                    cp2x: instruction.cpx,
+                    cp2y: instruction.cpy,
+                    x: instruction.x,
+                    y: instruction.y,
                 });
             }
             if (curve) {
@@ -196,28 +196,28 @@ const constructFromInstructions = (instructions) => {
                 if (curve) {
                     const c = curve.getC();
                     const d = curve.getD();
-                    curve = (0, bezier_1.makeBezier)({
-                        ax: cur[0],
-                        ay: cur[1],
-                        bx: cur[0] + d.x - c.x,
-                        by: cur[1] + d.y - c.y,
-                        cx: cur[0] + instruction.cpdx,
-                        cy: cur[1] + instruction.cpdy,
-                        dx: cur[0] + instruction.dx,
-                        dy: cur[1] + instruction.dy,
+                    curve = (0, bezier_1.makeCubic)({
+                        startX: cur[0],
+                        startY: cur[1],
+                        cp1x: cur[0] + d.x - c.x,
+                        cp1y: cur[1] + d.y - c.y,
+                        cp2x: cur[0] + instruction.cpdx,
+                        cp2y: cur[1] + instruction.cpdy,
+                        x: cur[0] + instruction.dx,
+                        y: cur[1] + instruction.dy,
                     });
                 }
             }
             else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: cur[0],
-                    by: cur[1],
-                    cx: cur[0] + instruction.cpdx,
-                    cy: cur[1] + instruction.cpdy,
-                    dx: cur[0] + instruction.dx,
-                    dy: cur[1] + instruction.dy,
+                curve = (0, bezier_1.makeCubic)({
+                    startX: cur[0],
+                    startY: cur[1],
+                    cp1x: cur[0],
+                    cp1y: cur[1],
+                    cp2x: cur[0] + instruction.cpdx,
+                    cp2y: cur[1] + instruction.cpdy,
+                    x: cur[0] + instruction.dx,
+                    y: cur[1] + instruction.dy,
                 });
             }
             if (curve) {
@@ -239,15 +239,13 @@ const constructFromInstructions = (instructions) => {
                 functions.push(linearCurve);
             }
             else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: instruction.cpx,
-                    by: instruction.cpy,
-                    cx: instruction.x,
-                    cy: instruction.y,
-                    dx: null,
-                    dy: null,
+                curve = (0, bezier_1.makeQuadratic)({
+                    startX: cur[0],
+                    startY: cur[1],
+                    cpx: instruction.cpx,
+                    cpy: instruction.cpy,
+                    x: instruction.x,
+                    y: instruction.y,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);
@@ -267,15 +265,13 @@ const constructFromInstructions = (instructions) => {
                 functions.push(linearCurve);
             }
             else {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: cur[0] + instruction.cpdx,
-                    by: cur[1] + instruction.cpdy,
-                    cx: cur[0] + instruction.dx,
-                    cy: cur[1] + instruction.dy,
-                    dx: null,
-                    dy: null,
+                curve = (0, bezier_1.makeQuadratic)({
+                    startX: cur[0],
+                    startY: cur[1],
+                    cpx: cur[0] + instruction.cpdx,
+                    cpy: cur[1] + instruction.cpdy,
+                    x: cur[0] + instruction.dx,
+                    y: cur[1] + instruction.dy,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);
@@ -290,15 +286,13 @@ const constructFromInstructions = (instructions) => {
                 prev.type === 'T' ||
                 prev.type === 't';
             if (i > 0 && prevWasQ) {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: 2 * cur[0] - prev_point[0],
-                    by: 2 * cur[1] - prev_point[1],
-                    cx: instruction.x,
-                    cy: instruction.y,
-                    dx: null,
-                    dy: null,
+                curve = (0, bezier_1.makeQuadratic)({
+                    startX: cur[0],
+                    startY: cur[1],
+                    cpx: 2 * cur[0] - prev_point[0],
+                    cpy: 2 * cur[1] - prev_point[1],
+                    x: instruction.x,
+                    y: instruction.y,
                 });
                 functions.push(curve);
                 length += curve.getTotalLength();
@@ -323,15 +317,13 @@ const constructFromInstructions = (instructions) => {
                 prev.type === 'T' ||
                 prev.type === 't';
             if (i > 0 && prevWasQ) {
-                curve = (0, bezier_1.makeBezier)({
-                    ax: cur[0],
-                    ay: cur[1],
-                    bx: 2 * cur[0] - prev_point[0],
-                    by: 2 * cur[1] - prev_point[1],
-                    cx: cur[0] + instruction.dx,
-                    cy: cur[1] + instruction.dy,
-                    dx: null,
-                    dy: null,
+                curve = (0, bezier_1.makeQuadratic)({
+                    startX: cur[0],
+                    startY: cur[1],
+                    cpx: 2 * cur[0] - prev_point[0],
+                    cpy: 2 * cur[1] - prev_point[1],
+                    x: cur[0] + instruction.dx,
+                    y: cur[1] + instruction.dy,
                 });
                 length += curve.getTotalLength();
                 functions.push(curve);

package/dist/helpers/linear.d.ts

@@ -1,12 +1,7 @@
-import type { Point, PointProperties } from './types';
+import type { Properties } from './types';
 export declare const makeLinearPosition: ({ x0, x1, y0, y1, }: {
     x0: number;
     x1: number;
     y0: number;
     y1: number;
-}) => {
-    getTotalLength: () => number;
-    getPointAtLength: (pos: number) => Point;
-    getTangentAtLength: () => Point;
-    getPropertiesAtLength: () => PointProperties;
-};
+}) => Properties;

package/dist/helpers/linear.js

@@ -16,15 +16,11 @@ const makeLinearPosition = ({ x0, x1, y0, y1, }) => {
         const module = Math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0));
         return { x: (x1 - x0) / module, y: (y1 - y0) / module };
     };
-    const getPropertiesAtLength = () => {
-        const tangent = getTangentAtLength();
-        return { tangentX: tangent.x, tangentY: tangent.y };
-    };
     return {
         getTotalLength,
         getPointAtLength,
         getTangentAtLength,
-        getPropertiesAtLength,
+        type: 'linear',
     };
 };
 exports.makeLinearPosition = makeLinearPosition;

package/dist/helpers/types.d.ts

@@ -2,6 +2,7 @@ export interface Properties {
     getTotalLength(): number;
     getPointAtLength(pos: number): Point;
     getTangentAtLength(pos: number): Point;
+    type: string;
 }
 export interface Part {
     start: Point;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/paths",
-  "version": "4.0.50",
+  "version": "4.0.51",
   "description": "Utility functions for SVG paths",
   "main": "dist/index.js",
   "sideEffects": false,

package/dist/center-path.d.ts

@@ -1 +0,0 @@
-export declare const centerPath: (path: string) => string;

package/dist/center-path.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.centerPath = void 0;
-const get_bounding_box_1 = require("./get-bounding-box");
-const translate_path_1 = require("./translate-path");
-const centerPath = (path) => {
-    const bBox = (0, get_bounding_box_1.getBoundingBox)(path);
-    const buttonWidth = bBox.x2 - bBox.x1;
-    const buttonHeight = bBox.y2 - bBox.y1;
-    const centeredButton = (0, translate_path_1.translatePath)(path, -buttonWidth / 2, -buttonHeight / 2);
-    return centeredButton;
-};
-exports.centerPath = centerPath;