@remotion/paths 4.0.178 → 4.0.180

package/package.json

@@ -3,7 +3,7 @@
     "url": "https://github.com/remotion-dev/remotion/tree/main/packages/paths"
   },
   "name": "@remotion/paths",
-  "version": "4.0.178",
+  "version": "4.0.180",
   "description": "Utilities for working with SVG paths",
   "main": "dist/index.js",
   "sideEffects": false,

package/dist/interpolate-path/array-of-length.d.ts

@@ -1 +0,0 @@
-export declare function arrayOfLength<T>(length: number, value: T): T[];

package/dist/interpolate-path/array-of-length.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayOfLength = void 0;
-function arrayOfLength(length, value) {
-    const array = Array(length);
-    for (let i = 0; i < length; i++) {
-        array[i] = value;
-    }
-    return array;
-}
-exports.arrayOfLength = arrayOfLength;

package/dist/interpolate-path/command-to-string.d.ts

@@ -1,7 +0,0 @@
-import type { Command } from './command';
-/**
- * Converts a command object to a string to be used in a `d` attribute
- * @param {Object} command A command object
- * @return {String} The string for the `d` attribute
- */
-export declare function commandToString(command: Command): string;

package/dist/interpolate-path/command-to-string.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.commandToString = void 0;
-const command_1 = require("./command");
-/**
- * Converts a command object to a string to be used in a `d` attribute
- * @param {Object} command A command object
- * @return {String} The string for the `d` attribute
- */
-function commandToString(command) {
-    return `${command.type} ${command_1.typeMap[command.type]
-        .map((p) => command[p])
-        .join(' ')}`;
-}
-exports.commandToString = commandToString;

package/dist/interpolate-path/command.d.ts

@@ -1,37 +0,0 @@
-/**
- * List of params for each command type in a path `d` attribute
- */
-export declare const typeMap: {
-    M: string[];
-    L: string[];
-    H: string[];
-    V: string[];
-    C: string[];
-    S: string[];
-    Q: string[];
-    T: string[];
-    A: string[];
-    Z: never[];
-    m: string[];
-    l: string[];
-    h: string[];
-    v: string[];
-    c: string[];
-    s: string[];
-    q: string[];
-    t: string[];
-    a: string[];
-    z: never[];
-};
-export type Command = {
-    x2?: number | undefined;
-    y2?: number | undefined;
-    x1?: number | undefined;
-    y1?: number | undefined;
-    x?: number;
-    y?: number;
-    xAxisRotate?: number;
-    largeArcFlag?: boolean;
-    sweepFlag?: boolean;
-    type: keyof typeof typeMap;
-};

package/dist/interpolate-path/command.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typeMap = void 0;
-/**
- * List of params for each command type in a path `d` attribute
- */
-exports.typeMap = {
-    M: ['x', 'y'],
-    L: ['x', 'y'],
-    H: ['x'],
-    V: ['y'],
-    C: ['x1', 'y1', 'x2', 'y2', 'x', 'y'],
-    S: ['x2', 'y2', 'x', 'y'],
-    Q: ['x1', 'y1', 'x', 'y'],
-    T: ['x', 'y'],
-    A: ['rx', 'ry', 'xAxisRotation', 'largeArcFlag', 'sweepFlag', 'x', 'y'],
-    Z: [],
-    m: ['x', 'y'],
-    l: ['x', 'y'],
-    h: ['x'],
-    v: ['y'],
-    c: ['x1', 'y1', 'x2', 'y2', 'x', 'y'],
-    s: ['x2', 'y2', 'x', 'y'],
-    q: ['x1', 'y1', 'x', 'y'],
-    t: ['x', 'y'],
-    a: ['rx', 'ry', 'xAxisRotation', 'largeArcFlag', 'sweepFlag', 'x', 'y'],
-    z: [],
-};

package/dist/interpolate-path/convert-to-same-type.d.ts

@@ -1,22 +0,0 @@
-import type { Command } from './command';
-/**
- * Converts command A to have the same type as command B.
- *
- * e.g., L0,5 -> C0,5,0,5,0,5
- *
- * Uses these rules:
- * x1 <- x
- * x2 <- x
- * y1 <- y
- * y2 <- y
- * rx <- 0
- * ry <- 0
- * xAxisRotation <- read from B
- * largeArcFlag <- read from B
- * sweepflag <- read from B
- *
- * @param {Object} aCommand Command object from path `d` attribute
- * @param {Object} bCommand Command object from path `d` attribute to match against
- * @return {Object} aCommand converted to type of bCommand
- */
-export declare function convertToSameType(aCommand: Command, bCommand: Command): Command;

