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

package/dist/packages/excalidraw/actions/actionSelectAll.js

@@ -0,0 +1,40 @@
+import { KEYS } from "../keys";
+import { register } from "./register";
+import { selectGroupsForSelectedElements } from "../groups";
+import { getNonDeletedElements, isTextElement } from "../element";
+import { isLinearElement } from "../element/typeChecks";
+import { LinearElementEditor } from "../element/linearElementEditor";
+import { excludeElementsInFramesFromSelection } from "../scene/selection";
+export const actionSelectAll = register({
+    name: "selectAll",
+    trackEvent: { category: "canvas" },
+    perform: (elements, appState, value, app) => {
+        if (appState.editingLinearElement) {
+            return false;
+        }
+        const selectedElementIds = excludeElementsInFramesFromSelection(elements.filter((element) => !element.isDeleted &&
+            !(isTextElement(element) && element.containerId) &&
+            !element.locked)).reduce((map, element) => {
+            map[element.id] = true;
+            return map;
+        }, {});
+        return {
+            appState: {
+                ...appState,
+                ...selectGroupsForSelectedElements({
+                    editingGroupId: null,
+                    selectedElementIds,
+                }, getNonDeletedElements(elements), appState, app),
+                selectedLinearElement: 
+                // single linear element selected
+                Object.keys(selectedElementIds).length === 1 &&
+                    isLinearElement(elements[0])
+                    ? new LinearElementEditor(elements[0], app.scene)
+                    : null,
+            },
+            commitToHistory: true,
+        };
+    },
+    contextItemLabel: "labels.selectAll",
+    keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.key === KEYS.A,
+});

package/dist/packages/excalidraw/actions/actionStyles.js

