@excalidraw/excalidraw 0.17.1-7441-0269e5a → 0.17.1-7441-4c9a6f4

package/dist/packages/excalidraw/ga.js

@@ -0,0 +1,268 @@
+/**
+ * This is a 2D Projective Geometric Algebra implementation.
+ *
+ * For wider context on geometric algebra visit see https://bivector.net.
+ *
+ * For this specific algebra see cheatsheet https://bivector.net/2DPGA.pdf.
+ *
+ * Converted from generator written by enki, with a ton of added on top.
+ *
+ * This library uses 8-vectors to represent points, directions and lines
+ * in 2D space.
+ *
+ * An array `[a, b, c, d, e, f, g, h]` represents a n(8)vector:
+ *   a + b*e0 + c*e1 + d*e2 + e*e01 + f*e20 + g*e12 + h*e012
+ *
+ * See GAPoint, GALine, GADirection and GATransform modules for common
+ * operations.
+ */
+export const point = (x, y) => [0, 0, 0, 0, y, x, 1, 0];
+export const origin = () => [0, 0, 0, 0, 0, 0, 1, 0];
+export const direction = (x, y) => {
+    const norm = Math.hypot(x, y); // same as `inorm(direction(x, y))`
+    return [0, 0, 0, 0, y / norm, x / norm, 0, 0];
+};
+export const offset = (x, y) => [
+    0,
+    0,
+    0,
+    0,
+    y,
+    x,
+    0,
+    0,
+];
+// These are labels for what each number in an nvector represents
+const NVECTOR_BASE = ["1", "e0", "e1", "e2", "e01", "e20", "e12", "e012"];
+// Used to represent points, lines and transformations
+export const nvector = (value = 0, index = 0) => {
+    const result = [0, 0, 0, 0, 0, 0, 0, 0];
+    if (index < 0 || index > 7) {
+        throw new Error(`Expected \`index\` between 0 and 7, got \`${index}\``);
+    }
+    if (value !== 0) {
+        result[index] = value;
+    }
+    return result;
+};
+const STRING_EPSILON = 0.000001;
+export const toString = (nvector) => {
+    const result = nvector
+        .map((value, index) => Math.abs(value) > STRING_EPSILON
+        ? value.toFixed(7).replace(/(\.|0+)$/, "") +
+            (index > 0 ? NVECTOR_BASE[index] : "")
+        : null)
+        .filter((representation) => representation != null)
+        .join(" + ");
+    return result === "" ? "0" : result;
+};
+// Reverse the order of the basis blades.
+export const reverse = (nvector) => [
+    nvector[0],
+    nvector[1],
+    nvector[2],
+    nvector[3],
+    -nvector[4],
+    -nvector[5],
+    -nvector[6],
+    -nvector[7],
+];
+// Poincare duality operator.
+export const dual = (nvector) => [
+    nvector[7],
+    nvector[6],
+    nvector[5],
+    nvector[4],
+    nvector[3],
+    nvector[2],
+    nvector[1],
+    nvector[0],
+];
+// Clifford Conjugation
+export const conjugate = (nvector) => [
+    nvector[0],
+    -nvector[1],
+    -nvector[2],
+    -nvector[3],
+    -nvector[4],
+    -nvector[5],
+    -nvector[6],
+    nvector[7],
+];
+// Main involution
+export const involute = (nvector) => [
+    nvector[0],
+    -nvector[1],
+    -nvector[2],
+    -nvector[3],
+    nvector[4],
+    nvector[5],
+    nvector[6],
+    -nvector[7],
+];
+// Multivector addition
+export const add = (a, b) => {
+    if (isNumber(b)) {
+        return [a[0] + b, a[1], a[2], a[3], a[4], a[5], a[6], a[7]];
+    }
+    return [
+        a[0] + b[0],
+        a[1] + b[1],
+        a[2] + b[2],
+        a[3] + b[3],
+        a[4] + b[4],
+        a[5] + b[5],
+        a[6] + b[6],
+        a[7] + b[7],
+    ];
+};
+// Multivector subtraction
+export const sub = (a, b) => {
+    if (isNumber(b)) {
+        return [a[0] - b, a[1], a[2], a[3], a[4], a[5], a[6], a[7]];
+    }
+    return [
+        a[0] - b[0],
+        a[1] - b[1],
+        a[2] - b[2],
+        a[3] - b[3],
+        a[4] - b[4],
+        a[5] - b[5],
+        a[6] - b[6],
+        a[7] - b[7],
+    ];
+};
+// The geometric product.
+export const mul = (a, b) => {
+    if (isNumber(b)) {
+        return [
+            a[0] * b,
+            a[1] * b,
+            a[2] * b,
+            a[3] * b,
+            a[4] * b,
+            a[5] * b,
+            a[6] * b,
+            a[7] * b,
+        ];
+    }
+    return [
+        mulScalar(a, b),
+        b[1] * a[0] +
+            b[0] * a[1] -
+            b[4] * a[2] +
+            b[5] * a[3] +
+            b[2] * a[4] -
+            b[3] * a[5] -
+            b[7] * a[6] -
+            b[6] * a[7],
+        b[2] * a[0] + b[0] * a[2] - b[6] * a[3] + b[3] * a[6],
+        b[3] * a[0] + b[6] * a[2] + b[0] * a[3] - b[2] * a[6],
+        b[4] * a[0] +
+            b[2] * a[1] -
+            b[1] * a[2] +
+            b[7] * a[3] +
+            b[0] * a[4] +
+            b[6] * a[5] -
+            b[5] * a[6] +
+            b[3] * a[7],
+        b[5] * a[0] -
+            b[3] * a[1] +
+            b[7] * a[2] +
+            b[1] * a[3] -
+            b[6] * a[4] +
+            b[0] * a[5] +
+            b[4] * a[6] +
+            b[2] * a[7],
+        b[6] * a[0] + b[3] * a[2] - b[2] * a[3] + b[0] * a[6],
+        b[7] * a[0] +
+            b[6] * a[1] +
+            b[5] * a[2] +
+            b[4] * a[3] +
+            b[3] * a[4] +
+            b[2] * a[5] +
+            b[1] * a[6] +
+            b[0] * a[7],
+    ];
+};
+export const mulScalar = (a, b) => b[0] * a[0] + b[2] * a[2] + b[3] * a[3] - b[6] * a[6];
+// The outer/exterior/wedge product.
+export const meet = (a, b) => [
+    b[0] * a[0],
+    b[1] * a[0] + b[0] * a[1],
+    b[2] * a[0] + b[0] * a[2],
+    b[3] * a[0] + b[0] * a[3],
+    b[4] * a[0] + b[2] * a[1] - b[1] * a[2] + b[0] * a[4],
+    b[5] * a[0] - b[3] * a[1] + b[1] * a[3] + b[0] * a[5],
+    b[6] * a[0] + b[3] * a[2] - b[2] * a[3] + b[0] * a[6],
+    b[7] * a[0] +
+        b[6] * a[1] +
+        b[5] * a[2] +
+        b[4] * a[3] +
+        b[3] * a[4] +
+        b[2] * a[5] +
+        b[1] * a[6],
+];
+// The regressive product.
+export const join = (a, b) => [
+    joinScalar(a, b),
+    a[1] * b[7] + a[4] * b[5] - a[5] * b[4] + a[7] * b[1],
+    a[2] * b[7] - a[4] * b[6] + a[6] * b[4] + a[7] * b[2],
+    a[3] * b[7] + a[5] * b[6] - a[6] * b[5] + a[7] * b[3],
+    a[4] * b[7] + a[7] * b[4],
+    a[5] * b[7] + a[7] * b[5],
+    a[6] * b[7] + a[7] * b[6],
+    a[7] * b[7],
+];
+export const joinScalar = (a, b) => a[0] * b[7] +
+    a[1] * b[6] +
+    a[2] * b[5] +
+    a[3] * b[4] +
+    a[4] * b[3] +
+    a[5] * b[2] +
+    a[6] * b[1] +
+    a[7] * b[0];
+// The inner product.
+export const dot = (a, b) => [
+    b[0] * a[0] + b[2] * a[2] + b[3] * a[3] - b[6] * a[6],
+    b[1] * a[0] +
+        b[0] * a[1] -
+        b[4] * a[2] +
+        b[5] * a[3] +
+        b[2] * a[4] -
+        b[3] * a[5] -
+        b[7] * a[6] -
+        b[6] * a[7],
+    b[2] * a[0] + b[0] * a[2] - b[6] * a[3] + b[3] * a[6],
+    b[3] * a[0] + b[6] * a[2] + b[0] * a[3] - b[2] * a[6],
+    b[4] * a[0] + b[7] * a[3] + b[0] * a[4] + b[3] * a[7],
+    b[5] * a[0] + b[7] * a[2] + b[0] * a[5] + b[2] * a[7],
+    b[6] * a[0] + b[0] * a[6],
+    b[7] * a[0] + b[0] * a[7],
+];
+export const norm = (a) => Math.sqrt(Math.abs(a[0] * a[0] - a[2] * a[2] - a[3] * a[3] + a[6] * a[6]));
+export const inorm = (a) => Math.sqrt(Math.abs(a[7] * a[7] - a[5] * a[5] - a[4] * a[4] + a[1] * a[1]));
+export const normalized = (a) => {
+    const n = norm(a);
+    if (n === 0 || n === 1) {
+        return a;
+    }
+    const sign = a[6] < 0 ? -1 : 1;
+    return mul(a, sign / n);
+};
+export const inormalized = (a) => {
+    const n = inorm(a);
+    if (n === 0 || n === 1) {
+        return a;
+    }
+    return mul(a, 1 / n);
+};
+const isNumber = (a) => typeof a === "number";
+export const E0 = nvector(1, 1);
+export const E1 = nvector(1, 2);
+export const E2 = nvector(1, 3);
+export const E01 = nvector(1, 4);
+export const E20 = nvector(1, 5);
+export const E12 = nvector(1, 6);
+export const E012 = nvector(1, 7);
+export const I = E012;

