@efxlab/motion-canvas-2d 4.0.0

package/lib/code/diff.js

@@ -0,0 +1,236 @@
+/**
+ * Performs a patience diff on two arrays of strings, returning an object
+ * containing the lines that were deleted, inserted, and potentially moved
+ * lines. The plus parameter can result in a significant performance hit due
+ * to additional Longest Common Substring searches.
+ *
+ * @param aLines - The original array of strings
+ * @param bLines - The new array of strings
+ * @param plus - Whether to return the moved lines
+ *
+ * Adapted from Jonathan "jonTrent" Trent's patience-diff algorithm.
+ * Types and tests added by Hunter "hhenrichsen" Henrichsen.
+ *
+ * {@link https://github.com/jonTrent/PatienceDiff}
+ */
+export function patienceDiff(aLines, bLines) {
+    /**
+     * Finds all unique values in lines[start...end], inclusive. This
+     * function is used in preparation for determining the longest common
+     * subsequence.
+     *
+     * @param lines - The array to search
+     * @param start - The starting index (inclusive)
+     * @param end - The ending index (inclusive)
+     * @returns A map of the unique lines to their index
+     */
+    function findUnique(lines, start, end) {
+        const lineMap = new Map();
+        for (let i = start; i <= end; i++) {
+            const line = lines[i];
+            const data = lineMap.get(line);
+            if (data) {
+                data.count++;
+                data.index = i;
+            }
+            else {
+                lineMap.set(line, { count: 1, index: i });
+            }
+        }
+        const newMap = new Map();
+        for (const [key, value] of lineMap) {
+            if (value.count === 1) {
+                newMap.set(key, value.index);
+            }
+        }
+        return newMap;
+    }
+    /**
+     * Finds all the unique common entries between aArray[aStart...aEnd] and
+     * bArray[bStart...bEnd], inclusive. This function uses findUnique to pare
+     * down the aArray and bArray ranges first, before then walking the
+     * comparison between the two arrays.
+     *
+     *
+     * @param aArray - The original array
+     * @param aStart - The start of the original array to search
+     * @param aEnd - The end of the original array to search, inclusive
+     * @param bArray - The new array
+     * @param bStart - the start of the new array to search
+     * @param bEnd - The end of the new array to search, inclusive
+     * @returns a Map, with the key as the common line between aArray and
+     * bArray, with the value as an object containing the array indices of the
+     * matching uniqe lines.
+     */
+    function uniqueCommon(aArray, aStart, aEnd, bArray, bStart, bEnd) {
+        const aUnique = findUnique(aArray, aStart, aEnd);
+        const bUnique = findUnique(bArray, bStart, bEnd);
+        return [...aUnique.entries()].reduce((paired, [key, value]) => {
+            const bIndex = bUnique.get(key);
+            if (bIndex !== undefined) {
+                paired.set(key, {
+                    aIndex: value,
+                    bIndex,
+                });
+            }
+            return paired;
+        }, new Map());
+    }
+    /**
+     * Takes a map from the unique common lines between two arrays and determines
+     * the longest common subsequence.
+     *
+     * @see uniqueCommon
+     *
+     * @param abMap - The map of unique common lines between two arrays.
+     * @returns An array of objects containing the indices of the longest common
+     * subsequence.
+     */
+    function longestCommonSubsequence(abMap) {
+        const jagged = [];
+        abMap.forEach(value => {
+            let i = 0;
+            while (jagged[i] && jagged[i].at(-1).bIndex < value.bIndex) {
+                i++;
+            }
+            if (i > 0) {
+                value.prev = jagged[i - 1].at(-1);
+            }
+            if (!jagged[i]) {
+                jagged[i] = [value];
+            }
+            else {
+                jagged[i].push(value);
+            }
+        });
+        // Pull out the longest common subsequence
+        let lcs = [];
+        if (jagged.length > 0) {
+            lcs = [jagged.at(-1).at(-1)];
+            let cursor = lcs.at(-1);
+            while (cursor?.prev) {
+                cursor = cursor.prev;
+                lcs.push(cursor);
+            }
+        }
+        return lcs.reverse();
+    }
+    /**
+     * Keeps track of the aLines that have been deleted, are shared between aLines
+     * and bLines, and bLines that have been inserted.
+     */
+    const result = [];
+    let deleted = 0;
+    let inserted = 0;
+    function addToResult(aIndex, bIndex) {
+        if (bIndex < 0) {
+            deleted++;
+        }
+        else if (aIndex < 0) {
+            inserted++;
+        }
+        result.push({
+            line: 0 <= aIndex ? aLines[aIndex] : bLines[bIndex],
+            aIndex,
+            bIndex,
+            moved: false,
+        });
+    }
+    function addSubMatch(aStart, aEnd, bStart, bEnd) {
+        // Match any lines at the beginning of aLines and bLines.
+        while (aStart <= aEnd &&
+            bStart <= bEnd &&
+            aLines[aStart] === bLines[bStart]) {
+            addToResult(aStart++, bStart++);
+        }
+        // Match any lines at the end of aLines and bLines, but don't place them
+        // in the "result" array just yet, as the lines between these matches at
+        // the beginning and the end need to be analyzed first.
+        const aEndTemp = aEnd;
+        while (aStart <= aEnd && bStart <= bEnd && aLines[aEnd] === bLines[bEnd]) {
+            aEnd--;
+            bEnd--;
+        }
+        // Now, check to determine with the remaining lines in the subsequence
+        // whether there are any unique common lines between aLines and bLines.
+        //
+        // If not, add the subsequence to the result (all aLines having been
+        // deleted, and all bLines having been inserted).
+        //
+        // If there are unique common lines between aLines and bLines, then let's
+        // recursively perform the patience diff on the subsequence.
+        const uniqueCommonMap = uniqueCommon(aLines, aStart, aEnd, bLines, bStart, bEnd);
+        if (uniqueCommonMap.size === 0) {
+            while (aStart <= aEnd) {
+                addToResult(aStart++, -1);
+            }
+            while (bStart <= bEnd) {
+                addToResult(-1, bStart++);
+            }
+        }
+        else {
+            recurseLCS(aStart, aEnd, bStart, bEnd, uniqueCommonMap);
+        }
+        // Finally, let's add the matches at the end to the result.
+        while (aEnd < aEndTemp) {
+            addToResult(++aEnd, ++bEnd);
+        }
+    }
+    /**
+     * Finds the longest common subsequence between the arrays
+     * aLines[aStart...aEnd] and bLines[bStart...bEnd], inclusive. Then for each
+     * subsequence, recursively performs another LCS search (via addSubMatch),
+     * until there are none found, at which point the subsequence is dumped to
+     * the result.
+     *
+     * @param aStart - The start of the original array to search
+     * @param aEnd - The end of the original array to search, inclusive
+     * @param bStart - The start of the new array to search
+     * @param bEnd - The end of the new array to search, inclusive
+     * @param uniqueCommonMap - A map of the unique common lines between
+     * aLines[aStart...aEnd] and bLines[bStart...bEnd], inclusive.
+     */
+    function recurseLCS(aStart, aEnd, bStart, bEnd, uniqueCommonMap = uniqueCommon(aLines, aStart, aEnd, bLines, bStart, bEnd)) {
+        const lcs = longestCommonSubsequence(uniqueCommonMap);
+        if (lcs.length === 0) {
+            addSubMatch(aStart, aEnd, bStart, bEnd);
+        }
+        else {
+            if (aStart < lcs[0].aIndex || bStart < lcs[0].bIndex) {
+                addSubMatch(aStart, lcs[0].aIndex - 1, bStart, lcs[0].bIndex - 1);
+            }
+            let i;
+            for (i = 0; i < lcs.length - 1; i++) {
+                addSubMatch(lcs[i].aIndex, lcs[i + 1].aIndex - 1, lcs[i].bIndex, lcs[i + 1].bIndex - 1);
+            }
+            if (lcs[i].aIndex <= aEnd || lcs[i].bIndex <= bEnd) {
+                addSubMatch(lcs[i].aIndex, aEnd, lcs[i].bIndex, bEnd);
+            }
+        }
+    }
+    recurseLCS(0, aLines.length - 1, 0, bLines.length - 1);
+    return {
+        lines: result,
+        lineCountDeleted: deleted,
+        lineCountInserted: inserted,
+    };
+}
+/**
+ * Utility function for debugging patienceDiff.
+ *
+ * @internal
+ */
+export function printDiff(diff) {
+    diff.lines.forEach(line => {
+        if (line.bIndex < 0) {
+            console.log(`- ${line.line}`);
+        }
+        else if (line.aIndex < 0) {
+            console.log(`+ ${line.line}`);
+        }
+        else {
+            console.log(`  ${line.line}`);
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../src/lib/code/diff.ts"],"names":[],"mappings":"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"}

package/lib/code/extractRange.d.ts

@@ -0,0 +1,17 @@
+import { CodeRange } from './CodeRange';
+import { CodeTag } from './CodeScope';
+/**
+ * Transform the fragments to isolate the given range into its own fragment.
+ *
+ * @remarks
+ * This function will try to preserve the original fragments, resolving them
+ * only if they overlap with the range.
+ *
+ * @param range - The range to extract.
+ * @param fragments - The fragments to transform.
+ *
+ * @returns A tuple containing the transformed fragments and the index of the
+ *          isolated fragment within.
+ */
+export declare function extractRange(range: CodeRange, fragments: CodeTag[]): [CodeTag[], number];
+//# sourceMappingURL=extractRange.d.ts.map

package/lib/code/extractRange.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractRange.d.ts","sourceRoot":"","sources":["../../src/lib/code/extractRange.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,OAAO,EAAiB,MAAM,aAAa,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,OAAO,EAAE,GACnB,CAAC,OAAO,EAAE,EAAE,MAAM,CAAC,CAyGrB"}

package/lib/code/extractRange.js

@@ -0,0 +1,102 @@
+import { resolveCodeTag } from './CodeScope';
+/**
+ * Transform the fragments to isolate the given range into its own fragment.
+ *
+ * @remarks
+ * This function will try to preserve the original fragments, resolving them
+ * only if they overlap with the range.
+ *
+ * @param range - The range to extract.
+ * @param fragments - The fragments to transform.
+ *
+ * @returns A tuple containing the transformed fragments and the index of the
+ *          isolated fragment within.
+ */
+export function extractRange(range, fragments) {
+    const [from, to] = range;
+    let [fromRow, fromColumn] = from;
+    let [toRow, toColumn] = to;
+    if (fromRow > toRow || (fromRow === toRow && fromColumn > toColumn)) {
+        [fromRow, fromColumn] = to;
+        [toRow, toColumn] = from;
+    }
+    let currentRow = 0;
+    let currentColumn = 0;
+    const newFragments = [];
+    let index = -1;
+    let found = false;
+    let extracted = '';
+    for (const fragment of fragments) {
+        if (found) {
+            newFragments.push(fragment);
+            continue;
+        }
+        const resolved = resolveCodeTag(fragment, false);
+        const lines = resolved.split('\n');
+        const newRows = lines.length - 1;
+        const lastColumn = lines[newRows].length;
+        const nextColumn = newRows > 0 ? lastColumn : currentColumn + lastColumn;
+        if (fromRow > currentRow + newRows ||
+            (fromRow === currentRow + newRows && fromColumn > nextColumn)) {
+            currentRow += newRows;
+            currentColumn = nextColumn;
+            newFragments.push(fragment);
+            continue;
+        }
+        for (let i = 0; i < resolved.length; i++) {
+            const char = resolved.charAt(i);
+            if (fromRow === currentRow && fromColumn >= currentColumn) {
+                if (fromColumn === currentColumn) {
+                    index = newFragments.length + 1;
+                    newFragments.push(resolved.slice(0, i), '');
+                }
+                else if (char === '\n') {
+                    index = newFragments.length + 1;
+                    newFragments.push(resolved.slice(0, i) + ' '.repeat(fromColumn - currentColumn), '');
+                }
+            }
+            if (index !== -1 && toRow === currentRow && toColumn >= currentColumn) {
+                if (toColumn === currentColumn) {
+                    newFragments.push(resolved.slice(i));
+                    found = true;
+                    break;
+                }
+                if (char === '\n') {
+                    if (currentColumn < toColumn) {
+                        extracted += '\n';
+                        if (i + 1 < resolved.length) {
+                            newFragments.push(resolved.slice(i + 1));
+                        }
+                    }
+                    else {
+                        newFragments.push(resolved.slice(i));
+                    }
+                    found = true;
+                    break;
+                }
+            }
+            if (index !== -1) {
+                extracted += char;
+            }
+            if (char === '\n') {
+                currentRow++;
+                currentColumn = 0;
+            }
+            else {
+                currentColumn++;
+            }
+        }
+        if (index === -1) {
+            newFragments.push(fragment);
+        }
+    }
+    if (index === -1) {
+        index = newFragments.length + 1;
+        const missingRows = fromRow - currentRow;
+        const missingColumns = missingRows > 0 ? fromColumn : fromColumn - currentColumn;
+        newFragments.push('\n'.repeat(missingRows) + ' '.repeat(missingColumns), '');
+    }
+    newFragments[index] = extracted;
+    return [newFragments, index];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/code/index.d.ts

@@ -0,0 +1,14 @@
+export * from './CodeCursor';
+export * from './CodeDiffer';
+export * from './CodeFragment';
+export * from './CodeHighlighter';
+export * from './CodeRange';
+export * from './CodeScope';
+export * from './CodeSelection';
+export * from './CodeSignal';
+export * from './CodeTokenizer';
+export * from './DefaultHighlightStyle';
+export * from './diff';
+export * from './extractRange';
+export * from './LezerHighlighter';
+//# sourceMappingURL=index.d.ts.map

package/lib/code/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lib/code/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC"}

package/lib/code/index.js

@@ -0,0 +1,14 @@
+export * from './CodeCursor';
+export * from './CodeDiffer';
+export * from './CodeFragment';
+export * from './CodeHighlighter';
+export * from './CodeRange';
+export * from './CodeScope';
+export * from './CodeSelection';
+export * from './CodeSignal';
+export * from './CodeTokenizer';
+export * from './DefaultHighlightStyle';
+export * from './diff';
+export * from './extractRange';
+export * from './LezerHighlighter';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbGliL2NvZGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxvQkFBb0IsQ0FBQyJ9

package/lib/components/Bezier.d.ts

@@ -0,0 +1,22 @@
+import { BBox, SerializedVector2, Vector2 } from '@efxlab/motion-canvas-core';
+import { CurveProfile } from '../curves';
+import { PolynomialSegment } from '../curves/PolynomialSegment';
+import { DesiredLength } from '../partials';
+import { Curve } from './Curve';
+export interface BezierOverlayInfo {
+    curve: Path2D;
+    handleLines: Path2D;
+    controlPoints: Vector2[];
+    startPoint: Vector2;
+    endPoint: Vector2;
+}
+export declare abstract class Bezier extends Curve {
+    profile(): CurveProfile;
+    protected abstract segment(): PolynomialSegment;
+    protected abstract overlayInfo(matrix: DOMMatrix): BezierOverlayInfo;
+    protected childrenBBox(): BBox;
+    protected desiredSize(): SerializedVector2<DesiredLength>;
+    protected offsetComputedLayout(box: BBox): BBox;
+    drawOverlay(context: CanvasRenderingContext2D, matrix: DOMMatrix): void;
+}
+//# sourceMappingURL=Bezier.d.ts.map

package/lib/components/Bezier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Bezier.d.ts","sourceRoot":"","sources":["../../src/lib/components/Bezier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAC,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAC;AACvC,OAAO,EAAC,iBAAiB,EAAC,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAAC,aAAa,EAAC,MAAM,aAAa,CAAC;AAE1C,OAAO,EAAC,KAAK,EAAC,MAAM,SAAS,CAAC;AAE9B,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,OAAO,EAAE,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,8BAAsB,MAAO,SAAQ,KAAK;IACxB,OAAO,IAAI,YAAY;IASvC,SAAS,CAAC,QAAQ,CAAC,OAAO,IAAI,iBAAiB;IAE/C,SAAS,CAAC,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,GAAG,iBAAiB;IAGpE,SAAS,CAAC,YAAY,IAAI,IAAI;cAIX,WAAW,IAAI,iBAAiB,CAAC,aAAa,CAAC;cAI/C,oBAAoB,CAAC,GAAG,EAAE,IAAI,GAAG,IAAI;IAKxC,WAAW,CACzB,OAAO,EAAE,wBAAwB,EACjC,MAAM,EAAE,SAAS;CAwDpB"}

package/lib/components/Bezier.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BBox } from '@efxlab/motion-canvas-core';
+import { computed } from '../decorators';
+import { arc, drawLine, drawPivot, moveTo } from '../utils';
+import { Curve } from './Curve';
+export class Bezier extends Curve {
+    profile() {
+        const segment = this.segment();
+        return {
+            segments: [segment],
+            arcLength: segment.arcLength,
+            minSin: 0,
+        };
+    }
+    childrenBBox() {
+        return BBox.fromPoints(...this.segment().points);
+    }
+    desiredSize() {
+        return this.segment().getBBox().size;
+    }
+    offsetComputedLayout(box) {
+        box.position = box.position.sub(this.segment().getBBox().center);
+        return box;
+    }
+    drawOverlay(context, matrix) {
+        const size = this.computedSize();
+        const box = this.childrenBBox().transformCorners(matrix);
+        const offset = size.mul(this.offset()).scale(0.5).transformAsPoint(matrix);
+        const overlayInfo = this.overlayInfo(matrix);
+        context.lineWidth = 1;
+        context.strokeStyle = 'white';
+        context.fillStyle = 'white';
+        // Draw the curve itself first so everything else gets drawn on top of it
+        context.stroke(overlayInfo.curve);
+        context.fillStyle = 'white';
+        context.globalAlpha = 0.5;
+        context.beginPath();
+        context.stroke(overlayInfo.handleLines);
+        context.globalAlpha = 1;
+        context.lineWidth = 2;
+        // Draw start and end points
+        for (const point of [overlayInfo.startPoint, overlayInfo.endPoint]) {
+            moveTo(context, point);
+            context.beginPath();
+            arc(context, point, 4);
+            context.closePath();
+            context.stroke();
+            context.fill();
+        }
+        // Draw the control points
+        context.fillStyle = 'black';
+        for (const point of overlayInfo.controlPoints) {
+            moveTo(context, point);
+            context.beginPath();
+            arc(context, point, 4);
+            context.closePath();
+            context.fill();
+            context.stroke();
+        }
+        // Draw the offset marker
+        context.lineWidth = 1;
+        context.beginPath();
+        drawPivot(context, offset);
+        context.stroke();
+        // Draw the bounding box
+        context.beginPath();
+        drawLine(context, box);
+        context.closePath();
+        context.stroke();
+    }
+}
+__decorate([
+    computed()
+], Bezier.prototype, "childrenBBox", null);
+//# sourceMappingURL=data:application/json;base64,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