@@ -0,0 +1,118 @@
+import { isTextElement, isExcalidrawElement, redrawTextBoundingBox, } from "../element";
+import { CODES, KEYS } from "../keys";
+import { t } from "../i18n";
+import { register } from "./register";
+import { newElementWith } from "../element/mutateElement";
+import { DEFAULT_FONT_SIZE, DEFAULT_FONT_FAMILY, DEFAULT_TEXT_ALIGN, } from "../constants";
+import { getBoundTextElement, getDefaultLineHeight, } from "../element/textElement";
+import { hasBoundTextElement, canApplyRoundnessTypeToElement, getDefaultRoundnessTypeForElement, isFrameLikeElement, isArrowElement, } from "../element/typeChecks";
+import { getSelectedElements } from "../scene";
+// `copiedStyles` is exported only for tests.
+export let copiedStyles = "{}";
+export const actionCopyStyles = register({
+    name: "copyStyles",
+    trackEvent: { category: "element" },
+    perform: (elements, appState) => {
+        const elementsCopied = [];
+        const element = elements.find((el) => appState.selectedElementIds[el.id]);
+        elementsCopied.push(element);
+        if (element && hasBoundTextElement(element)) {
+            const boundTextElement = getBoundTextElement(element);
+            elementsCopied.push(boundTextElement);
+        }
+        if (element) {
+            copiedStyles = JSON.stringify(elementsCopied);
+        }
+        return {
+            appState: {
+                ...appState,
+                toast: { message: t("toast.copyStyles") },
+            },
+            commitToHistory: false,
+        };
+    },
+    contextItemLabel: "labels.copyStyles",
+    keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.C,
+});
+export const actionPasteStyles = register({
+    name: "pasteStyles",
+    trackEvent: { category: "element" },
+    perform: (elements, appState) => {
+        const elementsCopied = JSON.parse(copiedStyles);
+        const pastedElement = elementsCopied[0];
+        const boundTextElement = elementsCopied[1];
+        if (!isExcalidrawElement(pastedElement)) {
+            return { elements, commitToHistory: false };
+        }
+        const selectedElements = getSelectedElements(elements, appState, {
+            includeBoundTextElement: true,
+        });
+        const selectedElementIds = selectedElements.map((element) => element.id);
+        return {
+            elements: elements.map((element) => {
+                if (selectedElementIds.includes(element.id)) {
+                    let elementStylesToCopyFrom = pastedElement;
+                    if (isTextElement(element) && element.containerId) {
+                        elementStylesToCopyFrom = boundTextElement;
+                    }
+                    if (!elementStylesToCopyFrom) {
+                        return element;
+                    }
+                    let newElement = newElementWith(element, {
+                        backgroundColor: elementStylesToCopyFrom?.backgroundColor,
+                        strokeWidth: elementStylesToCopyFrom?.strokeWidth,
+                        strokeColor: elementStylesToCopyFrom?.strokeColor,
+                        strokeStyle: elementStylesToCopyFrom?.strokeStyle,
+                        fillStyle: elementStylesToCopyFrom?.fillStyle,
+                        opacity: elementStylesToCopyFrom?.opacity,
+                        roughness: elementStylesToCopyFrom?.roughness,
+                        roundness: elementStylesToCopyFrom.roundness
+                            ? canApplyRoundnessTypeToElement(elementStylesToCopyFrom.roundness.type, element)
+                                ? elementStylesToCopyFrom.roundness
+                                : getDefaultRoundnessTypeForElement(element)
+                            : null,
+                    });
+                    if (isTextElement(newElement)) {
+                        const fontSize = elementStylesToCopyFrom.fontSize ||
+                            DEFAULT_FONT_SIZE;
+                        const fontFamily = elementStylesToCopyFrom.fontFamily ||
+                            DEFAULT_FONT_FAMILY;
+                        newElement = newElementWith(newElement, {
+                            fontSize,
+                            fontFamily,
+                            textAlign: elementStylesToCopyFrom.textAlign ||
+                                DEFAULT_TEXT_ALIGN,
+                            lineHeight: elementStylesToCopyFrom.lineHeight ||
+                                getDefaultLineHeight(fontFamily),
+                        });
+                        let container = null;
+                        if (newElement.containerId) {
+                            container =
+                                selectedElements.find((element) => isTextElement(newElement) &&
+                                    element.id === newElement.containerId) || null;
+                        }
+                        redrawTextBoundingBox(newElement, container);
+                    }
+                    if (newElement.type === "arrow" &&
+                        isArrowElement(elementStylesToCopyFrom)) {
+                        newElement = newElementWith(newElement, {
+                            startArrowhead: elementStylesToCopyFrom.startArrowhead,
+                            endArrowhead: elementStylesToCopyFrom.endArrowhead,
+                        });
+                    }
+                    if (isFrameLikeElement(element)) {
+                        newElement = newElementWith(newElement, {
+                            roundness: null,
+                            backgroundColor: "transparent",
+                        });
+                    }
+                    return newElement;
+                }
+                return element;
+            }),
+            commitToHistory: true,
+        };
+    },
+    contextItemLabel: "labels.pasteStyles",
+    keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.V,
+});

package/dist/packages/excalidraw/actions/actionToggleGridMode.js

@@ -0,0 +1,27 @@
+import { CODES, KEYS } from "../keys";
+import { register } from "./register";
+import { GRID_SIZE } from "../constants";
+export const actionToggleGridMode = register({
+    name: "gridMode",
+    viewMode: true,
+    trackEvent: {
+        category: "canvas",
+        predicate: (appState) => !appState.gridSize,
+    },
+    perform(elements, appState) {
+        return {
+            appState: {
+                ...appState,
+                gridSize: this.checked(appState) ? null : GRID_SIZE,
+                objectsSnapModeEnabled: false,
+            },
+            commitToHistory: false,
+        };
+    },
+    checked: (appState) => appState.gridSize !== null,
+    predicate: (element, appState, props) => {
+        return typeof props.gridModeEnabled === "undefined";
+    },
+    contextItemLabel: "labels.showGrid",
+    keyTest: (event) => event[KEYS.CTRL_OR_CMD] && event.code === CODES.QUOTE,
+});

package/dist/packages/excalidraw/actions/actionToggleObjectsSnapMode.js