package/dist/packages/excalidraw/gadirections.js

@@ -0,0 +1,18 @@
+import * as GA from "./ga";
+/**
+ * A direction is stored as an array `[0, 0, 0, 0, y, x, 0, 0]` representing
+ * vector `(x, y)`.
+ */
+export const from = (point) => [
+    0,
+    0,
+    0,
+    0,
+    point[4],
+    point[5],
+    0,
+    0,
+];
+export const fromTo = (from, to) => GA.inormalized([0, 0, 0, 0, to[4] - from[4], to[5] - from[5], 0, 0]);
+export const orthogonal = (direction) => GA.inormalized([0, 0, 0, 0, -direction[5], direction[4], 0, 0]);
+export const orthogonalToLine = (line) => GA.mul(line, GA.I);

package/dist/packages/excalidraw/galines.js

@@ -0,0 +1,32 @@
+import * as GA from "./ga";
+/**
+ * A line is stored as an array `[0, c, a, b, 0, 0, 0, 0]` representing:
+ *   c * e0 + a * e1 + b*e2
+ *
+ * This maps to a standard formula `a * x + b * y + c`.
+ *
+ * `(-b, a)` corresponds to a 2D vector parallel to the line. The lines
+ * have a natural orientation, corresponding to that vector.
+ *
+ * The magnitude ("norm") of the line is `sqrt(a ^ 2 + b ^ 2)`.
+ * `c / norm(line)` is the oriented distance from line to origin.
+ */
+// Returns line with direction (x, y) through origin
+export const vector = (x, y) => GA.normalized([0, 0, -y, x, 0, 0, 0, 0]);
+// For equation ax + by + c = 0.
+export const equation = (a, b, c) => GA.normalized([0, c, a, b, 0, 0, 0, 0]);
+export const through = (from, to) => GA.normalized(GA.join(to, from));
+export const orthogonal = (line, point) => GA.dot(line, point);
+// Returns a line perpendicular to the line through `against` and `intersection`
+// going through `intersection`.
+export const orthogonalThrough = (against, intersection) => orthogonal(through(against, intersection), intersection);
+export const parallel = (line, distance) => {
+    const result = line.slice();
+    result[1] -= distance;
+    return result;
+};
+export const parallelThrough = (line, point) => orthogonal(orthogonal(point, line), point);
+export const distance = (line1, line2) => GA.inorm(GA.meet(line1, line2));
+export const angle = (line1, line2) => Math.acos(GA.dot(line1, line2)[0]);
+// The orientation of the line
+export const sign = (line) => Math.sign(line[1]);