package/dist/interpolate-path/convert-to-same-type.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToSameType = void 0;
-/**
- * Converts command A to have the same type as command B.
- *
- * e.g., L0,5 -> C0,5,0,5,0,5
- *
- * Uses these rules:
- * x1 <- x
- * x2 <- x
- * y1 <- y
- * y2 <- y
- * rx <- 0
- * ry <- 0
- * xAxisRotation <- read from B
- * largeArcFlag <- read from B
- * sweepflag <- read from B
- *
- * @param {Object} aCommand Command object from path `d` attribute
- * @param {Object} bCommand Command object from path `d` attribute to match against
- * @return {Object} aCommand converted to type of bCommand
- */
-function convertToSameType(aCommand, bCommand) {
-    const conversionMap = {
-        x1: 'x',
-        y1: 'y',
-        x2: 'x',
-        y2: 'y',
-    };
-    const readFromBKeys = ['xAxisRotation', 'largeArcFlag', 'sweepFlag'];
-    // convert (but ignore M types)
-    if (aCommand.type !== bCommand.type && bCommand.type.toUpperCase() !== 'M') {
-        const aConverted = {
-            type: bCommand.type,
-        };
-        Object.keys(bCommand).forEach((bKey) => {
-            const bValue = bCommand[bKey];
-            // first read from the A command
-            let aValue = aCommand[bKey];
-            // if it is one of these values, read from B no matter what
-            if (aValue === undefined) {
-                if (readFromBKeys.includes(bKey)) {
-                    aValue = bValue;
-                }
-                else {
-                    // if it wasn't in the A command, see if an equivalent was
-                    if (aValue === undefined &&
-                        conversionMap[bKey]) {
-                        aValue =
-                            aCommand[conversionMap[bKey]];
-                    }
-                    // if it doesn't have a converted value, use 0
-                    if (aValue === undefined) {
-                        aValue = 0;
-                    }
-                }
-            }
-            // @ts-expect-error
-            aConverted[bKey] = aValue;
-        });
-        // update the type to match B
-        aConverted.type = bCommand.type;
-        aCommand = aConverted;
-    }
-    return aCommand;
-}
-exports.convertToSameType = convertToSameType;

package/dist/interpolate-path/interpolate-commands.d.ts

@@ -1,16 +0,0 @@
-import { type Command } from './command';
-/**
- * Interpolate from A to B by extending A and B during interpolation to have
- * the same number of points. This allows for a smooth transition when they
- * have a different number of points.
- *
- * Ignores the `Z` command in paths unless both A and B end with it.
- *
- * This function works directly with arrays of command objects instead of with
- * path `d` strings (see interpolatePath for working with `d` strings).
- *
- * @param {Object[]} aCommandsInput Array of path commands
- * @param {Object[]} bCommandsInput Array of path commands
- * @returns {Function} Interpolation function that maps t ([0, 1]) to an array of path commands.
- */
-export declare function interpolatePathCommands(aCommandsInput: Command[], bCommandsInput: Command[]): (t: number) => Command[];

package/dist/interpolate-path/interpolate-commands.js