@@ -0,0 +1,26 @@
+import { CODES, KEYS } from "../keys";
+import { register } from "./register";
+export const actionToggleObjectsSnapMode = register({
+    name: "objectsSnapMode",
+    viewMode: true,
+    trackEvent: {
+        category: "canvas",
+        predicate: (appState) => !appState.objectsSnapModeEnabled,
+    },
+    perform(elements, appState) {
+        return {
+            appState: {
+                ...appState,
+                objectsSnapModeEnabled: !this.checked(appState),
+                gridSize: null,
+            },
+            commitToHistory: false,
+        };
+    },
+    checked: (appState) => appState.objectsSnapModeEnabled,
+    predicate: (elements, appState, appProps) => {
+        return typeof appProps.objectsSnapModeEnabled === "undefined";
+    },
+    contextItemLabel: "buttons.objectsSnapMode",
+    keyTest: (event) => !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.S,
+});

package/dist/packages/excalidraw/actions/actionToggleStats.js

@@ -0,0 +1,19 @@
+import { register } from "./register";
+import { CODES, KEYS } from "../keys";
+export const actionToggleStats = register({
+    name: "stats",
+    viewMode: true,
+    trackEvent: { category: "menu" },
+    perform(elements, appState) {
+        return {
+            appState: {
+                ...appState,
+                showStats: !this.checked(appState),
+            },
+            commitToHistory: false,
+        };
+    },
+    checked: (appState) => appState.showStats,
+    contextItemLabel: "stats.title",
+    keyTest: (event) => !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.SLASH,
+});

package/dist/packages/excalidraw/actions/actionToggleViewMode.js

@@ -0,0 +1,25 @@
+import { CODES, KEYS } from "../keys";
+import { register } from "./register";
+export const actionToggleViewMode = register({
+    name: "viewMode",
+    viewMode: true,
+    trackEvent: {
+        category: "canvas",
+        predicate: (appState) => !appState.viewModeEnabled,
+    },
+    perform(elements, appState) {
+        return {
+            appState: {
+                ...appState,
+                viewModeEnabled: !this.checked(appState),
+            },
+            commitToHistory: false,
+        };
+    },
+    checked: (appState) => appState.viewModeEnabled,
+    predicate: (elements, appState, appProps) => {
+        return typeof appProps.viewModeEnabled === "undefined";
+    },
+    contextItemLabel: "labels.viewMode",
+    keyTest: (event) => !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.R,
+});

package/dist/packages/excalidraw/actions/actionToggleZenMode.js

@@ -0,0 +1,25 @@
+import { CODES, KEYS } from "../keys";
+import { register } from "./register";
+export const actionToggleZenMode = register({
+    name: "zenMode",
+    viewMode: true,
+    trackEvent: {
+        category: "canvas",
+        predicate: (appState) => !appState.zenModeEnabled,
+    },
+    perform(elements, appState) {
+        return {
+            appState: {
+                ...appState,
+                zenModeEnabled: !this.checked(appState),
+            },
+            commitToHistory: false,
+        };
+    },
+    checked: (appState) => appState.zenModeEnabled,
+    predicate: (elements, appState, appProps) => {
+        return typeof appProps.zenModeEnabled === "undefined";
+    },
+    contextItemLabel: "buttons.zenMode",
+    keyTest: (event) => !event[KEYS.CTRL_OR_CMD] && event.altKey && event.code === CODES.Z,
+});

package/dist/packages/excalidraw/actions/actionZindex.js