package/dist/packages/excalidraw/gapoints.js

@@ -0,0 +1,30 @@
+import * as GA from "./ga";
+import * as GALine from "./galines";
+import { join } from "./ga";
+export const from = ([x, y]) => [
+    0,
+    0,
+    0,
+    0,
+    y,
+    x,
+    1,
+    0,
+];
+export const toTuple = (point) => [point[5], point[4]];
+export const abs = (point) => [
+    0,
+    0,
+    0,
+    0,
+    Math.abs(point[4]),
+    Math.abs(point[5]),
+    1,
+    0,
+];
+export const intersect = (line1, line2) => GA.normalized(GA.meet(line1, line2));
+// Projects `point` onto the `line`.
+// The returned point is the closest point on the `line` to the `point`.
+export const project = (point, line) => intersect(GALine.orthogonal(line, point), line);
+export const distance = (point1, point2) => GA.norm(join(point1, point2));
+export const distanceToLine = (point, line) => GA.joinScalar(point, line);

package/dist/packages/excalidraw/gatransforms.js

@@ -0,0 +1,23 @@
+import * as GA from "./ga";
+import * as GADirection from "./gadirections";
+/**
+ * TODO: docs
+ */
+export const rotation = (pivot, angle) => GA.add(GA.mul(pivot, Math.sin(angle / 2)), Math.cos(angle / 2));
+export const translation = (direction) => [
+    1,
+    0,
+    0,
+    0,
+    -(0.5 * direction[5]),
+    0.5 * direction[4],
+    0,
+    0,
+];
+export const translationOrthogonal = (direction, distance) => {
+    const scale = 0.5 * distance;
+    return [1, 0, 0, 0, scale * direction[4], scale * direction[5], 0, 0];
+};
+export const translationAlong = (line, distance) => GA.add(GA.mul(GADirection.orthogonalToLine(line), 0.5 * distance), 1);
+export const compose = (motor1, motor2) => GA.mul(motor2, motor1);
+export const apply = (motor, nvector) => GA.normalized(GA.mul(GA.mul(motor, nvector), GA.reverse(motor)));