@@ -1,108 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.interpolatePathCommands = void 0;
-const command_1 = require("./command");
-const convert_to_same_type_1 = require("./convert-to-same-type");
-const extend_command_1 = require("./extend-command");
-/**
- * Interpolate from A to B by extending A and B during interpolation to have
- * the same number of points. This allows for a smooth transition when they
- * have a different number of points.
- *
- * Ignores the `Z` command in paths unless both A and B end with it.
- *
- * This function works directly with arrays of command objects instead of with
- * path `d` strings (see interpolatePath for working with `d` strings).
- *
- * @param {Object[]} aCommandsInput Array of path commands
- * @param {Object[]} bCommandsInput Array of path commands
- * @returns {Function} Interpolation function that maps t ([0, 1]) to an array of path commands.
- */
-function interpolatePathCommands(aCommandsInput, bCommandsInput) {
-    // make a copy so we don't mess with the input arrays
-    let aCommands = aCommandsInput === null || aCommandsInput === undefined
-        ? []
-        : aCommandsInput.slice();
-    let bCommands = bCommandsInput === null || bCommandsInput === undefined
-        ? []
-        : bCommandsInput.slice();
-    // both input sets are empty, so we don't interpolate
-    if (!aCommands.length && !bCommands.length) {
-        return function () {
-            return [];
-        };
-    }
-    // do we add Z during interpolation? yes if both have it. (we'd expect both to have it or not)
-    const addZ = (aCommands.length === 0 || aCommands[aCommands.length - 1].type === 'Z') &&
-        (bCommands.length === 0 || bCommands[bCommands.length - 1].type === 'Z');
-    // we temporarily remove Z
-    if (aCommands.length > 0 && aCommands[aCommands.length - 1].type === 'Z') {
-        aCommands.pop();
-    }
-    if (bCommands.length > 0 && bCommands[bCommands.length - 1].type === 'Z') {
-        bCommands.pop();
-    }
-    // if A is empty, treat it as if it used to contain just the first point
-    // of B. This makes it so the line extends out of from that first point.
-    if (!aCommands.length) {
-        aCommands.push(bCommands[0]);
-        // otherwise if B is empty, treat it as if it contains the first point
-        // of A. This makes it so the line retracts into the first point.
-    }
-    else if (!bCommands.length) {
-        bCommands.push(aCommands[0]);
-    }
-    // extend to match equal size
-    const numPointsToExtend = Math.abs(bCommands.length - aCommands.length);
-    if (numPointsToExtend !== 0) {
-        // B has more points than A, so add points to A before interpolating
-        if (bCommands.length > aCommands.length) {
-            aCommands = (0, extend_command_1.extend)(aCommands, bCommands);
-            // else if A has more points than B, add more points to B
-        }
-        else if (bCommands.length < aCommands.length) {
-            bCommands = (0, extend_command_1.extend)(bCommands, aCommands);
-        }
-    }
-    // commands have same length now.
-    // convert commands in A to the same type as those in B
-    aCommands = aCommands.map((aCommand, i) => (0, convert_to_same_type_1.convertToSameType)(aCommand, bCommands[i]));
-    // create mutable interpolated command objects
-    const interpolatedCommands = aCommands.map((aCommand) => ({ ...aCommand }));
-    if (addZ) {
-        interpolatedCommands.push({ type: 'Z' });
-        aCommands.push({ type: 'Z' }); // required for when returning at t == 0
-    }
-    return function (t) {
-        // at 1 return the final value without the extensions used during interpolation
-        if (t === 1) {
-            return bCommandsInput === null || bCommandsInput === undefined
-                ? []
-                : bCommandsInput;
-        }
-        // work with aCommands directly since interpolatedCommands are mutated
-        if (t === 0) {
-            return aCommands;
-        }
-        // interpolate the commands using the mutable interpolated command objs
-        for (let i = 0; i < interpolatedCommands.length; ++i) {
-            // if (interpolatedCommands[i].type === 'Z') continue;
-            const aCommand = aCommands[i];
-            const bCommand = bCommands[i];
-            const interpolatedCommand = interpolatedCommands[i];
-            for (const arg of command_1.typeMap[interpolatedCommand.type]) {
-                // @ts-expect-error
-                interpolatedCommand[arg] =
-                    (1 - t) * aCommand[arg] +
-                        t * bCommand[arg];
-                // do not use floats for flags (#27), round to integer
-                if (arg === 'largeArcFlag' || arg === 'sweepFlag') {
-                    // @ts-expect-error
-                    interpolatedCommand[arg] = Math.round(interpolatedCommand[arg]);
-                }
-            }
-        }
-        return interpolatedCommands;
-    };
-}
-exports.interpolatePathCommands = interpolatePathCommands;

package/dist/interpolate-path/path-commands-from-string.d.ts

@@ -1,8 +0,0 @@
-import { type Command } from './command';
-/**
- * Takes a path `d` string and converts it into an array of command
- * objects. Drops the `Z` character.
- *
- * @param {String|null} d A path `d` string
- */
-export declare function pathCommandsFromString(d: string | null): Command[];

package/dist/interpolate-path/path-commands-from-string.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.pathCommandsFromString = void 0;
-const command_1 = require("./command");
-const commandTokenRegex = /[MLCSTQAHVZmlcstqahv]|-?[\d.e+-]+/g;
-/**
- * Takes a path `d` string and converts it into an array of command
- * objects. Drops the `Z` character.
- *
- * @param {String|null} d A path `d` string
- */
-function pathCommandsFromString(d) {
-    // split into valid tokens
-    const tokens = (d || '').match(commandTokenRegex) || [];
-    const commands = [];
-    let commandArgs;
-    let command;
-    // iterate over each token, checking if we are at a new command
-    // by presence in the typeMap
-    for (let i = 0; i < tokens.length; ++i) {
-        commandArgs = command_1.typeMap[tokens[i]];
-        // new command found:
-        if (commandArgs) {
-            command = {
-                type: tokens[i],
-            };
-            // add each of the expected args for this command:
-            for (let a = 0; a < commandArgs.length; ++a) {
-                // @ts-expect-error
-                command[commandArgs[a]] = Number(tokens[i + a + 1]);
-            }
-            // need to increment our token index appropriately since
-            // we consumed token args
-            i += commandArgs.length;
-            commands.push(command);
-        }
-    }
-    return commands;
-}
-exports.pathCommandsFromString = pathCommandsFromString;