@@ -0,0 +1,86 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { moveOneLeft, moveOneRight, moveAllLeft, moveAllRight, } from "../zindex";
+import { KEYS, CODES } from "../keys";
+import { t } from "../i18n";
+import { getShortcutKey } from "../utils";
+import { register } from "./register";
+import { BringForwardIcon, BringToFrontIcon, SendBackwardIcon, SendToBackIcon, } from "../components/icons";
+import { isDarwin } from "../constants";
+export const actionSendBackward = register({
+    name: "sendBackward",
+    trackEvent: { category: "element" },
+    perform: (elements, appState) => {
+        return {
+            elements: moveOneLeft(elements, appState),
+            appState,
+            commitToHistory: true,
+        };
+    },
+    contextItemLabel: "labels.sendBackward",
+    keyPriority: 40,
+    keyTest: (event) => event[KEYS.CTRL_OR_CMD] &&
+        !event.shiftKey &&
+        event.code === CODES.BRACKET_LEFT,
+    PanelComponent: ({ updateData, appState }) => (_jsx("button", { type: "button", className: "zIndexButton", onClick: () => updateData(null), title: `${t("labels.sendBackward")} — ${getShortcutKey("CtrlOrCmd+[")}`, children: SendBackwardIcon })),
+});
+export const actionBringForward = register({
+    name: "bringForward",
+    trackEvent: { category: "element" },
+    perform: (elements, appState) => {
+        return {
+            elements: moveOneRight(elements, appState),
+            appState,
+            commitToHistory: true,
+        };
+    },
+    contextItemLabel: "labels.bringForward",
+    keyPriority: 40,
+    keyTest: (event) => event[KEYS.CTRL_OR_CMD] &&
+        !event.shiftKey &&
+        event.code === CODES.BRACKET_RIGHT,
+    PanelComponent: ({ updateData, appState }) => (_jsx("button", { type: "button", className: "zIndexButton", onClick: () => updateData(null), title: `${t("labels.bringForward")} — ${getShortcutKey("CtrlOrCmd+]")}`, children: BringForwardIcon })),
+});
+export const actionSendToBack = register({
+    name: "sendToBack",
+    trackEvent: { category: "element" },
+    perform: (elements, appState) => {
+        return {
+            elements: moveAllLeft(elements, appState),
+            appState,
+            commitToHistory: true,
+        };
+    },
+    contextItemLabel: "labels.sendToBack",
+    keyTest: (event) => isDarwin
+        ? event[KEYS.CTRL_OR_CMD] &&
+            event.altKey &&
+            event.code === CODES.BRACKET_LEFT
+        : event[KEYS.CTRL_OR_CMD] &&
+            event.shiftKey &&
+            event.code === CODES.BRACKET_LEFT,
+    PanelComponent: ({ updateData, appState }) => (_jsx("button", { type: "button", className: "zIndexButton", onClick: () => updateData(null), title: `${t("labels.sendToBack")} — ${isDarwin
+            ? getShortcutKey("CtrlOrCmd+Alt+[")
+            : getShortcutKey("CtrlOrCmd+Shift+[")}`, children: SendToBackIcon })),
+});
+export const actionBringToFront = register({
+    name: "bringToFront",
+    trackEvent: { category: "element" },
+    perform: (elements, appState) => {
+        return {
+            elements: moveAllRight(elements, appState),
+            appState,
+            commitToHistory: true,
+        };
+    },
+    contextItemLabel: "labels.bringToFront",
+    keyTest: (event) => isDarwin
+        ? event[KEYS.CTRL_OR_CMD] &&
+            event.altKey &&
+            event.code === CODES.BRACKET_RIGHT
+        : event[KEYS.CTRL_OR_CMD] &&
+            event.shiftKey &&
+            event.code === CODES.BRACKET_RIGHT,
+    PanelComponent: ({ updateData, appState }) => (_jsx("button", { type: "button", className: "zIndexButton", onClick: (event) => updateData(null), title: `${t("labels.bringToFront")} — ${isDarwin
+            ? getShortcutKey("CtrlOrCmd+Alt+]")
+            : getShortcutKey("CtrlOrCmd+Shift+]")}`, children: BringToFrontIcon })),
+});

package/dist/packages/excalidraw/actions/index.js