package/dist/packages/excalidraw/gesture.js

@@ -0,0 +1,9 @@
+export const getCenter = (pointers) => {
+    const allCoords = Array.from(pointers.values());
+    return {
+        x: sum(allCoords, (coords) => coords.x) / allCoords.length,
+        y: sum(allCoords, (coords) => coords.y) / allCoords.length,
+    };
+};
+export const getDistance = ([a, b]) => Math.hypot(a.x - b.x, a.y - b.y);
+const sum = (array, mapper) => array.reduce((acc, item) => acc + mapper(item), 0);

package/dist/packages/excalidraw/groups.js

@@ -0,0 +1,225 @@
+import { getSelectedElements } from "./scene";
+import { getBoundTextElement } from "./element/textElement";
+import { makeNextSelectedElementIds } from "./scene/selection";
+export const selectGroup = (groupId, appState, elements) => {
+    const elementsInGroup = elements.reduce((acc, element) => {
+        if (element.groupIds.includes(groupId)) {
+            acc[element.id] = true;
+        }
+        return acc;
+    }, {});
+    if (Object.keys(elementsInGroup).length < 2) {
+        if (appState.selectedGroupIds[groupId] ||
+            appState.editingGroupId === groupId) {
+            return {
+                selectedElementIds: appState.selectedElementIds,
+                selectedGroupIds: { ...appState.selectedGroupIds, [groupId]: false },
+                editingGroupId: null,
+            };
+        }
+        return appState;
+    }
+    return {
+        editingGroupId: appState.editingGroupId,
+        selectedGroupIds: { ...appState.selectedGroupIds, [groupId]: true },
+        selectedElementIds: {
+            ...appState.selectedElementIds,
+            ...elementsInGroup,
+        },
+    };
+};
+export const selectGroupsForSelectedElements = (function () {
+    let lastSelectedElements = null;
+    let lastElements = null;
+    let lastReturnValue = null;
+    const _selectGroups = (selectedElements, elements, appState, prevAppState) => {
+        if (lastReturnValue !== undefined &&
+            elements === lastElements &&
+            selectedElements === lastSelectedElements &&
+            appState.editingGroupId === lastReturnValue?.editingGroupId) {
+            return lastReturnValue;
+        }
+        const selectedGroupIds = {};
+        // Gather all the groups withing selected elements
+        for (const selectedElement of selectedElements) {
+            let groupIds = selectedElement.groupIds;
+            if (appState.editingGroupId) {
+                // handle the case where a group is nested within a group
+                const indexOfEditingGroup = groupIds.indexOf(appState.editingGroupId);
+                if (indexOfEditingGroup > -1) {
+                    groupIds = groupIds.slice(0, indexOfEditingGroup);
+                }
+            }
+            if (groupIds.length > 0) {
+                const lastSelectedGroup = groupIds[groupIds.length - 1];
+                selectedGroupIds[lastSelectedGroup] = true;
+            }
+        }
+        // Gather all the elements within selected groups
+        const groupElementsIndex = {};
+        const selectedElementIdsInGroups = elements.reduce((acc, element) => {
+            const groupId = element.groupIds.find((id) => selectedGroupIds[id]);
+            if (groupId) {
+                acc[element.id] = true;
+                // Populate the index
+                if (!Array.isArray(groupElementsIndex[groupId])) {
+                    groupElementsIndex[groupId] = [element.id];
+                }
+                else {
+                    groupElementsIndex[groupId].push(element.id);
+                }
+            }
+            return acc;
+        }, {});
+        for (const groupId of Object.keys(groupElementsIndex)) {
+            // If there is one element in the group, and the group is selected or it's being edited, it's not a group
+            if (groupElementsIndex[groupId].length < 2) {
+                if (selectedGroupIds[groupId]) {
+                    selectedGroupIds[groupId] = false;
+                }
+            }
+        }
+        lastElements = elements;
+        lastSelectedElements = selectedElements;
+        lastReturnValue = {
+            editingGroupId: appState.editingGroupId,
+            selectedGroupIds,
+            selectedElementIds: makeNextSelectedElementIds({
+                ...appState.selectedElementIds,
+                ...selectedElementIdsInGroups,
+            }, prevAppState),
+        };
+        return lastReturnValue;
+    };
+    /**
+     * When you select an element, you often want to actually select the whole group it's in, unless
+     * you're currently editing that group.
+     */
+    const selectGroupsForSelectedElements = (appState, elements, prevAppState, 
+    /**
+     * supply null in cases where you don't have access to App instance and
+     * you don't care about optimizing selectElements retrieval
+     */
+    app) => {
+        const selectedElements = app
+            ? app.scene.getSelectedElements({
+                selectedElementIds: appState.selectedElementIds,
+                // supplying elements explicitly in case we're passed non-state elements
+                elements,
+            })
+            : getSelectedElements(elements, appState);
+        if (!selectedElements.length) {
+            return {
+                selectedGroupIds: {},
+                editingGroupId: null,
+                selectedElementIds: makeNextSelectedElementIds(appState.selectedElementIds, prevAppState),
+            };
+        }
+        return _selectGroups(selectedElements, elements, appState, prevAppState);
+    };
+    selectGroupsForSelectedElements.clearCache = () => {
+        lastElements = null;
+        lastSelectedElements = null;
+        lastReturnValue = null;
+    };
+    return selectGroupsForSelectedElements;
+})();
+/**
+ * If the element's group is selected, don't render an individual
+ * selection border around it.
+ */
+export const isSelectedViaGroup = (appState, element) => getSelectedGroupForElement(appState, element) != null;
+export const getSelectedGroupForElement = (appState, element) => element.groupIds
+    .filter((groupId) => groupId !== appState.editingGroupId)
+    .find((groupId) => appState.selectedGroupIds[groupId]);
+export const getSelectedGroupIds = (appState) => Object.entries(appState.selectedGroupIds)
+    .filter(([groupId, isSelected]) => isSelected)
+    .map(([groupId, isSelected]) => groupId);
+// given a list of elements, return the the actual group ids that should be selected
+// or used to update the elements
+export const selectGroupsFromGivenElements = (elements, appState) => {
+    let nextAppState = {
+        ...appState,
+        selectedGroupIds: {},
+    };
+    for (const element of elements) {
+        let groupIds = element.groupIds;
+        if (appState.editingGroupId) {
+            const indexOfEditingGroup = groupIds.indexOf(appState.editingGroupId);
+            if (indexOfEditingGroup > -1) {
+                groupIds = groupIds.slice(0, indexOfEditingGroup);
+            }
+        }
+        if (groupIds.length > 0) {
+            const groupId = groupIds[groupIds.length - 1];
+            nextAppState = {
+                ...nextAppState,
+                ...selectGroup(groupId, nextAppState, elements),
+            };
+        }
+    }
+    return nextAppState.selectedGroupIds;
+};
+export const editGroupForSelectedElement = (appState, element) => {
+    return {
+        ...appState,
+        editingGroupId: element.groupIds.length ? element.groupIds[0] : null,
+        selectedGroupIds: {},
+        selectedElementIds: {
+            [element.id]: true,
+        },
+    };
+};
+export const isElementInGroup = (element, groupId) => element.groupIds.includes(groupId);
+export const getElementsInGroup = (elements, groupId) => elements.filter((element) => isElementInGroup(element, groupId));
+export const getSelectedGroupIdForElement = (element, selectedGroupIds) => element.groupIds.find((groupId) => selectedGroupIds[groupId]);
+export const getNewGroupIdsForDuplication = (groupIds, editingGroupId, mapper) => {
+    const copy = [...groupIds];
+    const positionOfEditingGroupId = editingGroupId
+        ? groupIds.indexOf(editingGroupId)
+        : -1;
+    const endIndex = positionOfEditingGroupId > -1 ? positionOfEditingGroupId : groupIds.length;
+    for (let index = 0; index < endIndex; index++) {
+        copy[index] = mapper(copy[index]);
+    }
+    return copy;
+};
+export const addToGroup = (prevGroupIds, newGroupId, editingGroupId) => {
+    // insert before the editingGroupId, or push to the end.
+    const groupIds = [...prevGroupIds];
+    const positionOfEditingGroupId = editingGroupId
+        ? groupIds.indexOf(editingGroupId)
+        : -1;
+    const positionToInsert = positionOfEditingGroupId > -1 ? positionOfEditingGroupId : groupIds.length;
+    groupIds.splice(positionToInsert, 0, newGroupId);
+    return groupIds;
+};
+export const removeFromSelectedGroups = (groupIds, selectedGroupIds) => groupIds.filter((groupId) => !selectedGroupIds[groupId]);
+export const getMaximumGroups = (elements) => {
+    const groups = new Map();
+    elements.forEach((element) => {
+        const groupId = element.groupIds.length === 0
+            ? element.id
+            : element.groupIds[element.groupIds.length - 1];
+        const currentGroupMembers = groups.get(groupId) || [];
+        // Include bound text if present when grouping
+        const boundTextElement = getBoundTextElement(element);
+        if (boundTextElement) {
+            currentGroupMembers.push(boundTextElement);
+        }
+        groups.set(groupId, [...currentGroupMembers, element]);
+    });
+    return Array.from(groups.values());
+};
+export const elementsAreInSameGroup = (elements) => {
+    const allGroups = elements.flatMap((element) => element.groupIds);
+    const groupCount = new Map();
+    let maxGroup = 0;
+    for (const group of allGroups) {
+        groupCount.set(group, (groupCount.get(group) ?? 0) + 1);
+        if (groupCount.get(group) > maxGroup) {
+            maxGroup = groupCount.get(group);
+        }
+    }
+    return maxGroup === elements.length;
+};