@@ -0,0 +1,25 @@
+export { actionDeleteSelected } from "./actionDeleteSelected";
+export { actionBringForward, actionBringToFront, actionSendBackward, actionSendToBack, } from "./actionZindex";
+export { actionSelectAll } from "./actionSelectAll";
+export { actionDuplicateSelection } from "./actionDuplicateSelection";
+export { actionChangeStrokeColor, actionChangeBackgroundColor, actionChangeStrokeWidth, actionChangeFillStyle, actionChangeSloppiness, actionChangeOpacity, actionChangeFontSize, actionChangeFontFamily, actionChangeTextAlign, actionChangeVerticalAlign, } from "./actionProperties";
+export { actionChangeViewBackgroundColor, actionClearCanvas, actionZoomIn, actionZoomOut, actionResetZoom, actionZoomToFit, actionToggleTheme, } from "./actionCanvas";
+export { actionFinalize } from "./actionFinalize";
+export { actionChangeProjectName, actionChangeExportBackground, actionSaveToActiveFile, actionSaveFileToDisk, actionLoadScene, } from "./actionExport";
+export { actionCopyStyles, actionPasteStyles } from "./actionStyles";
+export { actionToggleCanvasMenu, actionToggleEditMenu, actionShortcuts, } from "./actionMenu";
+export { actionGroup, actionUngroup } from "./actionGroup";
+export { actionGoToCollaborator } from "./actionNavigate";
+export { actionAddToLibrary } from "./actionAddToLibrary";
+export { actionAlignTop, actionAlignBottom, actionAlignLeft, actionAlignRight, actionAlignVerticallyCentered, actionAlignHorizontallyCentered, } from "./actionAlign";
+export { distributeHorizontally, distributeVertically, } from "./actionDistribute";
+export { actionFlipHorizontal, actionFlipVertical } from "./actionFlip";
+export { actionCopy, actionCut, actionCopyAsPng, actionCopyAsSvg, copyText, } from "./actionClipboard";
+export { actionToggleGridMode } from "./actionToggleGridMode";
+export { actionToggleZenMode } from "./actionToggleZenMode";
+export { actionToggleObjectsSnapMode } from "./actionToggleObjectsSnapMode";
+export { actionToggleStats } from "./actionToggleStats";
+export { actionUnbindText, actionBindText } from "./actionBoundText";
+export { actionLink } from "../element/Hyperlink";
+export { actionToggleElementLock } from "./actionElementLock";
+export { actionToggleLinearEditor } from "./actionLinearEditor";

package/dist/packages/excalidraw/actions/manager.js

@@ -0,0 +1,110 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { trackEvent } from "../analytics";
+const trackAction = (action, source, appState, elements, app, value) => {
+    if (action.trackEvent) {
+        try {
+            if (typeof action.trackEvent === "object") {
+                const shouldTrack = action.trackEvent.predicate
+                    ? action.trackEvent.predicate(appState, elements, value)
+                    : true;
+                if (shouldTrack) {
+                    trackEvent(action.trackEvent.category, action.trackEvent.action || action.name, `${source} (${app.device.editor.isMobile ? "mobile" : "desktop"})`);
+                }
+            }
+        }
+        catch (error) {
+            console.error("error while logging action:", error);
+        }
+    }
+};
+export class ActionManager {
+    actions = {};
+    updater;
+    getAppState;
+    getElementsIncludingDeleted;
+    app;
+    constructor(updater, getAppState, getElementsIncludingDeleted, app) {
+        this.updater = (actionResult) => {
+            if (actionResult && "then" in actionResult) {
+                actionResult.then((actionResult) => {
+                    return updater(actionResult);
+                });
+            }
+            else {
+                return updater(actionResult);
+            }
+        };
+        this.getAppState = getAppState;
+        this.getElementsIncludingDeleted = getElementsIncludingDeleted;
+        this.app = app;
+    }
+    registerAction(action) {
+        this.actions[action.name] = action;
+    }
+    registerAll(actions) {
+        actions.forEach((action) => this.registerAction(action));
+    }
+    handleKeyDown(event) {
+        const canvasActions = this.app.props.UIOptions.canvasActions;
+        const data = Object.values(this.actions)
+            .sort((a, b) => (b.keyPriority || 0) - (a.keyPriority || 0))
+            .filter((action) => (action.name in canvasActions
+            ? canvasActions[action.name]
+            : true) &&
+            action.keyTest &&
+            action.keyTest(event, this.getAppState(), this.getElementsIncludingDeleted(), this.app));
+        if (data.length !== 1) {
+            if (data.length > 1) {
+                console.warn("Canceling as multiple actions match this shortcut", data);
+            }
+            return false;
+        }
+        const action = data[0];
+        if (this.getAppState().viewModeEnabled && action.viewMode !== true) {
+            return false;
+        }
+        const elements = this.getElementsIncludingDeleted();
+        const appState = this.getAppState();
+        const value = null;
+        trackAction(action, "keyboard", appState, elements, this.app, null);
+        event.preventDefault();
+        event.stopPropagation();
+        this.updater(data[0].perform(elements, appState, value, this.app));
+        return true;
+    }
+    executeAction(action, source = "api", value = null) {
+        const elements = this.getElementsIncludingDeleted();
+        const appState = this.getAppState();
+        trackAction(action, source, appState, elements, this.app, value);
+        this.updater(action.perform(elements, appState, value, this.app));
+    }
+    /**
+     * @param data additional data sent to the PanelComponent
+     */
+    renderAction = (name, data) => {
+        const canvasActions = this.app.props.UIOptions.canvasActions;
+        if (this.actions[name] &&
+            "PanelComponent" in this.actions[name] &&
+            (name in canvasActions
+                ? canvasActions[name]
+                : true)) {
+            const action = this.actions[name];
+            const PanelComponent = action.PanelComponent;
+            PanelComponent.displayName = "PanelComponent";
+            const elements = this.getElementsIncludingDeleted();
+            const appState = this.getAppState();
+            const updateData = (formState) => {
+                trackAction(action, "ui", appState, elements, this.app, formState);
+                this.updater(action.perform(this.getElementsIncludingDeleted(), this.getAppState(), formState, this.app));
+            };
+            return (_jsx(PanelComponent, { elements: this.getElementsIncludingDeleted(), appState: this.getAppState(), updateData: updateData, appProps: this.app.props, app: this.app, data: data }));
+        }
+        return null;
+    };
+    isActionEnabled = (action) => {
+        const elements = this.getElementsIncludingDeleted();
+        const appState = this.getAppState();
+        return (!action.predicate ||
+            action.predicate(elements, appState, this.app.props, this.app));
+    };
+}

package/dist/packages/excalidraw/actions/register.js

@@ -0,0 +1,5 @@
+export let actions = [];
+export const register = (action) => {
+    actions = actions.concat(action);
+    return action;
+};

package/dist/packages/excalidraw/actions/shortcuts.js

@@ -0,0 +1,52 @@
+import { isDarwin } from "../constants";
+import { t } from "../i18n";
+import { getShortcutKey } from "../utils";
+const shortcutMap = {
+    toggleTheme: [getShortcutKey("Shift+Alt+D")],
+    saveScene: [getShortcutKey("CtrlOrCmd+S")],
+    loadScene: [getShortcutKey("CtrlOrCmd+O")],
+    clearCanvas: [getShortcutKey("CtrlOrCmd+Delete")],
+    imageExport: [getShortcutKey("CtrlOrCmd+Shift+E")],
+    cut: [getShortcutKey("CtrlOrCmd+X")],
+    copy: [getShortcutKey("CtrlOrCmd+C")],
+    paste: [getShortcutKey("CtrlOrCmd+V")],
+    copyStyles: [getShortcutKey("CtrlOrCmd+Alt+C")],
+    pasteStyles: [getShortcutKey("CtrlOrCmd+Alt+V")],
+    selectAll: [getShortcutKey("CtrlOrCmd+A")],
+    deleteSelectedElements: [getShortcutKey("Delete")],
+    duplicateSelection: [
+        getShortcutKey("CtrlOrCmd+D"),
+        getShortcutKey(`Alt+${t("helpDialog.drag")}`),
+    ],
+    sendBackward: [getShortcutKey("CtrlOrCmd+[")],
+    bringForward: [getShortcutKey("CtrlOrCmd+]")],
+    sendToBack: [
+        isDarwin
+            ? getShortcutKey("CtrlOrCmd+Alt+[")
+            : getShortcutKey("CtrlOrCmd+Shift+["),
+    ],
+    bringToFront: [
+        isDarwin
+            ? getShortcutKey("CtrlOrCmd+Alt+]")
+            : getShortcutKey("CtrlOrCmd+Shift+]"),
+    ],
+    copyAsPng: [getShortcutKey("Shift+Alt+C")],
+    copyAsSvg: [],
+    group: [getShortcutKey("CtrlOrCmd+G")],
+    ungroup: [getShortcutKey("CtrlOrCmd+Shift+G")],
+    gridMode: [getShortcutKey("CtrlOrCmd+'")],
+    zenMode: [getShortcutKey("Alt+Z")],
+    objectsSnapMode: [getShortcutKey("Alt+S")],
+    stats: [getShortcutKey("Alt+/")],
+    addToLibrary: [],
+    flipHorizontal: [getShortcutKey("Shift+H")],
+    flipVertical: [getShortcutKey("Shift+V")],
+    viewMode: [getShortcutKey("Alt+R")],
+    hyperlink: [getShortcutKey("CtrlOrCmd+K")],
+    toggleElementLock: [getShortcutKey("CtrlOrCmd+Shift+L")],
+};
+export const getShortcutFromShortcutName = (name) => {
+    const shortcuts = shortcutMap[name];
+    // if multiple shortcuts available, take the first one
+    return shortcuts && shortcuts.length > 0 ? shortcuts[0] : "";
+};

package/dist/packages/excalidraw/align.js

@@ -0,0 +1,36 @@
+import { newElementWith } from "./element/mutateElement";
+import { getCommonBoundingBox } from "./element/bounds";
+import { getMaximumGroups } from "./groups";
+export const alignElements = (selectedElements, alignment) => {
+    const groups = getMaximumGroups(selectedElements);
+    const selectionBoundingBox = getCommonBoundingBox(selectedElements);
+    return groups.flatMap((group) => {
+        const translation = calculateTranslation(group, selectionBoundingBox, alignment);
+        return group.map((element) => newElementWith(element, {
+            x: element.x + translation.x,
+            y: element.y + translation.y,
+        }));
+    });
+};
+const calculateTranslation = (group, selectionBoundingBox, { axis, position }) => {
+    const groupBoundingBox = getCommonBoundingBox(group);
+    const [min, max] = axis === "x" ? ["minX", "maxX"] : ["minY", "maxY"];
+    const noTranslation = { x: 0, y: 0 };
+    if (position === "start") {
+        return {
+            ...noTranslation,
+            [axis]: selectionBoundingBox[min] - groupBoundingBox[min],
+        };
+    }
+    else if (position === "end") {
+        return {
+            ...noTranslation,
+            [axis]: selectionBoundingBox[max] - groupBoundingBox[max],
+        };
+    } // else if (position === "center") {
+    return {
+        ...noTranslation,
+        [axis]: (selectionBoundingBox[min] + selectionBoundingBox[max]) / 2 -
+            (groupBoundingBox[min] + groupBoundingBox[max]) / 2,
+    };
+};

package/dist/packages/excalidraw/analytics.js

@@ -0,0 +1,30 @@
+// place here categories that you want to track. We want to track just a
+// small subset of categories at a given time.
+const ALLOWED_CATEGORIES_TO_TRACK = ["ai"];
+export const trackEvent = (category, action, label, value) => {
+    try {
+        // prettier-ignore
+        if (typeof window === "undefined"
+            || import.meta.env.VITE_WORKER_ID
+            // comment out to debug locally
+            || import.meta.env.PROD) {
+            return;
+        }
+        if (!ALLOWED_CATEGORIES_TO_TRACK.includes(category)) {
+            return;
+        }
+        if (!import.meta.env.PROD) {
+            console.info("trackEvent", { category, action, label, value });
+        }
+        if (window.sa_event) {
+            window.sa_event(action, {
+                category,
+                label,
+                value,
+            });
+        }
+    }
+    catch (error) {
+        console.error("error during analytics", error);
+    }
+};