fix: More robust mobile and tablet detection

Signed-off-by: Mark Tolmacs <mark@lazycat.hu>

.codesandbox/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24-bullseye
+FROM node:18-bullseye
 
 # Vite wants to open the browser using `open`, so we
 # need to install those utils.

.env.development

@@ -12,7 +12,7 @@ VITE_APP_WS_SERVER_URL=http://localhost:3002
 VITE_APP_PLUS_LP=https://plus.excalidraw.com
 VITE_APP_PLUS_APP=http://localhost:3000
 
-VITE_APP_AI_BACKEND=http://localhost:3016
+VITE_APP_AI_BACKEND=http://localhost:3015
 
 VITE_APP_FIREBASE_CONFIG='{"apiKey":"AIzaSyCMkxA60XIW8KbqMYL7edC4qT5l4qHX2h8","authDomain":"excalidraw-oss-dev.firebaseapp.com","projectId":"excalidraw-oss-dev","storageBucket":"excalidraw-oss-dev.appspot.com","messagingSenderId":"664559512677","appId":"1:664559512677:web:a385181f2928d328a7aa8c"}'
 
@@ -27,7 +27,7 @@ VITE_APP_ENABLE_TRACKING=true
 FAST_REFRESH=false
 
 # The port the run the dev server
-VITE_APP_PORT=3001
+VITE_APP_PORT=3000
 
 #Debug flags
 

.env.test

@@ -1,7 +0,0 @@
-# VITE_DEBUG_DOM
-#   When "true", testing-library failures (waitFor / getBy*) include the full
-#   serialized DOM in the error message. It's off by default because it's noisy.
-#
-#   Flip it to "true" (or use `VITE_DEBUG_DOM=true yarn test`) when you need to
-#   inspect the DOM of a failing test.
-VITE_DEBUG_DOM=false

.eslintrc.json

@@ -39,26 +39,5 @@
         "allowReferrer": true
       }
     ]
-  },
-  "overrides": [
-    {
-      "files": ["packages/excalidraw/**/*.{ts,tsx}"],
-      "excludedFiles": ["packages/excalidraw/**/*.test.{ts,tsx}", "packages/excalidraw/**/*.test.*.{ts,tsx}"],
-      "rules": {
-        "@typescript-eslint/no-restricted-imports": [
-          "error",
-          {
-            "patterns": [
-              {
-                "group": ["@excalidraw/excalidraw"],
-                "message": "Do not import from the barrel 'index.tsx' files. Use direct relative imports to the specific module instead.",
-                "allowTypeImports": true
-              }
-            ],
-            "paths": [".", "..", "../..", "../../..", "../../../..", "../../../../..", "../index", "../../index", "../../../index", "../../../../index"]
-          }
-        ]
-      }
-    }
-  ]
+  }
 }

.github/workflows/autorelease-excalidraw.yml

@@ -9,13 +9,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
         with:
           fetch-depth: 2
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
         with:
-          node-version: 20.x
+          node-version: 18.x
       - name: Set up publish access
         run: |
           npm config set //registry.npmjs.org/:_authToken ${NPM_TOKEN}

.github/workflows/build-docker.yml

@@ -9,5 +9,5 @@ jobs:
   build-docker:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
       - run: docker build -t excalidraw .

.github/workflows/cancel.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     timeout-minutes: 3
     steps:
-      - uses: styfle/cancel-workflow-action@ce177499ccf9fd2aded3b0426c97e5434c2e8a73 # 0.6.0
+      - uses: styfle/cancel-workflow-action@0.6.0
         with:
           workflow_id: 400555, 400556, 905313, 1451724, 1710116, 3185001, 3438604
           access_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/lint.yml

@@ -7,12 +7,12 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
 
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
         with:
-          node-version: 20.x
+          node-version: 18.x
 
       - name: Install and lint
         run: |

.github/workflows/locales-coverage.yml

@@ -10,14 +10,14 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v4
         with:
           token: ${{ secrets.PUSH_TRANSLATIONS_COVERAGE_PAT }}
 
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
         with:
-          node-version: 20.x
+          node-version: 18.x
 
       - name: Create report file
         run: |
@@ -40,7 +40,7 @@ jobs:
           echo ::set-output name=body::$body
 
       - name: Update description with coverage
-        uses: kt3k/update-pr-description@1b35a6dcd84d81aa0bc1889610efdcde7f37b0c0 # v1.0.1
+        uses: kt3k/update-pr-description@v1.0.1
         with:
           pr_body: ${{ steps.getCommentBody.outputs.body }}
           pr_title: "chore: Update translations from Crowdin"

.github/workflows/publish-docker.yml

@@ -11,18 +11,18 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+        uses: actions/checkout@v3
       - name: Login to DockerHub
-        uses: docker/login-action@465a07811f14bebb1938fbed4728c6a1ff8901fc # v2
+        uses: docker/login-action@v2
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
+        uses: docker/setup-qemu-action@v3
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
+        uses: docker/setup-buildx-action@v3
       - name: Build and push
-        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
+        uses: docker/build-push-action@v5
         with:
           context: .
           push: true

.github/workflows/semantic-pr-title.yml

@@ -6,97 +6,11 @@ on:
       - opened
       - edited
       - synchronize
-      - labeled
-      - unlabeled
 
 jobs:
   semantic:
     runs-on: ubuntu-latest
-    permissions:
-      pull-requests: read
     steps:
-      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
-        with:
-          requireScope: true
-          scopes: |
-            app
-            editor
-            packages/excalidraw
-            packages/utils
-            docker
-            repo
-          ignoreLabels: |
-            skip-semantic-title
+      - uses: amannn/action-semantic-pull-request@v5
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-  label-scope:
-    needs: semantic
-    if: github.event.pull_request.head.repo.full_name == github.repository
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-    steps:
-      - name: Label scoped PR
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          PR_NUMBER: ${{ github.event.pull_request.number }}
-          PR_TITLE: ${{ github.event.pull_request.title }}
-          REPOSITORY: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-
-          scope_labels=(s-app s-editor s-package)
-
-          readarray -t desired_labels < <(
-            node <<'NODE'
-          const title = process.env.PR_TITLE;
-          const match = title.match(/^[a-z]+(?:\(([^)]+)\))?!?:/i);
-          const scopes = match?.[1]?.split(",").map((scope) => scope.trim()) ?? [];
-          const labels = new Set();
-
-          for (const scope of scopes) {
-            if (scope === "app") {
-              labels.add("s-app");
-            } else if (scope === "editor") {
-              labels.add("s-editor");
-            } else if (scope.startsWith("packages/")) {
-              labels.add("s-package");
-            }
-          }
-
-          process.stdout.write([...labels].join("\n"));
-          NODE
-          )
-
-          should_apply_label() {
-            local label="$1"
-
-            for desired_label in "${desired_labels[@]}"; do
-              if [[ "$desired_label" == "$label" ]]; then
-                return 0
-              fi
-            done
-
-            return 1
-          }
-
-          for label in "${scope_labels[@]}"; do
-            if ! should_apply_label "$label"; then
-              gh api \
-                --method DELETE \
-                "repos/${REPOSITORY}/issues/${PR_NUMBER}/labels/${label}" \
-                --silent 2>/dev/null || true
-            fi
-          done
-
-          for label in "${desired_labels[@]}"; do
-            if ! gh api \
-              --method POST \
-              "repos/${REPOSITORY}/issues/${PR_NUMBER}/labels" \
-              --field "labels[]=${label}" \
-              --silent; then
-              echo "::warning::Could not apply ${label}. The workflow token likely does not have issues:write permission for this PR."
-            fi
-          done

.github/workflows/sentry-production.yml

@@ -9,11 +9,11 @@ jobs:
   sentry:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - uses: actions/checkout@v2
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v2
         with:
-          node-version: 20.x
+          node-version: 18.x
       - name: Install and build
         run: |
           yarn --frozen-lockfile
@@ -28,7 +28,7 @@ jobs:
           export SENTRY_RELEASE=$(sentry-cli releases propose-version)
           sentry-cli releases new $SENTRY_RELEASE --project $SENTRY_PROJECT
           sentry-cli releases set-commits --auto $SENTRY_RELEASE
-          sentry-cli sourcemaps upload --release $SENTRY_RELEASE --no-rewrite ./build/static/js/ --url-prefix "~/static/js"
+          sentry-cli releases files $SENTRY_RELEASE upload-sourcemaps --no-rewrite ./build/static/js/ --url-prefix "~/static/js"
           sentry-cli releases finalize $SENTRY_RELEASE
           sentry-cli releases deploys $SENTRY_RELEASE new -e production
         env:

.github/workflows/size-limit.yml

@@ -10,17 +10,17 @@ jobs:
       CI_JOB_NUMBER: 1
     steps:
       - name: Checkout repository
-        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/checkout@v3
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v3
         with:
-          node-version: 20.x
+          node-version: 18.x
       - name: Install in packages/excalidraw
         run: yarn
         working-directory: packages/excalidraw
         env:
           CI: true
-      - uses: andresz1/size-limit-action@e7493a72a44b113341c0cf6186ab49c17c4b65c1 # v1
+      - uses: andresz1/size-limit-action@v1
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           build_script: build:esm

.github/workflows/test-coverage-pr.yml

@@ -10,17 +10,17 @@ jobs:
       pull-requests: write
 
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
+      - uses: actions/checkout@v2
       - name: "Install Node"
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+        uses: actions/setup-node@v2
         with:
-          node-version: "20.x"
+          node-version: "18.x"
       - name: "Install Deps"
         run: yarn install
       - name: "Test Coverage"
         run: yarn test:coverage
       - name: "Report Coverage"
         if: always() # Also generate the report if tests are failing
-        uses: davelosert/vitest-coverage-report-action@2500dafcee7dd64f85ab689c0b83798a8359770e # v2
+        uses: davelosert/vitest-coverage-report-action@v2
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -8,11 +8,11 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4
-      - name: Setup Node.js
-        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
+      - uses: actions/checkout@v4
+      - name: Setup Node.js 18.x
+        uses: actions/setup-node@v4
         with:
-          node-version: 20.x
+          node-version: 18.x
       - name: Install and test
         run: |
           yarn install

Dockerfile

@@ -1,4 +1,4 @@
-FROM --platform=${BUILDPLATFORM} node:24@sha256:8530f76a96d88820d288761f022e318970dda93d01536919fbc16076b7983e63 AS build
+FROM --platform=${BUILDPLATFORM} node:18 AS build
 
 WORKDIR /opt/node_app
 
@@ -7,13 +7,13 @@ COPY . .
 # do not ignore optional dependencies:
 # Error: Cannot find module @rollup/rollup-linux-x64-gnu
 RUN --mount=type=cache,target=/root/.cache/yarn \
-    npm_config_target_arch=${TARGETARCH} yarn --frozen-lockfile --network-timeout 600000
+    npm_config_target_arch=${TARGETARCH} yarn --network-timeout 600000
 
 ARG NODE_ENV=production
 
 RUN npm_config_target_arch=${TARGETARCH} yarn build:app:docker
 
-FROM nginx:stable-alpine-slim@sha256:2c605dbeab79a6b2a63340474fe58119d0ef95bdc4b1f41df0aa689659b3d13b
+FROM --platform=${TARGETPLATFORM} nginx:1.27-alpine
 
 COPY --from=build /opt/node_app/excalidraw-app/build /usr/share/nginx/html
 

README.md

@@ -29,7 +29,7 @@
   <a href="https://docs.excalidraw.com/docs/introduction/contributing">
     <img alt="PRs welcome!" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat"  /></a>
   <a href="https://discord.gg/UexuTaE">
-    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widget=false"/></a>
+    <img alt="Chat on Discord" src="https://img.shields.io/discord/723672430744174682?color=738ad6&label=Chat%20on%20Discord&logo=discord&logoColor=ffffff&widge=false"/></a>
   <a href="https://deepwiki.com/excalidraw/excalidraw">
     <img alt="Ask DeepWiki" src="https://deepwiki.com/badge.svg" /></a>
   <a href="https://twitter.com/excalidraw">

dev-docs/docs/@excalidraw/excalidraw/api/excalidraw-element-skeleton.mdx

@@ -172,7 +172,7 @@ convertToExcalidrawElements([
     type: "arrow",
     x: 450,
     y: 20,
-    startArrowhead: "circle",
+    startArrowhead: "dot",
     endArrowhead: "triangle",
     strokeColor: "#1971c2",
     strokeWidth: 2,

dev-docs/docusaurus.config.js

@@ -97,8 +97,8 @@ const config = {
                 href: "https://discord.gg/UexuTaE",
               },
               {
-                label: "𝕏",
-                href: "https://x.com/excalidraw",
+                label: "Twitter",
+                href: "https://twitter.com/excalidraw",
               },
               {
                 label: "Linkedin",

examples/with-script-in-browser/initialData.tsx

@@ -1,4 +1,4 @@
-import type { ExcalidrawElementSkeleton } from "@excalidraw/excalidraw/element/transform";
+import type { ExcalidrawElementSkeleton } from "@excalidraw/excalidraw/data/transform";
 import type { FileId } from "@excalidraw/excalidraw/element/types";
 
 const elements: ExcalidrawElementSkeleton[] = [

examples/with-script-in-browser/package.json

@@ -3,14 +3,14 @@
   "version": "1.0.0",
   "private": true,
   "dependencies": {
-    "@excalidraw/excalidraw": "*",
-    "browser-fs-access": "0.38.0",
     "react": "19.0.0",
-    "react-dom": "19.0.0"
+    "react-dom": "19.0.0",
+    "@excalidraw/excalidraw": "*",
+    "browser-fs-access": "0.29.1"
   },
   "devDependencies": {
-    "typescript": "^5",
-    "vite": "5.0.12"
+    "vite": "5.0.12",
+    "typescript": "^5"
   },
   "scripts": {
     "start": "vite",

examples/with-script-in-browser/utils.ts

@@ -4,6 +4,8 @@ import { unstable_batchedUpdates } from "react-dom";
 
 type FILE_EXTENSION = Exclude<keyof typeof MIME_TYPES, "binary">;
 
+const INPUT_CHANGE_INTERVAL_MS = 500;
+
 export type ResolvablePromise<T> = Promise<T> & {
   resolve: [T] extends [undefined] ? (value?: T) => void : (value: T) => void;
   reject: (error: Error) => void;
@@ -52,6 +54,40 @@ export const fileOpen = <M extends boolean | undefined = false>(opts: {
     extensions,
     mimeTypes,
     multiple: opts.multiple ?? false,
+    legacySetup: (resolve, reject, input) => {
+      const scheduleRejection = debounce(reject, INPUT_CHANGE_INTERVAL_MS);
+      const focusHandler = () => {
+        checkForFile();
+        document.addEventListener("keyup", scheduleRejection);
+        document.addEventListener("pointerup", scheduleRejection);
+        scheduleRejection();
+      };
+      const checkForFile = () => {
+        // this hack might not work when expecting multiple files
+        if (input.files?.length) {
+          const ret = opts.multiple ? [...input.files] : input.files[0];
+          resolve(ret as RetType);
+        }
+      };
+      requestAnimationFrame(() => {
+        window.addEventListener("focus", focusHandler);
+      });
+      const interval = window.setInterval(() => {
+        checkForFile();
+      }, INPUT_CHANGE_INTERVAL_MS);
+      return (rejectPromise) => {
+        clearInterval(interval);
+        scheduleRejection.cancel();
+        window.removeEventListener("focus", focusHandler);
+        document.removeEventListener("keyup", scheduleRejection);
+        document.removeEventListener("pointerup", scheduleRejection);
+        if (rejectPromise) {
+          // so that something is shown in console if we need to debug this
+          console.warn("Opening the file was canceled (legacy-fs).");
+          rejectPromise(new Error("Request Aborted"));
+        }
+      };
+    },
   }) as Promise<RetType>;
 };
 

excalidraw-app/App.tsx

@@ -5,8 +5,6 @@ import {
   CaptureUpdateAction,
   reconcileElements,
   useEditorInterface,
-  ExcalidrawAPIProvider,
-  useExcalidrawAPI,
 } from "@excalidraw/excalidraw";
 import { trackEvent } from "@excalidraw/excalidraw/analytics";
 import { getDefaultAppState } from "@excalidraw/excalidraw/appState";
@@ -22,6 +20,7 @@ import Trans from "@excalidraw/excalidraw/components/Trans";
 import {
   APP_NAME,
   EVENT,
+  THEME,
   VERSION_TIMEOUT,
   debounce,
   getVersion,
@@ -35,6 +34,7 @@ import {
 import polyfill from "@excalidraw/excalidraw/polyfill";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { loadFromBlob } from "@excalidraw/excalidraw/data/blob";
+import { useCallbackRefState } from "@excalidraw/excalidraw/hooks/useCallbackRefState";
 import { t } from "@excalidraw/excalidraw/i18n";
 
 import {
@@ -48,11 +48,7 @@ import {
   youtubeIcon,
 } from "@excalidraw/excalidraw/components/icons";
 import { isElementLink } from "@excalidraw/element";
-import {
-  bumpElementVersions,
-  restoreAppState,
-  restoreElements,
-} from "@excalidraw/excalidraw/data/restore";
+import { restore, restoreAppState } from "@excalidraw/excalidraw/data/restore";
 import { newElementWith } from "@excalidraw/element";
 import { isInitializedImageElement } from "@excalidraw/element";
 import clsx from "clsx";
@@ -74,7 +70,6 @@ import type {
   BinaryFiles,
   ExcalidrawInitialDataState,
   UIAppState,
-  ExcalidrawProps,
 } from "@excalidraw/excalidraw/types";
 import type { ResolutionType } from "@excalidraw/common/utility-types";
 import type { ResolvablePromise } from "@excalidraw/common/utils";
@@ -110,12 +105,11 @@ import { TopErrorBoundary } from "./components/TopErrorBoundary";
 import {
   exportToBackend,
   getCollaborationLinkData,
-  importFromBackend,
   isCollaborationLink,
+  loadScene,
 } from "./data";
 
 import { updateStaleImageStatuses } from "./data/FileManager";
-import { FileStatusStore } from "./data/fileStatusStore";
 import {
   importFromLocalStorage,
   importUsernameFromLocalStorage,
@@ -230,20 +224,9 @@ const initializeScene = async (opts: {
 
   const localDataState = importFromLocalStorage();
 
-  let scene: Omit<
-    RestoredDataState,
-    // we're not storing files in the scene database/localStorage, and instead
-    // fetch them async from a different store
-    "files"
-  > & {
+  let scene: RestoredDataState & {
     scrollToContent?: boolean;
-  } = {
-    elements: restoreElements(localDataState?.elements, null, {
-      repairBindings: true,
-      deleteInvisibleElements: true,
-    }),
-    appState: restoreAppState(localDataState?.appState, null),
-  };
+  } = await loadScene(null, null, localDataState);
 
   let roomLinkData = getCollaborationLinkData(window.location.href);
   const isExternalScene = !!(id || jsonBackendMatch || roomLinkData);
@@ -257,26 +240,11 @@ const initializeScene = async (opts: {
       (await openConfirmModal(shareableLinkConfirmDialog))
     ) {
       if (jsonBackendMatch) {
-        const imported = await importFromBackend(
+        scene = await loadScene(
           jsonBackendMatch[1],
           jsonBackendMatch[2],
+          localDataState,
         );
-
-        scene = {
-          elements: bumpElementVersions(
-            restoreElements(imported.elements, null, {
-              repairBindings: true,
-              deleteInvisibleElements: true,
-            }),
-            localDataState?.elements,
-          ),
-          appState: restoreAppState(
-            imported.appState,
-            // local appState when importing from backend to ensure we restore
-            // localStorage user settings which we do not persist on server.
-            localDataState?.appState,
-          ),
-        };
       }
       scene.scrollToContent = true;
       if (!roomLinkData) {
@@ -371,8 +339,6 @@ const initializeScene = async (opts: {
 };
 
 const ExcalidrawWrapper = () => {
-  const excalidrawAPI = useExcalidrawAPI();
-
   const [errorMessage, setErrorMessage] = useState("");
   const isCollabDisabled = isRunningInIframe();
 
@@ -403,6 +369,9 @@ const ExcalidrawWrapper = () => {
     }, VERSION_TIMEOUT);
   }, []);
 
+  const [excalidrawAPI, excalidrawRefCallback] =
+    useCallbackRefState<ExcalidrawImperativeAPI>();
+
   const [, setShareDialogState] = useAtom(shareDialogStateAtom);
   const [collabAPI] = useAtom(collabAPIAtom);
   const [isCollaborating] = useAtomWithInitialValue(isCollaboratingAtom, () => {
@@ -434,15 +403,18 @@ const ExcalidrawWrapper = () => {
     }
   }, [excalidrawAPI]);
 
-  // ---------------------------------------------------------------------------
-  // Hoisted loadImages
-  // ---------------------------------------------------------------------------
-  const loadImages = useCallback(
-    (data: ResolutionType<typeof initializeScene>, isInitialLoad = false) => {
-      if (!data.scene || !excalidrawAPI) {
+  useEffect(() => {
+    if (!excalidrawAPI || (!isCollabDisabled && !collabAPI)) {
+      return;
+    }
+
+    const loadImages = (
+      data: ResolutionType<typeof initializeScene>,
+      isInitialLoad = false,
+    ) => {
+      if (!data.scene) {
         return;
       }
-
       if (collabAPI?.isCollaborating()) {
         if (data.scene.elements) {
           collabAPI
@@ -469,12 +441,6 @@ const ExcalidrawWrapper = () => {
           }, [] as FileId[]) || [];
 
         if (data.isExternalScene) {
-          if (fileIds.length) {
-            // Direct Firebase call (not through FileManager), so track manually
-            FileStatusStore.updateStatuses(
-              fileIds.map((id) => [id, "loading"]),
-            );
-          }
           loadFilesFromFirebase(
             `${FIREBASE_STORAGE_PREFIXES.shareLinkFiles}/${data.id}`,
             data.key,
@@ -486,18 +452,12 @@ const ExcalidrawWrapper = () => {
               erroredFiles,
               elements: excalidrawAPI.getSceneElementsIncludingDeleted(),
             });
-            FileStatusStore.updateStatuses([
-              ...loadedFiles.map((f) => [f.id, "loaded"] as [FileId, "loaded"]),
-              ...[...erroredFiles.keys()].map(
-                (id) => [id, "error"] as [FileId, "error"],
-              ),
-            ]);
           });
         } else if (isInitialLoad) {
           if (fileIds.length) {
             LocalData.fileStorage
               .getFiles(fileIds)
-              .then(async ({ loadedFiles, erroredFiles }) => {
+              .then(({ loadedFiles, erroredFiles }) => {
                 if (loadedFiles.length) {
                   excalidrawAPI.addFiles(loadedFiles);
                 }
@@ -510,19 +470,10 @@ const ExcalidrawWrapper = () => {
           }
           // on fresh load, clear unused files from IDB (from previous
           // session)
-          LocalData.fileStorage.clearObsoleteFiles({
-            currentFileIds: fileIds,
-          });
+          LocalData.fileStorage.clearObsoleteFiles({ currentFileIds: fileIds });
         }
       }
-    },
-    [collabAPI, excalidrawAPI],
-  );
-
-  useEffect(() => {
-    if (!excalidrawAPI || (!isCollabDisabled && !collabAPI)) {
-      return;
-    }
+    };
 
     initializeScene({ collabAPI, excalidrawAPI }).then(async (data) => {
       loadImages(data, /* isInitialLoad */ true);
@@ -545,10 +496,8 @@ const ExcalidrawWrapper = () => {
           loadImages(data);
           if (data.scene) {
             excalidrawAPI.updateScene({
-              elements: restoreElements(data.scene.elements, null, {
-                repairBindings: true,
-              }),
-              appState: restoreAppState(data.scene.appState, null),
+              ...data.scene,
+              ...restore(data.scene, null, null, { repairBindings: true }),
               captureUpdate: CaptureUpdateAction.IMMEDIATELY,
             });
           }
@@ -647,7 +596,7 @@ const ExcalidrawWrapper = () => {
         false,
       );
     };
-  }, [isCollabDisabled, collabAPI, excalidrawAPI, setLangCode, loadImages]);
+  }, [isCollabDisabled, collabAPI, excalidrawAPI, setLangCode]);
 
   useEffect(() => {
     const unloadHandler = (event: BeforeUnloadEvent) => {
@@ -792,56 +741,6 @@ const ExcalidrawWrapper = () => {
     [setShareDialogState],
   );
 
-  // ---------------------------------------------------------------------------
-  // onExport — intercepts file save to wait for pending image loads
-  // ---------------------------------------------------------------------------
-  const onExport: Required<ExcalidrawProps>["onExport"] = useCallback(
-    async function* () {
-      let snapshot = FileStatusStore.getSnapshot();
-      const { pending, total } = FileStatusStore.getPendingCount(
-        snapshot.value,
-      );
-      if (pending === 0) {
-        return;
-      }
-
-      // Yield initial progress
-      yield {
-        type: "progress",
-        progress: (total - pending) / total,
-        message: `Loading images (${total - pending}/${total})...`,
-      };
-
-      // Wait for all pending images to finish
-      while (true) {
-        snapshot = await FileStatusStore.pull(snapshot.version);
-        const { pending: nowPending, total: nowTotal } =
-          FileStatusStore.getPendingCount(snapshot.value);
-
-        yield {
-          type: "progress",
-          progress: (nowTotal - nowPending) / nowTotal,
-          message: `Loading images (${nowTotal - nowPending}/${nowTotal})...`,
-        };
-
-        if (nowPending === 0) {
-          await new Promise((r) => setTimeout(r, 500));
-          yield {
-            type: "progress",
-            message: `Preparing export...`,
-          };
-          return;
-        }
-      }
-    },
-    [],
-  );
-
-  // const onExport = () => {
-  //   return new Promise((r) => setTimeout(r, 2500));
-  //   // console.log("onExport");
-  // };
-
   // browsers generally prevent infinite self-embedding, there are
   // cases where it still happens, and while we disallow self-embedding
   // by not whitelisting our own origin, this serves as an additional guard
@@ -908,8 +807,8 @@ const ExcalidrawWrapper = () => {
       })}
     >
       <Excalidraw
+        excalidrawAPI={excalidrawRefCallback}
         onChange={onChange}
-        onExport={onExport}
         initialData={initialStatePromiseRef.current.promise}
         isCollaborating={isCollaborating}
         onPointerUpdate={collabAPI?.onPointerUpdate}
@@ -951,7 +850,6 @@ const ExcalidrawWrapper = () => {
         handleKeyboardGlobally={true}
         autoFocus={true}
         theme={editorTheme}
-        onThemeChange={setAppTheme}
         renderTopRightUI={(isMobile) => {
           if (isMobile || !collabAPI || isCollabDisabled) {
             return null;
@@ -988,6 +886,7 @@ const ExcalidrawWrapper = () => {
           isCollaborating={isCollaborating}
           isCollabEnabled={!isCollabDisabled}
           theme={appTheme}
+          setTheme={(theme) => setAppTheme(theme)}
           refresh={() => forceRefresh((prev) => !prev)}
         />
         <AppWelcomeScreen
@@ -1228,6 +1127,14 @@ const ExcalidrawWrapper = () => {
                 }
               },
             },
+            {
+              ...CommandPalette.defaultItems.toggleTheme,
+              perform: () => {
+                setAppTheme(
+                  editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK,
+                );
+              },
+            },
             {
               label: t("labels.installPWA"),
               category: DEFAULT_CATEGORIES.app,
@@ -1267,9 +1174,7 @@ const ExcalidrawApp = () => {
   return (
     <TopErrorBoundary>
       <Provider store={appJotaiStore}>
-        <ExcalidrawAPIProvider>
-          <ExcalidrawWrapper />
-        </ExcalidrawAPIProvider>
+        <ExcalidrawWrapper />
       </Provider>
     </TopErrorBoundary>
   );

excalidraw-app/app_constants.ts

@@ -46,7 +46,6 @@ export const STORAGE_KEYS = {
   VERSION_FILES: "version-files",
 
   IDB_LIBRARY: "excalidraw-library",
-  IDB_TTD_CHATS: "excalidraw-ttd-chats",
 
   // do not use apart from migrations
   __LEGACY_LOCAL_STORAGE_LIBRARY: "excalidraw-library",

excalidraw-app/collab/Collab.tsx

@@ -6,7 +6,7 @@ import {
   reconcileElements,
 } from "@excalidraw/excalidraw";
 import { ErrorDialog } from "@excalidraw/excalidraw/components/ErrorDialog";
-import { APP_NAME, cloneJSON, EVENT, toBrandedType } from "@excalidraw/common";
+import { APP_NAME, EVENT } from "@excalidraw/common";
 import {
   IDLE_THRESHOLD,
   ACTIVE_THRESHOLD,
@@ -29,8 +29,6 @@ import { withBatchedUpdates } from "@excalidraw/excalidraw/reactUtils";
 import throttle from "lodash.throttle";
 import { PureComponent } from "react";
 
-import { bumpElementVersions } from "@excalidraw/excalidraw/data/restore";
-
 import type {
   ReconciledExcalidrawElement,
   RemoteExcalidrawElement,
@@ -72,7 +70,6 @@ import {
   FileManager,
   updateStaleImageStatuses,
 } from "../data/FileManager";
-import { FileStatusStore } from "../data/fileStatusStore";
 import { LocalData } from "../data/LocalData";
 import {
   isSavedToFirebase,
@@ -150,7 +147,6 @@ class Collab extends PureComponent<CollabProps, CollabState> {
     };
     this.portal = new Portal(this);
     this.fileManager = new FileManager({
-      onFileStatusChange: FileStatusStore.updateStatuses.bind(FileStatusStore),
       getFiles: async (fileIds) => {
         const { roomId, roomKey } = this.portal;
         if (!roomId || !roomKey) {
@@ -315,7 +311,6 @@ class Collab extends PureComponent<CollabProps, CollabState> {
   saveCollabRoomToFirebase = async (
     syncableElements: readonly SyncableExcalidrawElement[],
   ) => {
-    syncableElements = cloneJSON(syncableElements);
     try {
       const storedElements = await saveToFirebase(
         this.portal,
@@ -584,9 +579,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
           case WS_SUBTYPES.INIT: {
             if (!this.portal.socketInitialized) {
               this.initializeRoom({ fetchScene: false });
-              const remoteElements = toBrandedType<
-                readonly RemoteExcalidrawElement[]
-              >(decryptedData.payload.elements);
+              const remoteElements = decryptedData.payload.elements;
               const reconciledElements =
                 this._reconcileElements(remoteElements);
               this.handleRemoteSceneUpdate(reconciledElements);
@@ -600,11 +593,7 @@ class Collab extends PureComponent<CollabProps, CollabState> {
           }
           case WS_SUBTYPES.UPDATE:
             this.handleRemoteSceneUpdate(
-              this._reconcileElements(
-                toBrandedType<readonly RemoteExcalidrawElement[]>(
-                  decryptedData.payload.elements,
-                ),
-              ),
+              this._reconcileElements(decryptedData.payload.elements),
             );
             break;
           case WS_SUBTYPES.MOUSE_LOCATION: {
@@ -753,28 +742,17 @@ class Collab extends PureComponent<CollabProps, CollabState> {
   };
 
   private _reconcileElements = (
-    remoteElements: readonly RemoteExcalidrawElement[],
+    remoteElements: readonly ExcalidrawElement[],
   ): ReconciledExcalidrawElement[] => {
+    const localElements = this.getSceneElementsIncludingDeleted();
     const appState = this.excalidrawAPI.getAppState();
-
-    const existingElements = this.getSceneElementsIncludingDeleted();
-
-    // NOTE ideally we restore _after_ reconciliation but we can't do that
-    // as we'd regenerate even elements such as appState.newElement which would
-    // break the state
-    remoteElements = restoreElements(remoteElements, existingElements);
-
-    let reconciledElements = reconcileElements(
-      existingElements,
-      remoteElements,
+    const restoredRemoteElements = restoreElements(remoteElements, null);
+    const reconciledElements = reconcileElements(
+      localElements,
+      restoredRemoteElements as RemoteExcalidrawElement[],
       appState,
     );
 
-    reconciledElements = bumpElementVersions(
-      reconciledElements,
-      existingElements,
-    );
-
     // Avoid broadcasting to the rest of the collaborators the scene
     // we just received!
     // Note: this needs to be set before updating the scene as it

excalidraw-app/components/AI.tsx

@@ -4,15 +4,12 @@ import {
   getTextFromElements,
   MIME_TYPES,
   TTDDialog,
-  TTDStreamFetch,
 } from "@excalidraw/excalidraw";
 import { getDataURL } from "@excalidraw/excalidraw/data/blob";
 import { safelyParseJSON } from "@excalidraw/common";
 
 import type { ExcalidrawImperativeAPI } from "@excalidraw/excalidraw/types";
 
-import { TTDIndexedDBAdapter } from "../data/TTDStorage";
-
 export const AIComponents = ({
   excalidrawAPI,
 }: {
@@ -102,23 +99,61 @@ export const AIComponents = ({
       />
 
       <TTDDialog
-        onTextSubmit={async (props) => {
-          const { onChunk, onStreamCreated, signal, messages } = props;
+        onTextSubmit={async (input) => {
+          try {
+            const response = await fetch(
+              `${
+                import.meta.env.VITE_APP_AI_BACKEND
+              }/v1/ai/text-to-diagram/generate`,
+              {
+                method: "POST",
+                headers: {
+                  Accept: "application/json",
+                  "Content-Type": "application/json",
+                },
+                body: JSON.stringify({ prompt: input }),
+              },
+            );
 
-          const result = await TTDStreamFetch({
-            url: `${
-              import.meta.env.VITE_APP_AI_BACKEND
-            }/v1/ai/text-to-diagram/chat-streaming`,
-            messages,
-            onChunk,
-            onStreamCreated,
-            extractRateLimits: true,
-            signal,
-          });
+            const rateLimit = response.headers.has("X-Ratelimit-Limit")
+              ? parseInt(response.headers.get("X-Ratelimit-Limit") || "0", 10)
+              : undefined;
 
-          return result;
+            const rateLimitRemaining = response.headers.has(
+              "X-Ratelimit-Remaining",
+            )
+              ? parseInt(
+                  response.headers.get("X-Ratelimit-Remaining") || "0",
+                  10,
+                )
+              : undefined;
+
+            const json = await response.json();
+
+            if (!response.ok) {
+              if (response.status === 429) {
+                return {
+                  rateLimit,
+                  rateLimitRemaining,
+                  error: new Error(
+                    "Too many requests today, please try again tomorrow!",
+                  ),
+                };
+              }
+
+              throw new Error(json.message || "Generation failed...");
+            }
+
+            const generatedResponse = json.generatedResponse;
+            if (!generatedResponse) {
+              throw new Error("Generation failed...");
+            }
+
+            return { generatedResponse, rateLimit, rateLimitRemaining };
+          } catch (err: any) {
+            throw new Error("Request failed");
+          }
         }}
-        persistenceAdapter={TTDIndexedDBAdapter}
       />
     </>
   );

excalidraw-app/components/AppMainMenu.tsx

@@ -20,6 +20,7 @@ export const AppMainMenu: React.FC<{
   isCollaborating: boolean;
   isCollabEnabled: boolean;
   theme: Theme | "system";
+  setTheme: (theme: Theme | "system") => void;
   refresh: () => void;
 }> = React.memo((props) => {
   return (
@@ -61,7 +62,7 @@ export const AppMainMenu: React.FC<{
       {isDevEnv() && (
         <MainMenu.Item
           icon={eyeIcon}
-          onSelect={() => {
+          onClick={() => {
             if (window.visualDebug) {
               delete window.visualDebug;
               saveDebugState({ enabled: false });
@@ -76,8 +77,11 @@ export const AppMainMenu: React.FC<{
         </MainMenu.Item>
       )}
       <MainMenu.Separator />
-      <MainMenu.DefaultItems.Preferences />
-      <MainMenu.DefaultItems.ToggleTheme allowSystemTheme theme={props.theme} />
+      <MainMenu.DefaultItems.ToggleTheme
+        allowSystemTheme
+        theme={props.theme}
+        onSelect={props.setTheme}
+      />
       <MainMenu.ItemCustom>
         <LanguageList style={{ width: "100%" }} />
       </MainMenu.ItemCustom>

excalidraw-app/components/AppWelcomeScreen.tsx

@@ -33,15 +33,7 @@ export const AppWelcomeScreen: React.FC<{
         return bit;
       });
   } else {
-    headingContent = (
-      <>
-        {t("welcomeScreen.app.center_heading")}
-        <br />
-        {t("welcomeScreen.app.center_heading_line2")}
-        <br />
-        {t("welcomeScreen.app.center_heading_line3")}
-      </>
-    );
+    headingContent = t("welcomeScreen.app.center_heading");
   }
 
   return (

excalidraw-app/components/DebugCanvas.tsx

@@ -27,10 +27,7 @@ import { isCurve } from "@excalidraw/math/curve";
 import React from "react";
 
 import type { Curve } from "@excalidraw/math";
-import type {
-  DebugElement,
-  DebugPolygon,
-} from "@excalidraw/element/visualdebug";
+import type { DebugElement } from "@excalidraw/common";
 import type {
   ElementsMap,
   ExcalidrawArrowElement,
@@ -78,44 +75,6 @@ const renderCubicBezier = (
   context.restore();
 };
 
-const renderPolygon = (
-  context: CanvasRenderingContext2D,
-  zoom: number,
-  polygon: DebugPolygon,
-  color: string,
-) => {
-  const { points, fill, close } = polygon;
-
-  if (points.length < 2) {
-    return;
-  }
-
-  context.save();
-  context.beginPath();
-  context.moveTo(points[0][0] * zoom, points[0][1] * zoom);
-  for (let i = 1; i < points.length; i += 1) {
-    context.lineTo(points[i][0] * zoom, points[i][1] * zoom);
-  }
-  if (close !== false) {
-    context.closePath();
-  }
-
-  if (fill) {
-    context.save();
-    context.globalAlpha = 0.15;
-    context.fillStyle = color;
-    context.fill();
-    context.restore();
-  }
-
-  context.strokeStyle = color;
-  context.stroke();
-  context.restore();
-};
-
-const isDebugPolygon = (data: DebugElement["data"]): data is DebugPolygon =>
-  (data as DebugPolygon).type === "polygon";
-
 const renderOrigin = (context: CanvasRenderingContext2D, zoom: number) => {
   context.strokeStyle = "#888";
   context.save();
@@ -321,9 +280,6 @@ const render = (
           el.color,
         );
         break;
-      case isDebugPolygon(el.data):
-        renderPolygon(context, appState.zoom.value, el.data, el.color);
-        break;
       default:
         throw new Error(`Unknown element type ${JSON.stringify(el)}`);
     }
@@ -414,6 +370,7 @@ export const debugRenderer = throttleRAF(
   ) => {
     _debugRenderer(canvas, appState, elements, scale);
   },
+  { trailing: true },
 );
 
 export const loadSavedDebugState = () => {

excalidraw-app/components/GitHubCorner.tsx

@@ -0,0 +1,46 @@
+import { THEME } from "@excalidraw/common";
+import oc from "open-color";
+import React from "react";
+
+import type { Theme } from "@excalidraw/element/types";
+
+// https://github.com/tholman/github-corners
+export const GitHubCorner = React.memo(
+  ({ theme, dir }: { theme: Theme; dir: string }) => (
+    <svg
+      xmlns="http://www.w3.org/2000/svg"
+      width="40"
+      height="40"
+      viewBox="0 0 250 250"
+      className="rtl-mirror"
+      style={{
+        marginTop: "calc(var(--space-factor) * -1)",
+        [dir === "rtl" ? "marginLeft" : "marginRight"]:
+          "calc(var(--space-factor) * -1)",
+      }}
+    >
+      <a
+        href="https://github.com/excalidraw/excalidraw"
+        target="_blank"
+        rel="noopener noreferrer"
+        aria-label="GitHub repository"
+      >
+        <path
+          d="M0 0l115 115h15l12 27 108 108V0z"
+          fill={theme === THEME.LIGHT ? oc.gray[6] : oc.gray[7]}
+        />
+        <path
+          className="octo-arm"
+          d="M128 109c-15-9-9-19-9-19 3-7 2-11 2-11-1-7 3-2 3-2 4 5 2 11 2 11-3 10 5 15 9 16"
+          style={{ transformOrigin: "130px 106px" }}
+          fill={theme === THEME.LIGHT ? oc.white : "var(--default-bg-color)"}
+        />
+        <path
+          className="octo-body"
+          d="M115 115s4 2 5 0l14-14c3-2 6-3 8-3-8-11-15-24 2-41 5-5 10-7 16-7 1-2 3-7 12-11 0 0 5 3 7 16 4 2 8 5 12 9s7 8 9 12c14 3 17 7 17 7-4 8-9 11-11 11 0 6-2 11-7 16-16 16-30 10-41 2 0 3-1 7-5 11l-12 11c-1 1 1 5 1 5z"
+          fill={theme === THEME.LIGHT ? oc.white : "var(--default-bg-color)"}
+        />
+      </a>
+    </svg>
+  ),
+);

excalidraw-app/data/FileManager.ts

@@ -40,12 +40,10 @@ export class FileManager {
 
   private _getFiles;
   private _saveFiles;
-  private _onFileStatusChange;
 
   constructor({
     getFiles,
     saveFiles,
-    onFileStatusChange,
   }: {
     getFiles: (fileIds: FileId[]) => Promise<{
       loadedFiles: BinaryFileData[];
@@ -55,13 +53,9 @@ export class FileManager {
       savedFiles: Map<FileId, BinaryFileData>;
       erroredFiles: Map<FileId, BinaryFileData>;
     }>;
-    onFileStatusChange?: (
-      updates: Array<[FileId, "loading" | "loaded" | "error"]>,
-    ) => void;
   }) {
     this._getFiles = getFiles;
     this._saveFiles = saveFiles;
-    this._onFileStatusChange = onFileStatusChange;
   }
 
   /**
@@ -152,8 +146,6 @@ export class FileManager {
       this.fetchingFiles.set(id, true);
     }
 
-    this._onFileStatusChange?.(ids.map((id) => [id, "loading"]));
-
     try {
       const { loadedFiles, erroredFiles } = await this._getFiles(ids);
 
@@ -164,13 +156,6 @@ export class FileManager {
         this.erroredFiles_fetch.set(fileId, true);
       }
 
-      this._onFileStatusChange?.([
-        ...loadedFiles.map((f) => [f.id, "loaded"] as [FileId, "loaded"]),
-        ...[...erroredFiles.keys()].map(
-          (id) => [id, "error"] as [FileId, "error"],
-        ),
-      ]);
-
       return { loadedFiles, erroredFiles };
     } finally {
       for (const id of ids) {
@@ -210,13 +195,6 @@ export class FileManager {
   };
 
   reset() {
-    if (this._onFileStatusChange && this.fetchingFiles.size) {
-      this._onFileStatusChange(
-        [...this.fetchingFiles.keys()].map(
-          (id) => [id, "error"] as [FileId, "error"],
-        ),
-      );
-    }
     this.fetchingFiles.clear();
     this.savingFiles.clear();
     this.savedFiles.clear();

excalidraw-app/data/LocalData.ts

@@ -26,6 +26,7 @@ import {
   get,
 } from "idb-keyval";
 
+import { appJotaiStore, atom } from "excalidraw-app/app-jotai";
 import { getNonDeletedElements } from "@excalidraw/element";
 
 import type { LibraryPersistedData } from "@excalidraw/excalidraw/data/library";
@@ -38,11 +39,9 @@ import type {
 } from "@excalidraw/excalidraw/types";
 import type { MaybePromise } from "@excalidraw/common/utility-types";
 
-import { appJotaiStore, atom } from "../app-jotai";
 import { SAVE_TO_LOCAL_STORAGE_TIMEOUT, STORAGE_KEYS } from "../app_constants";
 
 import { FileManager } from "./FileManager";
-import { FileStatusStore } from "./fileStatusStore";
 import { Locker } from "./Locker";
 import { updateBrowserStateVersion } from "./tabSync";
 
@@ -167,7 +166,6 @@ export class LocalData {
   // ---------------------------------------------------------------------------
 
   static fileStorage = new LocalFileManager({
-    onFileStatusChange: FileStatusStore.updateStatuses.bind(FileStatusStore),
     getFiles(ids) {
       return getMany(ids, filesStore).then(
         async (filesData: (BinaryFileData | undefined)[]) => {

excalidraw-app/data/TTDStorage.ts

@@ -1,51 +0,0 @@
-import { createStore, get, set } from "idb-keyval";
-
-import type { SavedChats } from "@excalidraw/excalidraw/components/TTDDialog/types";
-
-import { STORAGE_KEYS } from "../app_constants";
-
-/**
- * IndexedDB adapter for TTD chat storage.
- * Implements TTDPersistenceAdapter interface.
- */
-export class TTDIndexedDBAdapter {
-  /** IndexedDB database name */
-  private static idb_name = STORAGE_KEYS.IDB_TTD_CHATS;
-  /** Store key for chat data */
-  private static key = "ttdChats";
-
-  private static store = createStore(
-    `${TTDIndexedDBAdapter.idb_name}-db`,
-    `${TTDIndexedDBAdapter.idb_name}-store`,
-  );
-
-  /**
-   * Load saved chats from IndexedDB.
-   * @returns Promise resolving to saved chats array (empty if none found)
-   */
-  static async loadChats(): Promise<SavedChats> {
-    try {
-      const data = await get<SavedChats>(
-        TTDIndexedDBAdapter.key,
-        TTDIndexedDBAdapter.store,
-      );
-      return data || [];
-    } catch (error) {
-      console.warn("Failed to load TTD chats from IndexedDB:", error);
-      return [];
-    }
-  }
-
-  /**
-   * Save chats to IndexedDB.
-   * @param chats - The chats array to persist
-   */
-  static async saveChats(chats: SavedChats): Promise<void> {
-    try {
-      await set(TTDIndexedDBAdapter.key, chats, TTDIndexedDBAdapter.store);
-    } catch (error) {
-      console.warn("Failed to save TTD chats to IndexedDB:", error);
-      throw error;
-    }
-  }
-}

excalidraw-app/data/fileStatusStore.ts

@@ -1,48 +0,0 @@
-import { VersionedSnapshotStore } from "@excalidraw/common";
-
-import type { FileId } from "@excalidraw/element/types";
-
-export type FileLoadingStatus = "loading" | "loaded" | "error";
-
-export class FileStatusStore {
-  private static store = new VersionedSnapshotStore<
-    Map<FileId, FileLoadingStatus>
-  >(new Map());
-
-  static getSnapshot() {
-    return this.store.getSnapshot();
-  }
-
-  static pull(sinceVersion?: number) {
-    return this.store.pull(sinceVersion);
-  }
-
-  static updateStatuses(updates: Array<[FileId, FileLoadingStatus]>) {
-    if (!updates.length) {
-      return;
-    }
-    this.store.update((prev) => {
-      let changed = false;
-      const next = new Map(prev);
-      for (const [id, status] of updates) {
-        if (next.get(id) !== status) {
-          next.set(id, status);
-          changed = true;
-        }
-      }
-      return changed ? next : prev;
-    });
-  }
-
-  static getPendingCount(statuses: Map<FileId, FileLoadingStatus>) {
-    let pending = 0;
-    let total = 0;
-    for (const status of statuses.values()) {
-      total++;
-      if (status === "loading") {
-        pending++;
-      }
-    }
-    return { pending, total };
-  }
-}

excalidraw-app/data/firebase.ts

@@ -1,5 +1,5 @@
 import { reconcileElements } from "@excalidraw/excalidraw";
-import { MIME_TYPES, toBrandedType } from "@excalidraw/common";
+import { MIME_TYPES } from "@excalidraw/common";
 import { decompressData } from "@excalidraw/excalidraw/data/encode";
 import {
   encryptData,
@@ -243,7 +243,7 @@ export const saveToFirebase = async (
 
   FirebaseSceneVersionCache.set(socket, storedElements);
 
-  return toBrandedType<RemoteExcalidrawElement[]>(storedElements);
+  return storedElements;
 };
 
 export const loadFromFirebase = async (

excalidraw-app/data/index.ts

@@ -8,6 +8,7 @@ import {
   IV_LENGTH_BYTES,
 } from "@excalidraw/excalidraw/data/encryption";
 import { serializeAsJSON } from "@excalidraw/excalidraw/data/json";
+import { restore } from "@excalidraw/excalidraw/data/restore";
 import { isInvisiblySmallElement } from "@excalidraw/element";
 import { isInitializedImageElement } from "@excalidraw/element";
 import { t } from "@excalidraw/excalidraw/i18n";
@@ -83,13 +84,13 @@ export type SocketUpdateDataSource = {
   SCENE_INIT: {
     type: WS_SUBTYPES.INIT;
     payload: {
-      elements: readonly OrderedExcalidrawElement[];
+      elements: readonly ExcalidrawElement[];
     };
   };
   SCENE_UPDATE: {
     type: WS_SUBTYPES.UPDATE;
     payload: {
-      elements: readonly OrderedExcalidrawElement[];
+      elements: readonly ExcalidrawElement[];
     };
   };
   MOUSE_LOCATION: {
@@ -199,7 +200,7 @@ const legacy_decodeFromBackend = async ({
   };
 };
 
-export const importFromBackend = async (
+const importFromBackend = async (
   id: string,
   decryptionKey: string,
 ): Promise<ImportedDataState> => {
@@ -241,6 +242,45 @@ export const importFromBackend = async (
   }
 };
 
+export const loadScene = async (
+  id: string | null,
+  privateKey: string | null,
+  // Supply local state even if importing from backend to ensure we restore
+  // localStorage user settings which we do not persist on server.
+  // Non-optional so we don't forget to pass it even if `undefined`.
+  localDataState: ImportedDataState | undefined | null,
+) => {
+  let data;
+  if (id != null && privateKey != null) {
+    // the private key is used to decrypt the content from the server, take
+    // extra care not to leak it
+    data = restore(
+      await importFromBackend(id, privateKey),
+      localDataState?.appState,
+      localDataState?.elements,
+      {
+        repairBindings: true,
+        refreshDimensions: false,
+        deleteInvisibleElements: true,
+      },
+    );
+  } else {
+    data = restore(localDataState || null, null, null, {
+      repairBindings: true,
+      deleteInvisibleElements: true,
+    });
+  }
+
+  return {
+    elements: data.elements,
+    appState: data.appState,
+    // note: this will always be empty because we're not storing files
+    // in the scene database/localStorage, and instead fetch them async
+    // from a different database
+    files: data.files,
+  };
+};
+
 type ExportToBackendResult =
   | { url: null; errorMessage: string }
   | { url: string; errorMessage: null };

excalidraw-app/debug.ts

@@ -1,9 +1,17 @@
+declare global {
+  interface Window {
+    debug: typeof Debug;
+  }
+}
+
 const lessPrecise = (num: number, precision = 5) =>
   parseFloat(num.toPrecision(precision));
 
 const getAvgFrameTime = (times: number[]) =>
   lessPrecise(times.reduce((a, b) => a + b) / times.length);
 
+const getFps = (frametime: number) => lessPrecise(1000 / frametime);
+
 export class Debug {
   public static DEBUG_LOG_TIMES = true;
 
@@ -16,35 +24,34 @@ export class Debug {
   private static LAST_DEBUG_LOG_CALL = 0;
   private static DEBUG_LOG_INTERVAL_ID: null | number = null;
 
-  private static LAST_FRAME_TIMESTAMP = 0;
-  private static FRAME_COUNT = 0;
-  private static ANIMATION_FRAME_ID: null | number = null;
-
-  private static scheduleAnimationFrame = () => {
-    if (Debug.DEBUG_LOG_INTERVAL_ID !== null) {
-      Debug.ANIMATION_FRAME_ID = requestAnimationFrame((timestamp) => {
-        if (Debug.LAST_FRAME_TIMESTAMP !== timestamp) {
-          Debug.LAST_FRAME_TIMESTAMP = timestamp;
-          Debug.FRAME_COUNT++;
-        }
-
-        if (Debug.DEBUG_LOG_INTERVAL_ID !== null) {
-          Debug.scheduleAnimationFrame();
-        }
-      });
-    }
-  };
-
   private static setupInterval = () => {
     if (Debug.DEBUG_LOG_INTERVAL_ID === null) {
       console.info("%c(starting perf recording)", "color: lime");
       Debug.DEBUG_LOG_INTERVAL_ID = window.setInterval(Debug.debugLogger, 1000);
-      Debug.scheduleAnimationFrame();
     }
     Debug.LAST_DEBUG_LOG_CALL = Date.now();
   };
 
   private static debugLogger = () => {
+    if (
+      Date.now() - Debug.LAST_DEBUG_LOG_CALL > 600 &&
+      Debug.DEBUG_LOG_INTERVAL_ID !== null
+    ) {
+      window.clearInterval(Debug.DEBUG_LOG_INTERVAL_ID);
+      Debug.DEBUG_LOG_INTERVAL_ID = null;
+      for (const [name, { avg }] of Object.entries(Debug.TIMES_AVG)) {
+        if (avg != null) {
+          console.info(
+            `%c${name} run avg: ${avg}ms (${getFps(avg)} fps)`,
+            "color: blue",
+          );
+        }
+      }
+      console.info("%c(stopping perf recording)", "color: red");
+      Debug.TIMES_AGGR = {};
+      Debug.TIMES_AVG = {};
+      return;
+    }
     if (Debug.DEBUG_LOG_TIMES) {
       for (const [name, { t, times }] of Object.entries(Debug.TIMES_AGGR)) {
         if (times.length) {
@@ -58,18 +65,8 @@ export class Debug {
       }
       for (const [name, { t, times, avg }] of Object.entries(Debug.TIMES_AVG)) {
         if (times.length) {
-          // const avgFrameTime = getAvgFrameTime(times);
-          const totalTime = times.reduce((a, b) => a + b);
-          const avgFrameTime = lessPrecise(totalTime / Debug.FRAME_COUNT);
-          console.info(
-            name,
-            `- ${times.length} calls - ${avgFrameTime}ms/frame across ${
-              Debug.FRAME_COUNT
-            } frames (${lessPrecise(
-              (avgFrameTime / 16.67) * 100,
-              1,
-            )}% of frame budget)`,
-          );
+          const avgFrameTime = getAvgFrameTime(times);
+          console.info(name, `${avgFrameTime}ms (${getFps(avgFrameTime)} fps)`);
           Debug.TIMES_AVG[name] = {
             t,
             times: [],
@@ -79,24 +76,6 @@ export class Debug {
         }
       }
     }
-    Debug.FRAME_COUNT = 0;
-
-    // Check for stop condition after logging
-    if (
-      Date.now() - Debug.LAST_DEBUG_LOG_CALL > 600 &&
-      Debug.DEBUG_LOG_INTERVAL_ID !== null
-    ) {
-      console.info("%c(stopping perf recording)", "color: red");
-      window.clearInterval(Debug.DEBUG_LOG_INTERVAL_ID);
-      window.cancelAnimationFrame(Debug.ANIMATION_FRAME_ID!);
-      Debug.ANIMATION_FRAME_ID = null;
-      Debug.FRAME_COUNT = 0;
-      Debug.LAST_FRAME_TIMESTAMP = 0;
-
-      Debug.DEBUG_LOG_INTERVAL_ID = null;
-      Debug.TIMES_AGGR = {};
-      Debug.TIMES_AVG = {};
-    }
   };
 
   public static logTime = (time?: number, name = "default") => {
@@ -130,7 +109,7 @@ export class Debug {
       return (...args: T) => {
         const t0 = performance.now();
         const ret = fn(...args);
-        Debug[type](performance.now() - t0, name);
+        Debug.logTime(performance.now() - t0, name);
         return ret;
       };
     };
@@ -151,70 +130,6 @@ export class Debug {
       return ret;
     };
   };
-
-  private static CHANGED_CACHE: Record<string, Record<string, unknown>> = {};
-
-  public static logChanged(name: string, obj: Record<string, unknown>) {
-    const prev = Debug.CHANGED_CACHE[name];
-
-    Debug.CHANGED_CACHE[name] = obj;
-
-    if (!prev) {
-      return;
-    }
-
-    const allKeys = new Set([...Object.keys(prev), ...Object.keys(obj)]);
-    const changed: Record<string, { prev: unknown; next: unknown }> = {};
-
-    for (const key of allKeys) {
-      const prevVal = prev[key];
-      const nextVal = obj[key];
-      if (!deepEqual(prevVal, nextVal)) {
-        changed[key] = { prev: prevVal, next: nextVal };
-      }
-    }
-
-    if (Object.keys(changed).length > 0) {
-      console.info(`[${name}] changed:`, changed);
-    }
-  }
-}
-
-function deepEqual(a: unknown, b: unknown): boolean {
-  if (Object.is(a, b)) {
-    return true;
-  }
-
-  if (
-    a === null ||
-    b === null ||
-    typeof a !== "object" ||
-    typeof b !== "object"
-  ) {
-    return false;
-  }
-
-  if (Array.isArray(a) !== Array.isArray(b)) {
-    return false;
-  }
-
-  const keysA = Object.keys(a as Record<string, unknown>);
-  const keysB = Object.keys(b as Record<string, unknown>);
-
-  if (keysA.length !== keysB.length) {
-    return false;
-  }
-
-  for (const key of keysA) {
-    if (
-      !deepEqual(
-        (a as Record<string, unknown>)[key],
-        (b as Record<string, unknown>)[key],
-      )
-    ) {
-      return false;
-    }
-  }
-
-  return true;
 }
+//@ts-ignore
+window.debug = Debug;

excalidraw-app/package.json

@@ -36,7 +36,6 @@
     "react": "19.0.0",
     "react-dom": "19.0.0",
     "socket.io-client": "4.7.2",
-    "uqr": "0.1.2",
     "vite-plugin-html": "3.2.2"
   },
   "prettier": "@excalidraw/prettier-config",

excalidraw-app/share/QRCode.tsx

@@ -1,56 +0,0 @@
-import { useEffect, useState } from "react";
-import Spinner from "@excalidraw/excalidraw/components/Spinner";
-
-interface QRCodeProps {
-  value: string;
-}
-
-export const QRCode = ({ value }: QRCodeProps) => {
-  const [svgData, setSvgData] = useState<string | null>(null);
-  const [error, setError] = useState<boolean>(false);
-
-  useEffect(() => {
-    let mounted = true;
-
-    import("./qrcode.chunk")
-      .then(({ generateQRCodeSVG }) => {
-        if (mounted) {
-          try {
-            setSvgData(generateQRCodeSVG(value));
-          } catch {
-            setError(true);
-          }
-        }
-      })
-      .catch(() => {
-        if (mounted) {
-          setError(true);
-        }
-      });
-
-    return () => {
-      mounted = false;
-    };
-  }, [value]);
-
-  if (error) {
-    return null;
-  }
-
-  if (!svgData) {
-    return (
-      <div className="ShareDialog__active__qrcode ShareDialog__active__qrcode--loading">
-        <Spinner />
-      </div>
-    );
-  }
-
-  return (
-    <div
-      className="ShareDialog__active__qrcode"
-      role="img"
-      aria-label="QR code for collaboration link"
-      dangerouslySetInnerHTML={{ __html: svgData }}
-    />
-  );
-};

excalidraw-app/share/ShareDialog.scss

@@ -140,31 +140,6 @@
         gap: 0.75rem;
       }
 
-      &__qrcode {
-        display: flex;
-        justify-content: center;
-        align-items: center;
-        align-self: center;
-        padding: 1rem;
-        background: #fff;
-        border-radius: 0.5rem;
-        border: 1px solid #e0e0e0;
-
-        $size: 150px;
-        width: $size;
-        height: $size;
-
-        & svg {
-          width: $size;
-          height: $size;
-        }
-
-        &--loading {
-          background: var(--island-bg-color);
-          border: 1px solid var(--dialog-border-color);
-        }
-      }
-
       &__description {
         border-top: 1px solid var(--color-gray-20);
 

excalidraw-app/share/ShareDialog.tsx

@@ -22,7 +22,6 @@ import { atom, useAtom, useAtomValue } from "../app-jotai";
 import { activeRoomLinkAtom } from "../collab/Collab";
 
 import "./ShareDialog.scss";
-import { QRCode } from "./QRCode";
 
 import type { CollabAPI } from "../collab/Collab";
 
@@ -143,7 +142,6 @@ const ActiveRoomDialog = ({
           }}
         />
       </div>
-      <QRCode value={activeRoomLink} />
       <div className="ShareDialog__active__description">
         <p>
           <span

excalidraw-app/share/qrcode.chunk.ts

@@ -1,5 +0,0 @@
-import { renderSVG } from "uqr";
-
-export const generateQRCodeSVG = (text: string): string => {
-  return renderSVG(text);
-};

excalidraw-app/tests/__snapshots__/MobileMenu.test.tsx.snap

@@ -50,11 +50,7 @@ exports[`Test MobileMenu > should initialize with welcome screen and hide once u
   <div
     class="welcome-screen-center__heading welcome-screen-decor excalifont"
   >
-    Your drawings are saved in your browser's storage.
-    <br />
-    Browser storage can be cleared unexpectedly.
-    <br />
-    Save your work to a file regularly to avoid losing it.
+    All your data is saved locally in your browser.
   </div>
   <div
     class="welcome-screen-menu"

excalidraw-app/useHandleAppTheme.ts

@@ -1,4 +1,5 @@
 import { THEME } from "@excalidraw/excalidraw";
+import { EVENT, CODES, KEYS } from "@excalidraw/common";
 import { useEffect, useLayoutEffect, useState } from "react";
 
 import type { Theme } from "@excalidraw/element/types";
@@ -30,10 +31,28 @@ export const useHandleAppTheme = () => {
       mediaQuery?.addEventListener("change", handleChange);
     }
 
+    const handleKeydown = (event: KeyboardEvent) => {
+      if (
+        !event[KEYS.CTRL_OR_CMD] &&
+        event.altKey &&
+        event.shiftKey &&
+        event.code === CODES.D
+      ) {
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        setAppTheme(editorTheme === THEME.DARK ? THEME.LIGHT : THEME.DARK);
+      }
+    };
+
+    document.addEventListener(EVENT.KEYDOWN, handleKeydown, { capture: true });
+
     return () => {
       mediaQuery?.removeEventListener("change", handleChange);
+      document.removeEventListener(EVENT.KEYDOWN, handleKeydown, {
+        capture: true,
+      });
     };
-  }, [appTheme]);
+  }, [appTheme, editorTheme, setAppTheme]);
 
   useLayoutEffect(() => {
     localStorage.setItem(STORAGE_KEYS.LOCAL_STORAGE_THEME, appTheme);

excalidraw-app/vite.config.mts

@@ -75,20 +75,6 @@ export default defineConfig(({ mode }) => {
           find: /^@excalidraw\/utils\/(.*?)/,
           replacement: path.resolve(__dirname, "../packages/utils/src/$1"),
         },
-        {
-          find: /^@excalidraw\/fractional-indexing$/,
-          replacement: path.resolve(
-            __dirname,
-            "../packages/fractional-indexing/src/index.ts",
-          ),
-        },
-        {
-          find: /^@excalidraw\/laser-pointer$/,
-          replacement: path.resolve(
-            __dirname,
-            "../packages/laser-pointer/src/index.ts",
-          ),
-        },
       ],
     },
     build: {
@@ -116,14 +102,6 @@ export default defineConfig(({ mode }) => {
               // Taking the substring after "locales/"
               return `locales/${id.substring(index + 8)}`;
             }
-
-            if (id.includes("@excalidraw/mermaid-to-excalidraw")) {
-              return "mermaid-to-excalidraw";
-            }
-
-            if (id.includes("@codemirror/") || id.includes("@lezer/")) {
-              return "codemirror.chunk";
-            }
           },
         },
       },
@@ -168,11 +146,6 @@ export default defineConfig(({ mode }) => {
             "**/locales/**",
             "service-worker.js",
             "**/*.chunk-*.js",
-            // CodeMirrorEditor can't be assigned a `.chunk` name via
-            // manualChunks because Rollup would hoist shared deps (React)
-            // via a static import from the main bundle, defeating lazy
-            // loading. So we exclude it by name instead.
-            "**/CodeMirrorEditor-*.js",
           ],
           runtimeCaching: [
             {
@@ -212,7 +185,7 @@ export default defineConfig(({ mode }) => {
               },
             },
             {
-              urlPattern: new RegExp("(.chunk-.+|CodeMirrorEditor-.+)\\.js"),
+              urlPattern: new RegExp(".chunk-.+.js"),
               handler: "CacheFirst",
               options: {
                 cacheName: "chunk",
@@ -223,7 +196,6 @@ export default defineConfig(({ mode }) => {
               },
             },
           ],
-          maximumFileSizeToCacheInBytes: 2.3 * 1024 ** 2, // 2.3MB
         },
         manifest: {
           short_name: "Excalidraw",

package.json

@@ -56,9 +56,7 @@
     "build:element": "yarn --cwd ./packages/element build:esm",
     "build:excalidraw": "yarn --cwd ./packages/excalidraw build:esm",
     "build:math": "yarn --cwd ./packages/math build:esm",
-    "build:fractional-indexing": "yarn --cwd ./packages/fractional-indexing build:esm",
-    "build:laser-pointer": "yarn --cwd ./packages/laser-pointer build:esm",
-    "build:packages": "yarn build:common && yarn build:fractional-indexing && yarn build:laser-pointer && yarn build:math && yarn build:element && yarn build:excalidraw",
+    "build:packages": "yarn build:common && yarn build:math && yarn build:element && yarn build:excalidraw",
     "build:version": "yarn --cwd ./excalidraw-app build:version",
     "build": "yarn --cwd ./excalidraw-app build",
     "build:preview": "yarn --cwd ./excalidraw-app build:preview",

packages/common/package.json

@@ -55,11 +55,5 @@
   "scripts": {
     "gen:types": "rimraf types && tsc",
     "build:esm": "rimraf dist && node ../../scripts/buildBase.js && yarn gen:types"
-  },
-  "dependencies": {
-    "tinycolor2": "1.6.0"
-  },
-  "devDependencies": {
-    "@types/tinycolor2": "1.4.6"
   }
 }

packages/common/src/__snapshots__/colors.test.ts.snap

@@ -1,185 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`COLOR_PALETTE > color palette doesn't regress 1`] = `
-{
-  "black": "#1e1e1e",
-  "blue": [
-    "#e7f5ff",
-    "#a5d8ff",
-    "#4dabf7",
-    "#228be6",
-    "#1971c2",
-  ],
-  "bronze": [
-    "#f8f1ee",
-    "#eaddd7",
-    "#d2bab0",
-    "#a18072",
-    "#846358",
-  ],
-  "cyan": [
-    "#e3fafc",
-    "#99e9f2",
-    "#3bc9db",
-    "#15aabf",
-    "#0c8599",
-  ],
-  "grape": [
-    "#f8f0fc",
-    "#eebefa",
-    "#da77f2",
-    "#be4bdb",
-    "#9c36b5",
-  ],
-  "gray": [
-    "#f8f9fa",
-    "#e9ecef",
-    "#ced4da",
-    "#868e96",
-    "#343a40",
-  ],
-  "green": [
-    "#ebfbee",
-    "#b2f2bb",
-    "#69db7c",
-    "#40c057",
-    "#2f9e44",
-  ],
-  "orange": [
-    "#fff4e6",
-    "#ffd8a8",
-    "#ffa94d",
-    "#fd7e14",
-    "#e8590c",
-  ],
-  "pink": [
-    "#fff0f6",
-    "#fcc2d7",
-    "#f783ac",
-    "#e64980",
-    "#c2255c",
-  ],
-  "red": [
-    "#fff5f5",
-    "#ffc9c9",
-    "#ff8787",
-    "#fa5252",
-    "#e03131",
-  ],
-  "teal": [
-    "#e6fcf5",
-    "#96f2d7",
-    "#38d9a9",
-    "#12b886",
-    "#099268",
-  ],
-  "transparent": "transparent",
-  "violet": [
-    "#f3f0ff",
-    "#d0bfff",
-    "#9775fa",
-    "#7950f2",
-    "#6741d9",
-  ],
-  "white": "#ffffff",
-  "yellow": [
-    "#fff9db",
-    "#ffec99",
-    "#ffd43b",
-    "#fab005",
-    "#f08c00",
-  ],
-}
-`;
-
-exports[`applyDarkModeFilter > COLOR_PALETTE regression tests > matches snapshot for all palette colors 1`] = `
-{
-  "black": "#d3d3d3",
-  "blue": [
-    "#121e26",
-    "#154162",
-    "#2273b4",
-    "#3791e0",
-    "#56a2e8",
-  ],
-  "bronze": [
-    "#221c1a",
-    "#362b26",
-    "#5a463d",
-    "#917569",
-    "#a98d84",
-  ],
-  "cyan": [
-    "#0a1e20",
-    "#004149",
-    "#007281",
-    "#0f8fa1",
-    "#3da5b6",
-  ],
-  "grape": [
-    "#211a25",
-    "#5b3165",
-    "#a954be",
-    "#d471ed",
-    "#e28af8",
-  ],
-  "gray": [
-    "#161718",
-    "#202325",
-    "#33383d",
-    "#6e757c",
-    "#b7bcc1",
-  ],
-  "green": [
-    "#0f1d12",
-    "#043b0c",
-    "#056715",
-    "#16842a",
-    "#39994b",
-  ],
-  "orange": [
-    "#22190d",
-    "#4c2b01",
-    "#924800",
-    "#cd6005",
-    "#f17634",
-  ],
-  "pink": [
-    "#26191e",
-    "#602e40",
-    "#b04d70",
-    "#f56e9d",
-    "#ff8dbc",
-  ],
-  "red": [
-    "#1f1717",
-    "#5a2c2c",
-    "#b44d4d",
-    "#fa6969",
-    "#ff8383",
-  ],
-  "teal": [
-    "#0a1d17",
-    "#00422b",
-    "#00744b",
-    "#039267",
-    "#32a783",
-  ],
-  "transparent": "#ededed00",
-  "violet": [
-    "#1f1c29",
-    "#4a3b72",
-    "#8a6cdf",
-    "#a885ff",
-    "#b595ff",
-  ],
-  "white": "#121212",
-  "yellow": [
-    "#1e1900",
-    "#362600",
-    "#5f3a00",
-    "#905000",
-    "#b86200",
-  ],
-}
-`;

packages/common/src/appEventBus.test.ts

@@ -1,74 +0,0 @@
-import { AppEventBus } from "./appEventBus";
-
-type TestEvents = {
-  initialize: [api: number];
-  pointerUp: [pointerId: string];
-  viewState: [zoom: number];
-};
-
-const behavior = {
-  initialize: { cardinality: "once", replay: "last" },
-  pointerUp: { cardinality: "many", replay: "none" },
-  viewState: { cardinality: "many", replay: "last" },
-} as const;
-
-const flushMicrotasks = async () => Promise.resolve();
-
-describe("AppEventBus", () => {
-  it("replays once events to late callback and Promise subscribers", async () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("initialize", 42);
-
-    const calls: number[] = [];
-    bus.on("initialize", (value) => {
-      calls.push(value);
-    });
-
-    expect(calls).toEqual([]);
-    await flushMicrotasks();
-    expect(calls).toEqual([42]);
-
-    await expect(bus.on("initialize")).resolves.toBe(42);
-  });
-
-  it("does not replay stream events to late subscribers", async () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("pointerUp", "first");
-
-    const calls: string[] = [];
-    bus.on("pointerUp", (pointerId) => {
-      calls.push(pointerId);
-    });
-
-    await flushMicrotasks();
-    expect(calls).toEqual([]);
-
-    bus.emit("pointerUp", "second");
-    expect(calls).toEqual(["second"]);
-  });
-
-  it("replays replay-last stream events and stays subscribed", async () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("viewState", 1);
-
-    const calls: number[] = [];
-    bus.on("viewState", (zoom) => {
-      calls.push(zoom);
-    });
-
-    await flushMicrotasks();
-    expect(calls).toEqual([1]);
-
-    bus.emit("viewState", 2);
-    expect(calls).toEqual([1, 2]);
-  });
-
-  it("throws when emitting a once event twice", () => {
-    const bus = new AppEventBus<TestEvents, typeof behavior>(behavior);
-    bus.emit("initialize", 1);
-
-    expect(() => {
-      bus.emit("initialize", 2);
-    }).toThrow('Event "initialize" can only be emitted once');
-  });
-});

packages/common/src/appEventBus.ts

@@ -1,136 +0,0 @@
-import type { UnsubscribeCallback } from "@excalidraw/excalidraw/types";
-
-import { Emitter } from "./emitter";
-import { isProdEnv } from "./utils";
-
-export type AppEventPayloadMap = Record<string, unknown[]>;
-
-export type AppEventBehavior = {
-  cardinality: "once" | "many";
-  replay: "none" | "last";
-};
-
-export type AppEventBehaviorMap<Events extends AppEventPayloadMap> = {
-  [K in keyof Events]: AppEventBehavior;
-};
-
-type AwaitableAppEventKeys<
-  Events extends AppEventPayloadMap,
-  Behavior extends AppEventBehaviorMap<Events>,
-> = {
-  [K in keyof Events]: Behavior[K]["cardinality"] extends "once"
-    ? Behavior[K]["replay"] extends "last"
-      ? K
-      : never
-    : never;
-}[keyof Events];
-
-type AppEventPromiseValue<Args extends any[]> = Args extends [infer Only]
-  ? Only
-  : Args;
-
-export class AppEventBus<
-  Events extends AppEventPayloadMap,
-  Behavior extends AppEventBehaviorMap<Events>,
-> {
-  private readonly emitters = new Map<keyof Events, Emitter<any>>();
-  private readonly lastPayload = new Map<keyof Events, any[]>();
-  private readonly emittedOnce = new Set<keyof Events>();
-
-  constructor(private readonly behavior: Behavior) {}
-
-  private getEmitter<K extends keyof Events>(name: K): Emitter<Events[K]> {
-    let emitter = this.emitters.get(name);
-    if (!emitter) {
-      emitter = new Emitter<any>();
-      this.emitters.set(name, emitter);
-    }
-    return emitter as Emitter<Events[K]>;
-  }
-
-  private toPromiseValue<Args extends any[]>(
-    args: Args,
-  ): AppEventPromiseValue<Args> {
-    return (args.length === 1 ? args[0] : args) as AppEventPromiseValue<Args>;
-  }
-
-  public on<K extends keyof Events>(
-    name: K,
-    callback: (...args: Events[K]) => void,
-  ): UnsubscribeCallback;
-  public on<K extends AwaitableAppEventKeys<Events, Behavior>>(
-    name: K,
-  ): Promise<AppEventPromiseValue<Events[K]>>;
-  public on<K extends keyof Events>(
-    name: K,
-    callback?: (...args: Events[K]) => void,
-  ): UnsubscribeCallback | Promise<AppEventPromiseValue<Events[K]>> {
-    const eventBehavior = this.behavior[name];
-    const cachedPayload = this.lastPayload.get(name) as Events[K] | undefined;
-
-    if (callback) {
-      if (eventBehavior.replay === "last" && cachedPayload) {
-        queueMicrotask(() => callback(...cachedPayload));
-
-        if (eventBehavior.cardinality === "once") {
-          return () => {};
-        }
-      }
-
-      return this.getEmitter(name).on(callback);
-    }
-
-    if (
-      eventBehavior.cardinality !== "once" ||
-      eventBehavior.replay !== "last"
-    ) {
-      throw new Error(`Event "${String(name)}" requires a callback`);
-    }
-
-    if (cachedPayload) {
-      return Promise.resolve(this.toPromiseValue(cachedPayload));
-    }
-
-    return new Promise<AppEventPromiseValue<Events[K]>>((resolve) => {
-      this.getEmitter(name).once((...args: Events[K]) => {
-        resolve(this.toPromiseValue(args));
-      });
-    });
-  }
-
-  public emit<K extends keyof Events>(name: K, ...args: Events[K]) {
-    const eventBehavior = this.behavior[name];
-
-    if (!isProdEnv()) {
-      if (eventBehavior.cardinality === "once") {
-        if (this.emittedOnce.has(name)) {
-          throw new Error(`Event "${String(name)}" can only be emitted once`);
-        }
-        this.emittedOnce.add(name);
-      }
-    }
-
-    if (eventBehavior.replay === "last") {
-      this.lastPayload.set(name, args);
-    }
-
-    try {
-      this.getEmitter(name).trigger(...args);
-    } finally {
-      if (eventBehavior.cardinality === "once") {
-        this.getEmitter(name).clear();
-      }
-    }
-  }
-
-  public clear() {
-    this.lastPayload.clear();
-    this.emittedOnce.clear();
-
-    for (const emitter of this.emitters.values()) {
-      emitter.clear();
-    }
-
-    this.emitters.clear();
-  }
-}

packages/common/src/bounds.ts

@@ -1,17 +0,0 @@
-/**
- * x and y position of top left corner, x and y position of bottom right corner
- */
-export type Bounds = readonly [
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-];
-
-export const isBounds = (box: unknown): box is Bounds =>
-  Array.isArray(box) &&
-  box.length === 4 &&
-  typeof box[0] === "number" &&
-  typeof box[1] === "number" &&
-  typeof box[2] === "number" &&
-  typeof box[3] === "number";

packages/common/src/colors.test.ts

@@ -1,286 +0,0 @@
-import {
-  applyDarkModeFilter,
-  COLOR_PALETTE,
-  rgbToHex,
-} from "@excalidraw/common";
-
-describe("COLOR_PALETTE", () => {
-  it("color palette doesn't regress", () => {
-    expect(COLOR_PALETTE).toMatchSnapshot();
-  });
-});
-
-describe("applyDarkModeFilter", () => {
-  describe("basic transformations", () => {
-    it("transforms black to near-white", () => {
-      const result = applyDarkModeFilter("#000000");
-      // Black inverted 93% + hue rotate should be near white/light gray
-      expect(result).toBe("#ededed");
-    });
-
-    it("transforms white to near-black", () => {
-      const result = applyDarkModeFilter("#ffffff");
-      // White inverted 93% should be near black/dark gray
-      expect(result).toBe("#121212");
-    });
-
-    it("transforms pure red", () => {
-      const result = applyDarkModeFilter("#ff0000");
-      // Invert 93% + hue rotate 180deg produces a cyan-ish tint
-      expect(result).toBe("#ff9090");
-    });
-
-    it("transforms pure green", () => {
-      const result = applyDarkModeFilter("#00ff00");
-      // Invert 93% + hue rotate 180deg
-      expect(result).toBe("#008f00");
-    });
-
-    it("transforms pure blue", () => {
-      const result = applyDarkModeFilter("#0000ff");
-      // Invert 93% + hue rotate 180deg produces a light purple
-      expect(result).toBe("#cdcdff");
-    });
-  });
-
-  describe("color formats", () => {
-    it("handles hex with hash", () => {
-      const result = applyDarkModeFilter("#ff0000");
-      // Fully opaque colors return 6-char hex
-      expect(result).toMatch(/^#[0-9a-f]{6}$/);
-    });
-
-    it("handles named colors", () => {
-      const result = applyDarkModeFilter("red");
-      // "red" = #ff0000, fully opaque
-      expect(result).toBe("#ff9090");
-    });
-
-    it("handles rgb format", () => {
-      const result = applyDarkModeFilter("rgb(255, 0, 0)");
-      expect(result).toBe("#ff9090");
-    });
-
-    it("handles rgba format and preserves alpha", () => {
-      const result = applyDarkModeFilter("rgba(255, 0, 0, 0.5)");
-      expect(result).toMatch(/^#[0-9a-f]{8}$/);
-      // Alpha 0.5 = 128 in hex = 80
-      expect(result).toBe("#ff909080");
-    });
-
-    it("handles transparent", () => {
-      const result = applyDarkModeFilter("transparent");
-      // transparent = rgba(0,0,0,0), inverted should still have 0 alpha
-      expect(result).toBe("#ededed00");
-    });
-
-    it("handles shorthand hex", () => {
-      const result = applyDarkModeFilter("#f00");
-      expect(result).toBe("#ff9090");
-    });
-  });
-
-  describe("alpha preservation", () => {
-    it("omits alpha for full opacity", () => {
-      const result = applyDarkModeFilter("#ff0000ff");
-      // Full opacity returns 6-char hex (no alpha suffix)
-      expect(result).toBe("#ff9090");
-    });
-
-    it("preserves 50% opacity", () => {
-      const result = applyDarkModeFilter("#ff000080");
-      expect(result.slice(-2)).toBe("80");
-    });
-
-    it("preserves 0% opacity", () => {
-      const result = applyDarkModeFilter("#ff000000");
-      expect(result.slice(-2)).toBe("00");
-    });
-  });
-
-  describe("COLOR_PALETTE regression tests", () => {
-    it("transforms black from palette", () => {
-      // COLOR_PALETTE.black is #1e1e1e (not pure black)
-      const result = applyDarkModeFilter(COLOR_PALETTE.black);
-      expect(result).toBe("#d3d3d3");
-    });
-
-    it("transforms white from palette", () => {
-      const result = applyDarkModeFilter(COLOR_PALETTE.white);
-      expect(result).toBe("#121212");
-    });
-
-    it("transforms transparent from palette", () => {
-      const result = applyDarkModeFilter(COLOR_PALETTE.transparent);
-      expect(result).toBe("#ededed00");
-    });
-
-    // Test each color family from the palette (all opaque, so 6-char hex)
-    describe("red shades", () => {
-      const redShades = COLOR_PALETTE.red;
-      it.each(redShades.map((color, i) => [color, i]))(
-        "transforms red shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("blue shades", () => {
-      const blueShades = COLOR_PALETTE.blue;
-      it.each(blueShades.map((color, i) => [color, i]))(
-        "transforms blue shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("green shades", () => {
-      const greenShades = COLOR_PALETTE.green;
-      it.each(greenShades.map((color, i) => [color, i]))(
-        "transforms green shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("gray shades", () => {
-      const grayShades = COLOR_PALETTE.gray;
-      it.each(grayShades.map((color, i) => [color, i]))(
-        "transforms gray shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    describe("bronze shades", () => {
-      const bronzeShades = COLOR_PALETTE.bronze;
-      it.each(bronzeShades.map((color, i) => [color, i]))(
-        "transforms bronze shade %s (index %d)",
-        (color) => {
-          const result = applyDarkModeFilter(color as string);
-          expect(result).toMatch(/^#[0-9a-f]{6}$/);
-        },
-      );
-    });
-
-    // Snapshot test for full palette to catch any regressions
-    it("matches snapshot for all palette colors", () => {
-      const transformedPalette: Record<string, string | string[]> = {};
-
-      transformedPalette.black = applyDarkModeFilter(COLOR_PALETTE.black);
-      transformedPalette.white = applyDarkModeFilter(COLOR_PALETTE.white);
-      transformedPalette.transparent = applyDarkModeFilter(
-        COLOR_PALETTE.transparent,
-      );
-
-      // Transform color arrays
-      for (const colorName of [
-        "gray",
-        "red",
-        "pink",
-        "grape",
-        "violet",
-        "blue",
-        "cyan",
-        "teal",
-        "green",
-        "yellow",
-        "orange",
-        "bronze",
-      ] as const) {
-        const shades = COLOR_PALETTE[colorName];
-        transformedPalette[colorName] = shades.map((shade) =>
-          applyDarkModeFilter(shade),
-        );
-      }
-
-      expect(transformedPalette).toMatchSnapshot();
-    });
-  });
-
-  describe("caching", () => {
-    it("returns same result for same input (cached)", () => {
-      const result1 = applyDarkModeFilter("#ff0000");
-      const result2 = applyDarkModeFilter("#ff0000");
-      expect(result1).toBe(result2);
-    });
-  });
-});
-
-describe("rgbToHex", () => {
-  describe("basic RGB conversion", () => {
-    it("converts black (0,0,0)", () => {
-      expect(rgbToHex(0, 0, 0)).toBe("#000000");
-    });
-
-    it("converts white (255,255,255)", () => {
-      expect(rgbToHex(255, 255, 255)).toBe("#ffffff");
-    });
-
-    it("converts red (255,0,0)", () => {
-      expect(rgbToHex(255, 0, 0)).toBe("#ff0000");
-    });
-
-    it("converts green (0,255,0)", () => {
-      expect(rgbToHex(0, 255, 0)).toBe("#00ff00");
-    });
-
-    it("converts blue (0,0,255)", () => {
-      expect(rgbToHex(0, 0, 255)).toBe("#0000ff");
-    });
-
-    it("converts arbitrary color", () => {
-      expect(rgbToHex(30, 30, 30)).toBe("#1e1e1e");
-    });
-  });
-
-  describe("leading zeros preservation", () => {
-    it("preserves leading zeros for low values", () => {
-      expect(rgbToHex(0, 0, 1)).toBe("#000001");
-      expect(rgbToHex(0, 1, 0)).toBe("#000100");
-      expect(rgbToHex(1, 0, 0)).toBe("#010000");
-    });
-
-    it("preserves zeros for single-digit hex values", () => {
-      expect(rgbToHex(15, 15, 15)).toBe("#0f0f0f");
-    });
-  });
-
-  describe("alpha handling", () => {
-    it("omits alpha when undefined", () => {
-      expect(rgbToHex(255, 0, 0)).toBe("#ff0000");
-      expect(rgbToHex(255, 0, 0, undefined)).toBe("#ff0000");
-    });
-
-    it("omits alpha when fully opaque (1)", () => {
-      expect(rgbToHex(255, 0, 0, 1)).toBe("#ff0000");
-    });
-
-    it("includes alpha for semi-transparent (0.5)", () => {
-      // 0.5 * 255 = 127.5 -> rounds to 128 = 0x80
-      expect(rgbToHex(255, 0, 0, 0.5)).toBe("#ff000080");
-    });
-
-    it("includes alpha for fully transparent (0)", () => {
-      expect(rgbToHex(255, 0, 0, 0)).toBe("#ff000000");
-    });
-
-    it("includes alpha for near-opaque (0.99)", () => {
-      // 0.99 * 255 = 252.45 -> rounds to 252 = 0xfc
-      expect(rgbToHex(255, 0, 0, 0.99)).toBe("#ff0000fc");
-    });
-
-    it("pads alpha with leading zero when needed", () => {
-      // 0.05 * 255 = 12.75 -> rounds to 13 = 0x0d
-      expect(rgbToHex(255, 0, 0, 0.05)).toBe("#ff00000d");
-    });
-  });
-});

packages/common/src/colors.ts

@@ -1,121 +1,8 @@
-import tinycolor from "tinycolor2";
+import oc from "open-color";
 
-import { clamp } from "@excalidraw/math";
-import { degreesToRadians } from "@excalidraw/math";
+import type { Merge } from "./utility-types";
 
-import type { Degrees } from "@excalidraw/math";
-
-// ---------------------------------------------------------------------------
-// Dark mode color transformation
-// ---------------------------------------------------------------------------
-
-// Browser-only cache to avoid memory leaks on server
-const DARK_MODE_COLORS_CACHE: Map<string, string> | null =
-  typeof window !== "undefined" ? new Map() : null;
-
-function cssHueRotate(
-  red: number,
-  green: number,
-  blue: number,
-  degrees: Degrees,
-): { r: number; g: number; b: number } {
-  // normalize
-  const r = red / 255;
-  const g = green / 255;
-  const b = blue / 255;
-
-  // Convert degrees to radians
-  const a = degreesToRadians(degrees);
-
-  const c = Math.cos(a);
-  const s = Math.sin(a);
-
-  // rotation matrix
-  const matrix = [
-    0.213 + c * 0.787 - s * 0.213,
-    0.715 - c * 0.715 - s * 0.715,
-    0.072 - c * 0.072 + s * 0.928,
-    0.213 - c * 0.213 + s * 0.143,
-    0.715 + c * 0.285 + s * 0.14,
-    0.072 - c * 0.072 - s * 0.283,
-    0.213 - c * 0.213 - s * 0.787,
-    0.715 - c * 0.715 + s * 0.715,
-    0.072 + c * 0.928 + s * 0.072,
-  ];
-
-  // transform
-  const newR = r * matrix[0] + g * matrix[1] + b * matrix[2];
-  const newG = r * matrix[3] + g * matrix[4] + b * matrix[5];
-  const newB = r * matrix[6] + g * matrix[7] + b * matrix[8];
-
-  // clamp the values to [0, 1] range and convert back to [0, 255]
-  return {
-    r: Math.round(Math.max(0, Math.min(1, newR)) * 255),
-    g: Math.round(Math.max(0, Math.min(1, newG)) * 255),
-    b: Math.round(Math.max(0, Math.min(1, newB)) * 255),
-  };
-}
-
-const cssInvert = (
-  r: number,
-  g: number,
-  b: number,
-  percent: number,
-): { r: number; g: number; b: number } => {
-  const p = clamp(percent, 0, 100) / 100;
-
-  // Function to invert a single color component
-  const invertComponent = (color: number): number => {
-    // Apply the invert formula
-    const inverted = color * (1 - p) + (255 - color) * p;
-    // Round to the nearest integer and clamp to [0, 255]
-    return Math.round(clamp(inverted, 0, 255));
-  };
-
-  // Calculate the inverted RGB components
-  const invertedR = invertComponent(r);
-  const invertedG = invertComponent(g);
-  const invertedB = invertComponent(b);
-
-  return { r: invertedR, g: invertedG, b: invertedB };
-};
-
-export const applyDarkModeFilter = (color: string, enable = true): string => {
-  if (!enable) {
-    return color;
-  }
-
-  const cached = DARK_MODE_COLORS_CACHE?.get(color);
-  if (cached) {
-    return cached;
-  }
-
-  const tc = tinycolor(color);
-  const alpha = tc.getAlpha();
-
-  // order of operations matters
-  // (corresponds to "filter: invert(invertPercent) hue-rotate(hueDegrees)" in css)
-  const rgb = tc.toRgb();
-  const inverted = cssInvert(rgb.r, rgb.g, rgb.b, 93);
-  const rotated = cssHueRotate(
-    inverted.r,
-    inverted.g,
-    inverted.b,
-    180 as Degrees,
-  );
-
-  const result = rgbToHex(rotated.r, rotated.g, rotated.b, alpha);
-
-  if (DARK_MODE_COLORS_CACHE) {
-    DARK_MODE_COLORS_CACHE.set(color, result);
-  }
-
-  return result;
-};
-
-// ---------------------------------------------------------------------------
-// Color palette
-// ---------------------------------------------------------------------------
+export const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
 
 // FIXME can't put to utils.ts rn because of circular dependency
 const pick = <R extends Record<string, any>, K extends readonly (keyof R)[]>(
@@ -130,7 +17,15 @@ const pick = <R extends Record<string, any>, K extends readonly (keyof R)[]>(
   }, {} as Pick<R, K[number]>) as Pick<R, K[number]>;
 };
 
+export type ColorPickerColor =
+  | Exclude<keyof oc, "indigo" | "lime">
+  | "transparent"
+  | "bronze";
 export type ColorTuple = readonly [string, string, string, string, string];
+export type ColorPalette = Merge<
+  Record<ColorPickerColor, ColorTuple>,
+  { black: "#1e1e1e"; white: "#ffffff"; transparent: "transparent" }
+>;
 
 // used general type instead of specific type (ColorPalette) to support custom colors
 export type ColorPaletteCustom = { [key: string]: ColorTuple | string };
@@ -143,30 +38,38 @@ export const DEFAULT_CHART_COLOR_INDEX = 4;
 
 export const DEFAULT_ELEMENT_STROKE_COLOR_INDEX = 4;
 export const DEFAULT_ELEMENT_BACKGROUND_COLOR_INDEX = 1;
+export const ELEMENTS_PALETTE_SHADE_INDEXES = [0, 2, 4, 6, 8] as const;
+export const CANVAS_PALETTE_SHADE_INDEXES = [0, 1, 2, 3, 4] as const;
+
+export const getSpecificColorShades = (
+  color: Exclude<
+    ColorPickerColor,
+    "transparent" | "white" | "black" | "bronze"
+  >,
+  indexArr: Readonly<ColorShadesIndexes>,
+) => {
+  return indexArr.map((index) => oc[color][index]) as any as ColorTuple;
+};
 
 export const COLOR_PALETTE = {
   transparent: "transparent",
   black: "#1e1e1e",
   white: "#ffffff",
-  // open-color from https://github.com/yeun/open-color/blob/master/open-color.js
-  // corresponds to indexes [0,2,4,6,8] (weights: 50, 200, 400, 600, 800)
-  gray: ["#f8f9fa", "#e9ecef", "#ced4da", "#868e96", "#343a40"],
-  red: ["#fff5f5", "#ffc9c9", "#ff8787", "#fa5252", "#e03131"],
-  pink: ["#fff0f6", "#fcc2d7", "#f783ac", "#e64980", "#c2255c"],
-  grape: ["#f8f0fc", "#eebefa", "#da77f2", "#be4bdb", "#9c36b5"],
-  violet: ["#f3f0ff", "#d0bfff", "#9775fa", "#7950f2", "#6741d9"],
-  blue: ["#e7f5ff", "#a5d8ff", "#4dabf7", "#228be6", "#1971c2"],
-  cyan: ["#e3fafc", "#99e9f2", "#3bc9db", "#15aabf", "#0c8599"],
-  teal: ["#e6fcf5", "#96f2d7", "#38d9a9", "#12b886", "#099268"],
-  green: ["#ebfbee", "#b2f2bb", "#69db7c", "#40c057", "#2f9e44"],
-  yellow: ["#fff9db", "#ffec99", "#ffd43b", "#fab005", "#f08c00"],
-  orange: ["#fff4e6", "#ffd8a8", "#ffa94d", "#fd7e14", "#e8590c"],
-  // radix bronze shades [3,5,7,9,11]
+  // open-colors
+  gray: getSpecificColorShades("gray", ELEMENTS_PALETTE_SHADE_INDEXES),
+  red: getSpecificColorShades("red", ELEMENTS_PALETTE_SHADE_INDEXES),
+  pink: getSpecificColorShades("pink", ELEMENTS_PALETTE_SHADE_INDEXES),
+  grape: getSpecificColorShades("grape", ELEMENTS_PALETTE_SHADE_INDEXES),
+  violet: getSpecificColorShades("violet", ELEMENTS_PALETTE_SHADE_INDEXES),
+  blue: getSpecificColorShades("blue", ELEMENTS_PALETTE_SHADE_INDEXES),
+  cyan: getSpecificColorShades("cyan", ELEMENTS_PALETTE_SHADE_INDEXES),
+  teal: getSpecificColorShades("teal", ELEMENTS_PALETTE_SHADE_INDEXES),
+  green: getSpecificColorShades("green", ELEMENTS_PALETTE_SHADE_INDEXES),
+  yellow: getSpecificColorShades("yellow", ELEMENTS_PALETTE_SHADE_INDEXES),
+  orange: getSpecificColorShades("orange", ELEMENTS_PALETTE_SHADE_INDEXES),
+  // radix bronze shades 3,5,7,9,11
   bronze: ["#f8f1ee", "#eaddd7", "#d2bab0", "#a18072", "#846358"],
-} as const;
-
-export type ColorPalette = typeof COLOR_PALETTE;
-export type ColorPickerColor = keyof typeof COLOR_PALETTE;
+} as ColorPalette;
 
 const COMMON_ELEMENT_SHADES = pick(COLOR_PALETTE, [
   "cyan",
@@ -181,6 +84,7 @@ const COMMON_ELEMENT_SHADES = pick(COLOR_PALETTE, [
   "red",
 ]);
 
+// -----------------------------------------------------------------------------
 // quick picks defaults
 // -----------------------------------------------------------------------------
 
@@ -215,6 +119,7 @@ export const DEFAULT_CANVAS_BACKGROUND_PICKS = [
   "#fdf8f6",
 ] as ColorTuple;
 
+// -----------------------------------------------------------------------------
 // palette defaults
 // -----------------------------------------------------------------------------
 
@@ -240,120 +145,29 @@ export const DEFAULT_ELEMENT_BACKGROUND_COLOR_PALETTE = {
   ...COMMON_ELEMENT_SHADES,
 } as const;
 
-// color palette helpers
+// -----------------------------------------------------------------------------
+// helpers
 // -----------------------------------------------------------------------------
 
 // !!!MUST BE WITHOUT GRAY, TRANSPARENT AND BLACK!!!
-export const getAllColorsSpecificShade = (index: 0 | 1 | 2 | 3 | 4) => [
-  // 2nd row
-  COLOR_PALETTE.cyan[index],
-  COLOR_PALETTE.blue[index],
-  COLOR_PALETTE.violet[index],
-  COLOR_PALETTE.grape[index],
-  COLOR_PALETTE.pink[index],
+export const getAllColorsSpecificShade = (index: 0 | 1 | 2 | 3 | 4) =>
+  [
+    // 2nd row
+    COLOR_PALETTE.cyan[index],
+    COLOR_PALETTE.blue[index],
+    COLOR_PALETTE.violet[index],
+    COLOR_PALETTE.grape[index],
+    COLOR_PALETTE.pink[index],
 
-  // 3rd row
-  COLOR_PALETTE.green[index],
-  COLOR_PALETTE.teal[index],
-  COLOR_PALETTE.yellow[index],
-  COLOR_PALETTE.orange[index],
-  COLOR_PALETTE.red[index],
-];
+    // 3rd row
+    COLOR_PALETTE.green[index],
+    COLOR_PALETTE.teal[index],
+    COLOR_PALETTE.yellow[index],
+    COLOR_PALETTE.orange[index],
+    COLOR_PALETTE.red[index],
+  ] as const;
+
+export const rgbToHex = (r: number, g: number, b: number) =>
+  `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
 
 // -----------------------------------------------------------------------------
-// other helpers
-// -----------------------------------------------------------------------------
-
-export const rgbToHex = (r: number, g: number, b: number, a?: number) => {
-  // (1 << 24) adds 0x1000000 to ensure the hex string is always 7 chars,
-  // then slice(1) removes the leading "1" to get exactly 6 hex digits
-  // e.g. rgb(0,0,0) -> 0x1000000 -> "1000000" -> "000000"
-  const hex6 = `#${((1 << 24) + (r << 16) + (g << 8) + b)
-    .toString(16)
-    .slice(1)}`;
-  if (a !== undefined && a < 1) {
-    // convert alpha from 0-1 float to 0-255 int, then to 2-digit hex
-    // e.g. 0.5 -> 128 -> "80"
-    const alphaHex = Math.round(a * 255)
-      .toString(16)
-      .padStart(2, "0");
-    return `${hex6}${alphaHex}`;
-  }
-  return hex6;
-};
-
-/**
- * @returns #RRGGBB or #RRGGBBAA based on color containing non-opaque alpha,
- *  null if not valid color
- */
-export const colorToHex = (color: string): string | null => {
-  const tc = tinycolor(color);
-  if (!tc.isValid()) {
-    return null;
-  }
-  const { r, g, b, a } = tc.toRgb();
-  return rgbToHex(r, g, b, a);
-};
-
-export const isTransparent = (color: string) => {
-  return tinycolor(color).getAlpha() === 0;
-};
-
-// -----------------------------------------------------------------------------
-// color contract helpers
-// -----------------------------------------------------------------------------
-
-export const COLOR_OUTLINE_CONTRAST_THRESHOLD = 240;
-
-const calculateContrast = (r: number, g: number, b: number): number => {
-  const yiq = (r * 299 + g * 587 + b * 114) / 1000;
-  return yiq;
-};
-
-// YIQ algo, inspiration from https://stackoverflow.com/a/11868398
-export const isColorDark = (color: string, threshold = 160): boolean => {
-  // no color ("") -> assume it default to black
-  if (!color) {
-    return true;
-  }
-
-  if (isTransparent(color)) {
-    return false;
-  }
-
-  const tc = tinycolor(color);
-  if (!tc.isValid()) {
-    // invalid color -> assume it defaults to black
-    return true;
-  }
-
-  const { r, g, b } = tc.toRgb();
-  return calculateContrast(r, g, b) < threshold;
-};
-
-// -----------------------------------------------------------------------------
-// normalization
-// -----------------------------------------------------------------------------
-
-/**
- * tries to keep the input color as-is if it's valid, making minimal adjustments
- * (trimming whitespace or adding `#` to hex colors)
- */
-export const normalizeInputColor = (color: string): string | null => {
-  color = color.trim();
-  if (isTransparent(color)) {
-    return color;
-  }
-
-  const tc = tinycolor(color);
-  if (tc.isValid()) {
-    // testing for `#` first fixes a bug on Electron (more specfically, an
-    // Obsidian popout window), where a hex color without `#` is considered valid
-    if (["hex", "hex8"].includes(tc.getFormat()) && !color.startsWith("#")) {
-      return `#${color}`;
-    }
-    return color;
-  }
-
-  return null;
-};

packages/common/src/constants.ts

@@ -106,16 +106,8 @@ export const CLASSES = {
   CONVERT_ELEMENT_TYPE_POPUP: "ConvertElementTypePopup",
   SHAPE_ACTIONS_THEME_SCOPE: "shape-actions-theme-scope",
   FRAME_NAME: "frame-name",
-  DROPDOWN_MENU_EVENT_WRAPPER: "dropdown-menu-event-wrapper",
 };
 
-export const FONT_SIZES = {
-  sm: 16,
-  md: 20,
-  lg: 28,
-  xl: 36,
-} as const;
-
 export const CJK_HAND_DRAWN_FALLBACK_FONT = "Xiaolai";
 export const WINDOWS_EMOJI_FALLBACK_FONT = "Segoe UI Emoji";
 
@@ -191,8 +183,6 @@ export const THEME = {
   DARK: "dark",
 } as const;
 
-export const DARK_THEME_FILTER = "invert(93%) hue-rotate(180deg)";
-
 export const FRAME_STYLE = {
   strokeColor: "#bbb" as ExcalidrawElement["strokeColor"],
   strokeWidth: 2 as ExcalidrawElement["strokeWidth"],
@@ -252,7 +242,6 @@ export const STRING_MIME_TYPES = {
   json: "application/json",
   // excalidraw data
   excalidraw: "application/vnd.excalidraw+json",
-  excalidrawClipboard: "application/vnd.excalidraw.clipboard+json",
   // LEGACY: fully-qualified library JSON data
   excalidrawlib: "application/vnd.excalidrawlib+json",
   // list of excalidraw library item ids
@@ -309,6 +298,9 @@ export const IDLE_THRESHOLD = 60_000;
 // Report a user active each ACTIVE_THRESHOLD milliseconds
 export const ACTIVE_THRESHOLD = 3_000;
 
+// duplicates --theme-filter, should be removed soon
+export const THEME_FILTER = "invert(93%) hue-rotate(180deg)";
+
 export const URL_QUERY_KEYS = {
   addLibrary: "addLibrary",
 } as const;
@@ -337,10 +329,9 @@ export const MAX_DECIMALS_FOR_SVG_EXPORT = 2;
 export const EXPORT_SCALES = [1, 2, 3];
 export const DEFAULT_EXPORT_PADDING = 10; // px
 
-export const DEFAULT_IMAGE_OPTIONS: AppProps["imageOptions"] = {
-  maxWidthOrHeight: 1440,
-  maxFileSizeBytes: 4 * 1024 * 1024,
-};
+export const DEFAULT_MAX_IMAGE_WIDTH_OR_HEIGHT = 1440;
+
+export const MAX_ALLOWED_FILE_BYTES = 4 * 1024 * 1024;
 
 export const SVG_NS = "http://www.w3.org/2000/svg";
 export const SVG_DOCUMENT_PREAMBLE = `<?xml version="1.0" standalone="no"?>
@@ -404,47 +395,11 @@ export const ROUGHNESS = {
   cartoonist: 2,
 } as const;
 
-export type StrokeWidthKey = "thin" | "medium" | "bold";
-
-export const STROKE_WIDTH_KEYS: readonly StrokeWidthKey[] = [
-  "thin",
-  "medium",
-  "bold",
-];
-
-export const STROKE_WIDTH: Readonly<
-  Record<StrokeWidthKey | "extraBold", ExcalidrawElement["strokeWidth"]>
-> = {
+export const STROKE_WIDTH = {
   thin: 1,
-  medium: 2,
-  bold: 4,
-  extraBold: 8, // unused (may be introduced in the future)
-};
-
-// freedraw schema 2.0 uses thinner stroke, but to maintain backwards and
-// forwards compatibility, instead of changing the shape renderer, we scale
-// the stroke width by 1/2 (previous, thin was 1, medium 2 etc.)
-//
-// note that in the UI, STROKE_WIDTH.thin == FREEDRAW_STROKE_WIDTH.thin still
-export const FREEDRAW_STROKE_WIDTH: Readonly<
-  Record<StrokeWidthKey | "extraBold", ExcalidrawElement["strokeWidth"]>
-> = {
-  thin: 0.5,
-  medium: 1,
   bold: 2,
-  extraBold: 4, // legacy (may be used again in the future)
-};
-
-export const getStrokeWidthByKey = (
-  elementType: ExcalidrawElement["type"],
-  strokeWidthKey: StrokeWidthKey,
-): ExcalidrawElement["strokeWidth"] => {
-  return elementType === "freedraw"
-    ? FREEDRAW_STROKE_WIDTH[strokeWidthKey]
-    : STROKE_WIDTH[strokeWidthKey];
-};
-
-export const DEFAULT_ELEMENT_STROKE_WIDTH_KEY: StrokeWidthKey = "medium";
+  extraBold: 4,
+} as const;
 
 export const DEFAULT_ELEMENT_PROPS: {
   strokeColor: ExcalidrawElement["strokeColor"];
@@ -459,7 +414,7 @@ export const DEFAULT_ELEMENT_PROPS: {
   strokeColor: COLOR_PALETTE.black,
   backgroundColor: COLOR_PALETTE.transparent,
   fillStyle: "solid",
-  strokeWidth: STROKE_WIDTH[DEFAULT_ELEMENT_STROKE_WIDTH_KEY],
+  strokeWidth: 2,
   strokeStyle: "solid",
   roughness: ROUGHNESS.artist,
   opacity: 100,
@@ -550,6 +505,3 @@ export const BIND_MODE_TIMEOUT = 700; // ms
 export const MOBILE_ACTION_BUTTON_BG = {
   background: "var(--mobile-action-button-bg)",
 } as const;
-
-export const DEFAULT_STROKE_STREAMLINE = 0.5;
-export const DEFAULT_STROKE_STREAMLINE_PRECISE = 0.2;

packages/common/src/editorInterface.ts

@@ -1,3 +1,5 @@
+import mobile from "is-mobile";
+
 export type StylesPanelMode = "compact" | "full" | "mobile";
 
 export type EditorInterface = Readonly<{
@@ -16,6 +18,7 @@ export type EditorInterface = Readonly<{
 const DESKTOP_UI_MODE_STORAGE_KEY = "excalidraw.desktopUIMode";
 
 // breakpoints
+// mobile: up to 699px
 export const MQ_MAX_MOBILE = 599;
 
 export const MQ_MAX_WIDTH_LANDSCAPE = 1000;
@@ -23,9 +26,9 @@ export const MQ_MAX_HEIGHT_LANDSCAPE = 500;
 
 // tablets
 export const MQ_MIN_TABLET = MQ_MAX_MOBILE + 1; // lower bound (excludes phones)
-export const MQ_MAX_TABLET = 1180; // ipad air
+export const MQ_MAX_TABLET = 1400; // upper bound (excludes laptops/desktops)
 
-// desktop/laptop (NOTE: not used for form factor detection)
+// desktop/laptop
 export const MQ_MIN_WIDTH_DESKTOP = 1440;
 
 // sidebar
@@ -138,12 +141,13 @@ export const getFormFactor = (
   editorWidth: number,
   editorHeight: number,
 ): EditorInterface["formFactor"] => {
-  if (isMobileBreakpoint(editorWidth, editorHeight)) {
+  if (mobile()) {
     return "phone";
-  }
-
-  if (isTabletBreakpoint(editorWidth, editorHeight)) {
+  } else if (mobile({ tablet: true })) {
     return "tablet";
+  } else if (isMobileBreakpoint(editorWidth, editorHeight)) {
+    // NOTE: Very small editor sizes should be treated as phone
+    return "phone";
   }
 
   return "desktop";

packages/common/src/index.ts

@@ -1,5 +1,4 @@
 export * from "./binary-heap";
-export * from "./bounds";
 export * from "./colors";
 export * from "./constants";
 export * from "./font-metadata";
@@ -11,7 +10,5 @@ export * from "./random";
 export * from "./url";
 export * from "./utils";
 export * from "./emitter";
-export * from "./appEventBus";
+export * from "./visualdebug";
 export * from "./editorInterface";
-export * from "./versionedSnapshotStore";
-export { Debug } from "../debug";

packages/common/src/utils.test.ts

@@ -3,12 +3,6 @@ import {
   mapFind,
   reduceToCommonValue,
 } from "@excalidraw/common";
-import { vi } from "vitest";
-
-// Import directly to avoid the @excalidraw/common throttleRAF mock from setupTests.ts.
-import { throttleRAF } from "./utils";
-
-type RafCallback = FrameRequestCallback;
 
 describe("@excalidraw/common/utils", () => {
   describe("isTransparent()", () => {
@@ -85,87 +79,4 @@ describe("@excalidraw/common/utils", () => {
       expect(mapFind([1, 2], () => null)).toBe(undefined);
     });
   });
-
-  describe("throttleRAF()", () => {
-    let frameCallbacks: Map<number, RafCallback>;
-    let nextFrameId: number;
-
-    const runScheduledFrame = (timestamp = 16) => {
-      const callbacks = [...frameCallbacks.values()];
-      frameCallbacks.clear();
-      callbacks.forEach((callback) => callback(timestamp));
-    };
-
-    beforeEach(() => {
-      frameCallbacks = new Map();
-      nextFrameId = 0;
-
-      vi.spyOn(window, "requestAnimationFrame").mockImplementation(
-        (callback) => {
-          const frameId = ++nextFrameId;
-          frameCallbacks.set(frameId, callback);
-          return frameId;
-        },
-      );
-
-      vi.spyOn(window, "cancelAnimationFrame").mockImplementation((frameId) => {
-        frameCallbacks.delete(frameId);
-      });
-    });
-
-    afterEach(() => {
-      vi.restoreAllMocks();
-    });
-
-    it("should invoke the callback with the last args from the same frame", () => {
-      const fn = vi.fn();
-      const throttled = throttleRAF(fn);
-
-      throttled("first", 1);
-      throttled("second", 2);
-      throttled("last", 3);
-
-      expect(fn).not.toHaveBeenCalled();
-      expect(window.requestAnimationFrame).toHaveBeenCalledTimes(1);
-
-      runScheduledFrame();
-
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledWith("last", 3);
-    });
-
-    it("should flush the pending callback immediately", () => {
-      const fn = vi.fn();
-      const throttled = throttleRAF(fn);
-
-      throttled("first");
-      throttled("last");
-
-      throttled.flush();
-
-      expect(window.cancelAnimationFrame).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledTimes(1);
-      expect(fn).toHaveBeenCalledWith("last");
-
-      runScheduledFrame();
-
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-
-    it("should cancel the pending callback", () => {
-      const fn = vi.fn();
-      const throttled = throttleRAF(fn);
-
-      throttled("first");
-      throttled("last");
-
-      throttled.cancel();
-
-      expect(window.cancelAnimationFrame).toHaveBeenCalledTimes(1);
-
-      runScheduledFrame();
-
-      expect(fn).not.toHaveBeenCalled();
-    });
-  });
 });

packages/common/src/utils.ts

@@ -1,7 +1,5 @@
 import { average } from "@excalidraw/math";
 
-import type { GlobalCoord } from "@excalidraw/math";
-
 import type { FontFamilyValues, FontString } from "@excalidraw/element/types";
 
 import type {
@@ -12,6 +10,7 @@ import type {
   Zoom,
 } from "@excalidraw/excalidraw/types";
 
+import { COLOR_PALETTE } from "./colors";
 import {
   DEFAULT_VERSION,
   ENV,
@@ -88,8 +87,7 @@ export const isWritableElement = (
     (target.type === "text" ||
       target.type === "number" ||
       target.type === "password" ||
-      target.type === "search")) ||
-  (target instanceof HTMLElement && target.closest(".cm-editor") !== null);
+      target.type === "search"));
 
 export const getFontFamilyString = ({
   fontFamily,
@@ -151,27 +149,38 @@ export const debounce = <T extends any[]>(
   return ret;
 };
 
-// throttle callback to execute once per animation frame using the latest args
-export const throttleRAF = <T extends any[]>(fn: (...args: T) => void) => {
+// throttle callback to execute once per animation frame
+export const throttleRAF = <T extends any[]>(
+  fn: (...args: T) => void,
+  opts?: { trailing?: boolean },
+) => {
   let timerId: number | null = null;
   let lastArgs: T | null = null;
+  let lastArgsTrailing: T | null = null;
 
-  const scheduleFunc = () => {
+  const scheduleFunc = (args: T) => {
     timerId = window.requestAnimationFrame(() => {
       timerId = null;
-      const args = lastArgs;
+      fn(...args);
       lastArgs = null;
-
-      if (args) {
-        fn(...args);
+      if (lastArgsTrailing) {
+        lastArgs = lastArgsTrailing;
+        lastArgsTrailing = null;
+        scheduleFunc(lastArgs);
       }
     });
   };
 
   const ret = (...args: T) => {
+    if (isTestEnv()) {
+      fn(...args);
+      return;
+    }
     lastArgs = args;
     if (timerId === null) {
-      scheduleFunc();
+      scheduleFunc(lastArgs);
+    } else if (opts?.trailing) {
+      lastArgsTrailing = args;
     }
   };
   ret.flush = () => {
@@ -180,12 +189,12 @@ export const throttleRAF = <T extends any[]>(fn: (...args: T) => void) => {
       timerId = null;
     }
     if (lastArgs) {
-      fn(...lastArgs);
-      lastArgs = null;
+      fn(...(lastArgsTrailing || lastArgs));
+      lastArgs = lastArgsTrailing = null;
     }
   };
   ret.cancel = () => {
-    lastArgs = null;
+    lastArgs = lastArgsTrailing = null;
     if (timerId !== null) {
       cancelAnimationFrame(timerId);
       timerId = null;
@@ -204,6 +213,135 @@ export const easeOut = (k: number) => {
   return 1 - Math.pow(1 - k, 4);
 };
 
+const easeOutInterpolate = (from: number, to: number, progress: number) => {
+  return (to - from) * easeOut(progress) + from;
+};
+
+/**
+ * Animates values from `fromValues` to `toValues` using the requestAnimationFrame API.
+ * Executes the `onStep` callback on each step with the interpolated values.
+ * Returns a function that can be called to cancel the animation.
+ *
+ * @example
+ * // Example usage:
+ * const fromValues = { x: 0, y: 0 };
+ * const toValues = { x: 100, y: 200 };
+ * const onStep = ({x, y}) => {
+ *   setState(x, y)
+ * };
+ * const onCancel = () => {
+ *   console.log("Animation canceled");
+ * };
+ *
+ * const cancelAnimation = easeToValuesRAF({
+ *   fromValues,
+ *   toValues,
+ *   onStep,
+ *   onCancel,
+ * });
+ *
+ * // To cancel the animation:
+ * cancelAnimation();
+ */
+export const easeToValuesRAF = <
+  T extends Record<keyof T, number>,
+  K extends keyof T,
+>({
+  fromValues,
+  toValues,
+  onStep,
+  duration = 250,
+  interpolateValue,
+  onStart,
+  onEnd,
+  onCancel,
+}: {
+  fromValues: T;
+  toValues: T;
+  /**
+   * Interpolate a single value.
+   * Return undefined to be handled by the default interpolator.
+   */
+  interpolateValue?: (
+    fromValue: number,
+    toValue: number,
+    /** no easing applied  */
+    progress: number,
+    key: K,
+  ) => number | undefined;
+  onStep: (values: T) => void;
+  duration?: number;
+  onStart?: () => void;
+  onEnd?: () => void;
+  onCancel?: () => void;
+}) => {
+  let canceled = false;
+  let frameId = 0;
+  let startTime: number;
+
+  function step(timestamp: number) {
+    if (canceled) {
+      return;
+    }
+    if (startTime === undefined) {
+      startTime = timestamp;
+      onStart?.();
+    }
+
+    const elapsed = Math.min(timestamp - startTime, duration);
+    const factor = easeOut(elapsed / duration);
+
+    const newValues = {} as T;
+
+    Object.keys(fromValues).forEach((key) => {
+      const _key = key as keyof T;
+      const result = ((toValues[_key] - fromValues[_key]) * factor +
+        fromValues[_key]) as T[keyof T];
+      newValues[_key] = result;
+    });
+
+    onStep(newValues);
+
+    if (elapsed < duration) {
+      const progress = elapsed / duration;
+
+      const newValues = {} as T;
+
+      Object.keys(fromValues).forEach((key) => {
+        const _key = key as K;
+        const startValue = fromValues[_key];
+        const endValue = toValues[_key];
+
+        let result;
+
+        result = interpolateValue
+          ? interpolateValue(startValue, endValue, progress, _key)
+          : easeOutInterpolate(startValue, endValue, progress);
+
+        if (result == null) {
+          result = easeOutInterpolate(startValue, endValue, progress);
+        }
+
+        newValues[_key] = result as T[K];
+      });
+      onStep(newValues);
+
+      frameId = window.requestAnimationFrame(step);
+    } else {
+      onStep(toValues);
+      onEnd?.();
+    }
+  }
+
+  frameId = window.requestAnimationFrame(step);
+
+  return () => {
+    onCancel?.();
+    canceled = true;
+    window.cancelAnimationFrame(frameId);
+  };
+};
+
 // https://github.com/lodash/lodash/blob/es/chunk.js
 export const chunk = <T extends any>(
   array: readonly T[],
@@ -304,7 +442,7 @@ export const viewportCoordsToSceneCoords = (
   const x = (clientX - offsetLeft) / zoom.value - scrollX;
   const y = (clientY - offsetTop) / zoom.value - scrollY;
 
-  return { x, y } as GlobalCoord;
+  return { x, y };
 };
 
 export const sceneCoordsToViewportCoords = (
@@ -410,6 +548,16 @@ export const mapFind = <T, K>(
   return undefined;
 };
 
+export const isTransparent = (color: string) => {
+  const isRGBTransparent = color.length === 5 && color.substr(4, 1) === "0";
+  const isRRGGBBTransparent = color.length === 9 && color.substr(7, 2) === "00";
+  return (
+    isRGBTransparent ||
+    isRRGGBBTransparent ||
+    color === COLOR_PALETTE.transparent
+  );
+};
+
 export type ResolvablePromise<T> = Promise<T> & {
   resolve: [T] extends [undefined]
     ? (value?: MaybePromise<Awaited<T>>) => void
@@ -1009,69 +1157,39 @@ export const normalizeEOL = (str: string) => {
 };
 
 // -----------------------------------------------------------------------------
-export type HasBrand<T> = {
+type HasBrand<T> = {
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  [K in keyof T]: K extends `~brand${infer _}` | "_brand" ? true : never;
+  [K in keyof T]: K extends `~brand${infer _}` ? true : never;
 }[keyof T];
 
 type RemoveAllBrands<T> = HasBrand<T> extends true
   ? {
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      [K in keyof T as K extends `~brand~${infer _}` | "_brand"
-        ? never
-        : K]: T[K];
+      [K in keyof T as K extends `~brand~${infer _}` ? never : K]: T[K];
     }
-  : T;
+  : never;
 
-// For accepting values - uses loose matching for branded types
-// Preserves readonly modifier: mutable array requires mutable input
-type UnbrandForValue<T> = T extends Map<infer E, infer F>
-  ? Map<UnbrandForValue<E>, UnbrandForValue<F>>
+// adapted from https://github.com/colinhacks/zod/discussions/1994#discussioncomment-6068940
+// currently does not cover all types (e.g. tuples, promises...)
+type Unbrand<T> = T extends Map<infer E, infer F>
+  ? Map<E, F>
   : T extends Set<infer E>
-  ? Set<UnbrandForValue<E>>
-  : T extends readonly any[]
-  ? T extends any[]
-    ? unknown[] // mutable array - require mutable input
-    : readonly unknown[] // readonly array - accept readonly input
+  ? Set<E>
+  : T extends Array<infer E>
+  ? Array<E>
   : RemoveAllBrands<T>;
 
-// For return types - preserves array element unbranding
-export type Unbrand<T> = T extends Map<infer E, infer F>
-  ? Map<Unbrand<E>, Unbrand<F>>
-  : T extends Set<infer E>
-  ? Set<Unbrand<E>>
-  : T extends readonly (infer E)[]
-  ? Array<Unbrand<E>>
-  : RemoveAllBrands<T>;
-
-export type CombineBrands<BrandedType, CurrentType> =
-  BrandedType extends readonly (infer BE)[]
-    ? CurrentType extends readonly (infer CE)[]
-      ? Array<CE & BE>
-      : CurrentType & BrandedType
-    : CurrentType & BrandedType;
-
-export type CombineBrandsIfNeeded<T, Required> = [T] extends [Required]
-  ? T[]
-  : HasBrand<T> extends true
-  ? CombineBrands<T, Required>[]
-  : Required[];
-
 /**
  * Makes type into a branded type, ensuring that value is assignable to
- * the base unbranded type. Optionally you can explicitly supply current value
+ * the base ubranded type. Optionally you can explicitly supply current value
  * type to combine both (useful for composite branded types. Make sure you
  * compose branded types which are not composite themselves.)
  */
-export function toBrandedType<BrandedType>(
-  value: UnbrandForValue<BrandedType>,
-): BrandedType;
-export function toBrandedType<BrandedType, CurrentType>(
-  value: CurrentType,
-): CombineBrands<BrandedType, CurrentType>;
-export function toBrandedType(value: unknown) {
-  return value;
-}
+export const toBrandedType = <BrandedType, CurrentType = BrandedType>(
+  value: Unbrand<BrandedType>,
+) => {
+  return value as CurrentType & BrandedType;
+};
 
 // -----------------------------------------------------------------------------
 
@@ -1193,10 +1311,3 @@ export const setFeatureFlag = <F extends keyof FEATURE_FLAGS>(
     console.error("unable to set feature flag", e);
   }
 };
-
-export const oneOf = <N extends string | number | symbol | null, H extends N>(
-  needle: N,
-  haystack: readonly H[],
-): needle is H => {
-  return haystack.includes(needle as any);
-};

packages/common/src/versionedSnapshotStore.ts

@@ -1,70 +0,0 @@
-export type VersionedSnapshot<T> = Readonly<{
-  version: number;
-  value: T;
-}>;
-
-export class VersionedSnapshotStore<T> {
-  private version = 0;
-  private value: T;
-  private readonly waiters = new Set<
-    (snapshot: VersionedSnapshot<T>) => void
-  >();
-  private readonly subscribers = new Set<
-    (snapshot: VersionedSnapshot<T>) => void
-  >();
-
-  constructor(
-    initialValue: T,
-    private readonly isEqual: (prev: T, next: T) => boolean = Object.is,
-  ) {
-    this.value = initialValue;
-  }
-
-  public getSnapshot(): VersionedSnapshot<T> {
-    return { version: this.version, value: this.value };
-  }
-
-  public set(nextValue: T): boolean {
-    if (this.isEqual(this.value, nextValue)) {
-      return false;
-    }
-
-    this.value = nextValue;
-    this.version += 1;
-
-    const snapshot = this.getSnapshot();
-
-    for (const subscriber of this.subscribers) {
-      subscriber(snapshot);
-    }
-    for (const waiter of this.waiters) {
-      waiter(snapshot);
-    }
-    this.waiters.clear();
-
-    return true;
-  }
-
-  public update(updater: (prev: T) => T): boolean {
-    return this.set(updater(this.value));
-  }
-
-  public subscribe(
-    subscriber: (snapshot: VersionedSnapshot<T>) => void,
-  ): () => void {
-    this.subscribers.add(subscriber);
-    return () => {
-      this.subscribers.delete(subscriber);
-    };
-  }
-
-  public pull(sinceVersion = -1): Promise<VersionedSnapshot<T>> {
-    if (this.version !== sinceVersion) {
-      return Promise.resolve(this.getSnapshot());
-    }
-
-    return new Promise((resolve) => {
-      this.waiters.add(resolve);
-    });
-  }
-}

packages/common/src/visualdebug.ts

@@ -1,23 +1,17 @@
 import {
   isLineSegment,
   lineSegment,
-  pointDistanceSq,
   pointFrom,
   type GlobalPoint,
   type LocalPoint,
-  type LineSegment,
 } from "@excalidraw/math";
-import { type Bounds, isBounds } from "@excalidraw/common";
-import {
-  getElementBounds,
-  intersectElementWithLineSegment,
-  isFreeDrawElement,
-  isLinearElement,
-  isPathALoop,
-} from "@excalidraw/element";
 
-import type { ElementsMap, ExcalidrawElement } from "@excalidraw/element/types";
+import { isBounds } from "@excalidraw/element";
+
 import type { Curve } from "@excalidraw/math";
+import type { LineSegment } from "@excalidraw/utils";
+
+import type { Bounds } from "@excalidraw/element";
 
 // The global data holder to collect the debug operations
 declare global {
@@ -31,69 +25,10 @@ declare global {
 
 export type DebugElement = {
   color: string;
-  data: LineSegment<GlobalPoint> | Curve<GlobalPoint> | DebugPolygon;
+  data: LineSegment<GlobalPoint> | Curve<GlobalPoint>;
   permanent: boolean;
 };
 
-export type DebugPolygon = {
-  type: "polygon";
-  points: GlobalPoint[];
-  fill?: boolean;
-  close?: boolean;
-};
-
-export const debugDrawHitVolume = (
-  element: ExcalidrawElement,
-  elementsMap: ElementsMap,
-  options?: {
-    rays?: number;
-    color?: string;
-    fill?: boolean;
-  },
-) => {
-  if (
-    (isLinearElement(element) || isFreeDrawElement(element)) &&
-    !isPathALoop(element.points)
-  ) {
-    return;
-  }
-
-  const [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
-  const center = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
-  const rays = options?.rays ?? 100;
-  const radius = Math.max(x2 - x1, y2 - y1) * 2;
-  const points: GlobalPoint[] = [];
-
-  for (let i = 0; i < rays; i += 1) {
-    const angle = (i / rays) * Math.PI * 2;
-    const end = pointFrom<GlobalPoint>(
-      center[0] + Math.cos(angle) * radius,
-      center[1] + Math.sin(angle) * radius,
-    );
-    const hits = intersectElementWithLineSegment(
-      element,
-      elementsMap,
-      lineSegment(center, end),
-    );
-    if (hits.length === 0) {
-      continue;
-    }
-    hits.sort(pointDistanceSq);
-    points.push(hits[0]);
-  }
-
-  if (points.length >= 3) {
-    debugDrawPolygon(points, {
-      color: options?.color ?? "orange",
-      fill: options?.fill ?? true,
-    });
-  } else {
-    console.warn(
-      `debugDrawHitVolume: could not compute hit volume for element ${element.id}`,
-    );
-  }
-};
-
 export const debugDrawCubicBezier = (
   c: Curve<GlobalPoint>,
   opts?: {
@@ -128,31 +63,6 @@ export const debugDrawLine = (
   );
 };
 
-export const debugDrawPolygon = (
-  points: GlobalPoint[],
-  opts?: {
-    color?: string;
-    permanent?: boolean;
-    fill?: boolean;
-    close?: boolean;
-  },
-) => {
-  if (points.length < 2) {
-    return;
-  }
-
-  addToCurrentFrame({
-    color: opts?.color ?? "orange",
-    permanent: !!opts?.permanent,
-    data: {
-      type: "polygon",
-      points,
-      fill: opts?.fill,
-      close: opts?.close,
-    },
-  });
-};
-
 export const debugDrawPoint = (
   p: GlobalPoint,
   opts?: {
@@ -193,7 +103,7 @@ export const debugDrawBounds = (
     permanent?: boolean;
   },
 ) => {
-  (isBounds(box) ? [box] : box).forEach((bbox: Bounds) =>
+  (isBounds(box) ? [box] : box).forEach((bbox) =>
     debugDrawLine(
       [
         lineSegment(

packages/common/tests/binary-heap.test.ts

@@ -1,109 +0,0 @@
-import { BinaryHeap } from "../src/binary-heap";
-
-describe("BinaryHeap", () => {
-  const numberHeap = () => new BinaryHeap<number>((n) => n);
-
-  const drain = (heap: BinaryHeap<number>) => {
-    const out: number[] = [];
-    while (heap.size() > 0) {
-      out.push(heap.pop()!);
-    }
-    return out;
-  };
-
-  describe("empty heap", () => {
-    it("has size 0", () => {
-      expect(numberHeap().size()).toBe(0);
-    });
-
-    it("pop() returns null", () => {
-      expect(numberHeap().pop()).toBe(null);
-    });
-
-    it("remove() is a no-op and does not throw", () => {
-      const heap = numberHeap();
-      expect(() => heap.remove(1)).not.toThrow();
-      expect(heap.size()).toBe(0);
-    });
-  });
-
-  describe("push / pop", () => {
-    it("tracks size as items are added and removed", () => {
-      const heap = numberHeap();
-      [3, 1, 2].forEach((n) => heap.push(n));
-      expect(heap.size()).toBe(3);
-
-      heap.pop();
-      expect(heap.size()).toBe(2);
-    });
-
-    it("pops a single pushed element back out", () => {
-      const heap = numberHeap();
-      heap.push(42);
-      expect(heap.pop()).toBe(42);
-      expect(heap.pop()).toBe(null);
-    });
-
-    it("always pops the smallest score first", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9, 2, 7].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 2, 3, 5, 7, 8, 9]);
-    });
-
-    it("handles duplicate scores", () => {
-      const heap = numberHeap();
-      [4, 1, 4, 1, 2].forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([1, 1, 2, 4, 4]);
-    });
-
-    it("maintains the heap invariant for a large adversarial (reverse-sorted) input", () => {
-      const heap = numberHeap();
-      // pushing in descending order forces a sift-up on every insert
-      const input = Array.from({ length: 1000 }, (_, i) => 1000 - i);
-      input.forEach((n) => heap.push(n));
-      expect(drain(heap)).toEqual([...input].sort((a, b) => a - b));
-    });
-  });
-
-  describe("remove", () => {
-    it("removes an interior element and keeps the rest ordered", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(8);
-
-      expect(heap.size()).toBe(4);
-      expect(drain(heap)).toEqual([1, 3, 5, 9]);
-    });
-
-    it("can remove the current minimum", () => {
-      const heap = numberHeap();
-      [5, 3, 8, 1, 9].forEach((n) => heap.push(n));
-
-      heap.remove(1);
-
-      expect(heap.size()).toBe(4);
-      expect(heap.pop()).toBe(3);
-    });
-  });
-
-  describe("rescoreElement", () => {
-    type Node = { id: string; f: number };
-
-    it("re-sorts a node after its score is lowered", () => {
-      const heap = new BinaryHeap<Node>((node) => node.f);
-
-      const a = { id: "a", f: 10 };
-      const b = { id: "b", f: 20 };
-      const c = { id: "c", f: 30 };
-      [a, b, c].forEach((node) => heap.push(node));
-
-      c.f = 5;
-      heap.rescoreElement(c);
-
-      expect(heap.pop()).toBe(c);
-      expect(heap.pop()).toBe(a);
-      expect(heap.pop()).toBe(b);
-    });
-  });
-});

packages/common/tsconfig.json

@@ -1,8 +1,7 @@
 {
   "extends": "../tsconfig.base.json",
   "compilerOptions": {
-    "outDir": "./dist/types",
-    "rootDir": "../"
+    "outDir": "./dist/types"
   },
   "include": ["src/**/*", "global.d.ts"],
   "exclude": ["**/*.test.*", "tests", "types", "examples", "dist"]

packages/element/package.json

@@ -17,12 +17,6 @@
       "development": "./dist/dev/index.js",
       "production": "./dist/prod/index.js",
       "default": "./dist/prod/index.js"
-    },
-    "./visualdebug": {
-      "types": "./dist/types/element/src/visualdebug.d.ts",
-      "development": "./dist/dev/visualdebug.js",
-      "production": "./dist/prod/visualdebug.js",
-      "default": "./dist/prod/visualdebug.js"
     }
   },
   "files": [
@@ -64,7 +58,6 @@
   },
   "dependencies": {
     "@excalidraw/common": "0.18.0",
-    "@excalidraw/math": "0.18.0",
-    "@excalidraw/fractional-indexing": "3.3.0"
+    "@excalidraw/math": "0.18.0"
   }
 }

packages/element/src/Scene.ts

@@ -338,18 +338,27 @@ export class Scene {
     this.callbacks.clear();
   }
 
-  /** low-level - generally use app.insertNewElements() */
-  insertElementsAtIndex(
-    elements: ExcalidrawElement[],
-    /** null indicates end of the array */
-    index: number | null,
-  ) {
-    if (!elements.length) {
-      return;
+  insertElementAtIndex(element: ExcalidrawElement, index: number) {
+    if (!Number.isFinite(index) || index < 0) {
+      throw new Error(
+        "insertElementAtIndex can only be called with index >= 0",
+      );
     }
 
-    if (index === null) {
-      index = this.elements.length;
+    const nextElements = [
+      ...this.elements.slice(0, index),
+      element,
+      ...this.elements.slice(index),
+    ];
+
+    syncMovedIndices(nextElements, arrayToMap([element]));
+
+    this.replaceAllElements(nextElements);
+  }
+
+  insertElementsAtIndex(elements: ExcalidrawElement[], index: number) {
+    if (!elements.length) {
+      return;
     }
 
     if (!Number.isFinite(index) || index < 0) {
@@ -369,9 +378,24 @@ export class Scene {
     this.replaceAllElements(nextElements);
   }
 
-  /** low-level - generally use app.insertNewElement() */
   insertElement = (element: ExcalidrawElement) => {
-    this.insertElementsAtIndex([element], null);
+    const index = element.frameId
+      ? this.getElementIndex(element.frameId)
+      : this.elements.length;
+
+    this.insertElementAtIndex(element, index);
+  };
+
+  insertElements = (elements: ExcalidrawElement[]) => {
+    if (!elements.length) {
+      return;
+    }
+
+    const index = elements[0]?.frameId
+      ? this.getElementIndex(elements[0].frameId)
+      : this.elements.length;
+
+    this.insertElementsAtIndex(elements, index);
   };
 
   getElementIndex(elementId: string) {
@@ -414,8 +438,6 @@ export class Scene {
     options: {
       informMutation: boolean;
       isDragging: boolean;
-      isBindingEnabled?: boolean;
-      isMidpointSnappingEnabled?: boolean;
     } = {
       informMutation: true,
       isDragging: false,

packages/element/src/arrowheads.ts

@@ -1,32 +0,0 @@
-import type { Arrowhead, AnyArrowhead } from "./types";
-
-export const normalizeArrowhead = (
-  arrowhead: AnyArrowhead | null | undefined,
-): Arrowhead | null => {
-  switch (arrowhead) {
-    case undefined:
-    case null:
-      return null;
-    case "dot":
-      return "circle";
-    case "crowfoot_one":
-      return "cardinality_one";
-    case "crowfoot_many":
-      return "cardinality_many";
-    case "crowfoot_one_or_many":
-      return "cardinality_one_or_many";
-    default:
-      return arrowhead;
-  }
-};
-
-export const getArrowheadForPicker = (
-  arrowhead: AnyArrowhead | null | undefined,
-): Arrowhead | null => {
-  const normalizedArrowhead = normalizeArrowhead(arrowhead);
-  if (normalizedArrowhead === null) {
-    return null;
-  }
-
-  return normalizedArrowhead;
-};

packages/element/src/arrows/focus.ts

@@ -1,558 +0,0 @@
-import { pointDistance, pointFrom, type GlobalPoint } from "@excalidraw/math";
-import { invariant } from "@excalidraw/common";
-
-import type { AppState, NullableGridSize } from "@excalidraw/excalidraw/types";
-
-import {
-  bindBindingElement,
-  calculateFixedPointForNonElbowArrowBinding,
-  FOCUS_POINT_SIZE,
-  getBindingGap,
-  getGlobalFixedPointForBindableElement,
-  isBindingEnabled,
-  maxBindingDistance_simple,
-  unbindBindingElement,
-  updateBoundPoint,
-} from "../binding";
-import {
-  isBindableElement,
-  isBindingElement,
-  isElbowArrow,
-} from "../typeChecks";
-import { LinearElementEditor } from "../linearElementEditor";
-import { getHoveredElementForFocusPoint, hitElementItself } from "../collision";
-import { moveArrowAboveBindable } from "../zindex";
-
-import type {
-  ElementsMap,
-  ExcalidrawArrowElement,
-  ExcalidrawBindableElement,
-  NonDeletedSceneElementsMap,
-  PointsPositionUpdates,
-} from "../types";
-
-import type { Scene } from "../Scene";
-
-export const isFocusPointVisible = (
-  focusPoint: GlobalPoint,
-  arrow: ExcalidrawArrowElement,
-  bindableElement: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-  appState: {
-    isBindingEnabled: AppState["isBindingEnabled"];
-    zoom: AppState["zoom"];
-  },
-  startOrEnd: "start" | "end",
-  ignoreOverlap = false,
-): boolean => {
-  // No focus point management for elbow arrows, because elbow arrows
-  // always have their focus point at the arrow point itself
-  if (
-    isElbowArrow(arrow) ||
-    !isBindingEnabled(appState) ||
-    arrow.points.length !== 2
-  ) {
-    return false;
-  }
-
-  // Avoid showing the focus point indicator if the focus point is essentially
-  // on top of the arrow point it belongs to itself, if not ignoring specifically
-  if (!ignoreOverlap) {
-    const associatedPointIdx =
-      arrow.startBinding?.elementId === bindableElement.id
-        ? 0
-        : arrow.points.length - 1;
-    const associatedArrowPoint =
-      LinearElementEditor.getPointAtIndexGlobalCoordinates(
-        arrow,
-        associatedPointIdx,
-        elementsMap,
-      );
-
-    if (
-      pointDistance(focusPoint, associatedArrowPoint) <
-      (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value
-    ) {
-      return false;
-    }
-  }
-
-  const arrowPoint = LinearElementEditor.getPointAtIndexGlobalCoordinates(
-    arrow,
-    startOrEnd === "end" ? arrow.points.length - 1 : 0,
-    elementsMap,
-  );
-
-  // Check if the focus point is within the element's shape bounds
-  // Endpoint dragging takes precedence
-  return (
-    pointDistance(focusPoint, arrowPoint) >=
-      (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value &&
-    hitElementItself({
-      element: bindableElement,
-      elementsMap,
-      point: focusPoint,
-      threshold: getBindingGap(bindableElement, arrow),
-      overrideShouldTestInside: true,
-    })
-  );
-};
-
-// Updates the arrow endpoints in "orbit" configuration
-const focusPointUpdate = (
-  arrow: ExcalidrawArrowElement,
-  bindableElement: ExcalidrawBindableElement | null,
-  isStartBinding: boolean,
-  elementsMap: NonDeletedSceneElementsMap,
-  scene: Scene,
-  appState: AppState,
-  switchToInsideBinding: boolean,
-) => {
-  const pointUpdates = new Map();
-
-  const bindingField = isStartBinding ? "startBinding" : "endBinding";
-  const adjacentBindingField = isStartBinding ? "endBinding" : "startBinding";
-  let currentBinding = arrow[bindingField];
-  let adjacentBinding = arrow[adjacentBindingField];
-
-  // Update the dragged focus point related end
-  if (currentBinding && bindableElement) {
-    // Update the targeted bindings
-    const boundToSameElement =
-      bindableElement &&
-      adjacentBinding &&
-      currentBinding.elementId === adjacentBinding.elementId;
-    if (switchToInsideBinding || boundToSameElement) {
-      currentBinding = {
-        ...currentBinding,
-        mode: "inside",
-      };
-    } else {
-      currentBinding = {
-        ...currentBinding,
-        mode: "orbit",
-      };
-    }
-
-    const pointIndex = isStartBinding ? 0 : arrow.points.length - 1;
-    const newPoint = updateBoundPoint(
-      arrow,
-      bindingField as "startBinding" | "endBinding",
-      currentBinding,
-      bindableElement,
-      elementsMap,
-      true,
-    );
-
-    if (newPoint) {
-      pointUpdates.set(pointIndex, { point: newPoint });
-    }
-  }
-
-  // Also update the adjacent end if it has a binding
-  if (adjacentBinding && adjacentBinding.mode === "orbit") {
-    const adjacentBindableElement = elementsMap.get(
-      adjacentBinding.elementId,
-    ) as ExcalidrawBindableElement;
-
-    if (
-      adjacentBindableElement &&
-      isBindableElement(adjacentBindableElement) &&
-      isBindingEnabled(appState)
-    ) {
-      // Same shape bound on both ends
-      const boundToSameElementAfterUpdate =
-        bindableElement && adjacentBinding.elementId === bindableElement.id;
-      if (switchToInsideBinding || boundToSameElementAfterUpdate) {
-        adjacentBinding = {
-          ...adjacentBinding,
-          mode: "inside",
-        };
-      } else {
-        adjacentBinding = {
-          ...adjacentBinding,
-          mode: "orbit",
-        };
-      }
-
-      const adjacentPointIndex = isStartBinding ? arrow.points.length - 1 : 0;
-      const adjacentNewPoint = updateBoundPoint(
-        arrow,
-        adjacentBindingField,
-        adjacentBinding,
-        adjacentBindableElement,
-        elementsMap,
-      );
-
-      if (adjacentNewPoint) {
-        pointUpdates.set(adjacentPointIndex, {
-          point: adjacentNewPoint,
-        });
-      }
-    }
-  }
-
-  if (pointUpdates.size > 0) {
-    LinearElementEditor.movePoints(arrow, scene, pointUpdates, {
-      [bindingField]: currentBinding,
-      [adjacentBindingField]: adjacentBinding,
-    });
-  }
-};
-
-export const handleFocusPointDrag = (
-  linearElementEditor: LinearElementEditor,
-  elementsMap: NonDeletedSceneElementsMap,
-  pointerCoords: { x: number; y: number },
-  scene: Scene,
-  appState: AppState,
-  gridSize: NullableGridSize,
-  switchToInsideBinding: boolean,
-) => {
-  const arrow = LinearElementEditor.getElement(
-    linearElementEditor.elementId,
-    elementsMap,
-  ) as any;
-
-  // Sanity checks
-  if (
-    !arrow ||
-    !isBindingElement(arrow) ||
-    isElbowArrow(arrow) ||
-    !linearElementEditor.hoveredFocusPointBinding ||
-    !linearElementEditor.draggedFocusPointBinding
-  ) {
-    return;
-  }
-
-  const isStartBinding =
-    linearElementEditor.draggedFocusPointBinding === "start";
-  const binding = isStartBinding ? arrow.startBinding : arrow.endBinding;
-  const { x: offsetX, y: offsetY } = linearElementEditor.pointerOffset;
-  const point = pointFrom<GlobalPoint>(
-    pointerCoords.x - offsetX,
-    pointerCoords.y - offsetY,
-  );
-  const bindingField = isStartBinding ? "startBinding" : "endBinding";
-  const hit = getHoveredElementForFocusPoint(
-    point,
-    arrow,
-    scene.getNonDeletedElements(),
-    elementsMap,
-    maxBindingDistance_simple(appState.zoom),
-  );
-
-  // Hovering a bindable element
-  if (hit && isBindingEnabled(appState)) {
-    // Break existing binding if bound to another shape or if binding is disabled
-    if (arrow[bindingField] && hit.id !== binding?.elementId) {
-      unbindBindingElement(
-        arrow,
-        linearElementEditor.draggedFocusPointBinding,
-        scene,
-      );
-    }
-
-    // Handle binding mode switch
-    const newMode =
-      switchToInsideBinding && arrow[bindingField]?.mode === "orbit"
-        ? "inside"
-        : !switchToInsideBinding && arrow[bindingField]?.mode === "inside"
-        ? "orbit"
-        : null;
-
-    // If no existing binding, create it
-    if (!arrow[bindingField] || newMode) {
-      // Create a new binding if none exists
-      bindBindingElement(
-        arrow,
-        hit,
-        newMode || "orbit",
-        linearElementEditor.draggedFocusPointBinding,
-        scene,
-        point,
-      );
-    }
-
-    // Update the binding's fixed point
-    scene.mutateElement(arrow, {
-      [bindingField]: {
-        ...arrow[bindingField],
-        elementId: hit.id,
-        mode: newMode || arrow[bindingField]?.mode || "orbit",
-        ...calculateFixedPointForNonElbowArrowBinding(
-          arrow,
-          hit,
-          linearElementEditor.draggedFocusPointBinding,
-          elementsMap,
-          point,
-        ),
-      },
-    });
-  } else {
-    // Not hovering any bindable element, move the arrow endpoint
-    const pointUpdates: PointsPositionUpdates = new Map();
-    const pointIndex = isStartBinding ? 0 : arrow.points.length - 1;
-    pointUpdates.set(pointIndex, {
-      point: LinearElementEditor.createPointAt(
-        arrow,
-        elementsMap,
-        point[0],
-        point[1],
-        gridSize,
-      ),
-    });
-    LinearElementEditor.movePoints(arrow, scene, pointUpdates);
-    if (arrow[bindingField]) {
-      unbindBindingElement(arrow, isStartBinding ? "start" : "end", scene);
-    }
-  }
-
-  // Update the arrow endpoints
-  focusPointUpdate(
-    arrow,
-    hit,
-    isStartBinding,
-    elementsMap,
-    scene,
-    appState,
-    switchToInsideBinding,
-  );
-
-  if (hit && isBindingEnabled(appState)) {
-    moveArrowAboveBindable(
-      point,
-      arrow,
-      scene.getElementsIncludingDeleted(),
-      elementsMap,
-      scene,
-      hit,
-    );
-  }
-};
-
-export const handleFocusPointPointerDown = (
-  arrow: ExcalidrawArrowElement,
-  pointerDownState: { origin: { x: number; y: number } },
-  elementsMap: NonDeletedSceneElementsMap,
-  appState: AppState,
-): {
-  hitFocusPoint: "start" | "end" | null;
-  pointerOffset: { x: number; y: number };
-} => {
-  const pointerPos = pointFrom(
-    pointerDownState.origin.x,
-    pointerDownState.origin.y,
-  );
-  const hitThreshold = (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value;
-
-  // Check start binding focus point
-  if (arrow.startBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.startBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.startBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "start",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return {
-          hitFocusPoint: "start",
-          pointerOffset: {
-            x: pointerPos[0] - focusPoint[0],
-            y: pointerPos[1] - focusPoint[1],
-          },
-        };
-      }
-    }
-  }
-
-  // Check end binding focus point (only if start not already hit)
-  if (arrow.endBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.endBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.endBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "end",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return {
-          hitFocusPoint: "end",
-          pointerOffset: {
-            x: pointerPos[0] - focusPoint[0],
-            y: pointerPos[1] - focusPoint[1],
-          },
-        };
-      }
-    }
-  }
-
-  return {
-    hitFocusPoint: null,
-    pointerOffset: { x: 0, y: 0 },
-  };
-};
-
-export const handleFocusPointPointerUp = (
-  linearElementEditor: LinearElementEditor,
-  scene: Scene,
-) => {
-  invariant(
-    linearElementEditor.draggedFocusPointBinding,
-    "Must have a dragged focus point at pointer release",
-  );
-
-  const arrow = LinearElementEditor.getElement<ExcalidrawArrowElement>(
-    linearElementEditor.elementId,
-    scene.getNonDeletedElementsMap(),
-  );
-  invariant(arrow, "Arrow must be in the scene");
-
-  // Clean up
-  const bindingKey =
-    linearElementEditor.draggedFocusPointBinding === "start"
-      ? "startBinding"
-      : "endBinding";
-  const otherBindingKey =
-    linearElementEditor.draggedFocusPointBinding === "start"
-      ? "endBinding"
-      : "startBinding";
-  const boundElementId = arrow[bindingKey]?.elementId;
-  const otherBoundElementId = arrow[otherBindingKey]?.elementId;
-  const oldBoundElement =
-    boundElementId &&
-    scene
-      .getNonDeletedElements()
-      .find(
-        (element) =>
-          element.id !== boundElementId &&
-          element.id !== otherBoundElementId &&
-          isBindableElement(element) &&
-          element.boundElements?.find(({ id }) => id === arrow.id),
-      );
-  if (oldBoundElement) {
-    scene.mutateElement(oldBoundElement, {
-      boundElements: oldBoundElement.boundElements?.filter(
-        ({ id }) => id !== arrow.id,
-      ),
-    });
-  }
-
-  // Record the new bound element
-  const boundElement =
-    boundElementId && scene.getNonDeletedElementsMap().get(boundElementId);
-  if (boundElement) {
-    scene.mutateElement(boundElement, {
-      boundElements: [
-        ...(boundElement.boundElements || [])?.filter(
-          ({ id }) => id !== arrow.id,
-        ),
-        {
-          id: arrow.id,
-          type: "arrow",
-        },
-      ],
-    });
-  }
-};
-
-export const handleFocusPointHover = (
-  arrow: ExcalidrawArrowElement,
-  scenePointerX: number,
-  scenePointerY: number,
-  scene: Scene,
-  appState: AppState,
-): "start" | "end" | null => {
-  const elementsMap = scene.getNonDeletedElementsMap();
-  const pointerPos = pointFrom(scenePointerX, scenePointerY);
-  const hitThreshold = (FOCUS_POINT_SIZE * 1.5) / appState.zoom.value;
-
-  // Check start binding focus point
-  if (arrow.startBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.startBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.startBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "start",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return "start";
-      }
-    }
-  }
-
-  // Check end binding focus point (only if start not already hovered)
-  if (arrow.endBinding?.elementId) {
-    const bindableElement = elementsMap.get(arrow.endBinding.elementId);
-    if (
-      bindableElement &&
-      isBindableElement(bindableElement) &&
-      !bindableElement.isDeleted
-    ) {
-      const focusPoint = getGlobalFixedPointForBindableElement(
-        arrow.endBinding.fixedPoint,
-        bindableElement,
-        elementsMap,
-      );
-      if (
-        isFocusPointVisible(
-          focusPoint,
-          arrow,
-          bindableElement,
-          elementsMap,
-          appState,
-          "end",
-        ) &&
-        pointDistance(pointerPos, focusPoint) <= hitThreshold
-      ) {
-        return "end";
-      }
-    }
-  }
-
-  return null;
-};

packages/element/src/arrows/helpers.ts

@@ -1,45 +0,0 @@
-import type { App } from "@excalidraw/excalidraw/types";
-
-import { LinearElementEditor } from "../linearElementEditor";
-
-import { handleFocusPointDrag } from "./focus";
-
-export const maybeHandleArrowPointlikeDrag = ({
-  app,
-  event,
-}: {
-  app: App;
-  event: KeyboardEvent | React.KeyboardEvent<Element> | PointerEvent;
-}): boolean => {
-  const appState = app.state;
-  if (appState.selectedLinearElement && app.lastPointerMoveCoords) {
-    // Update focus point status if the binding mode is changing
-    if (appState.selectedLinearElement.draggedFocusPointBinding) {
-      handleFocusPointDrag(
-        appState.selectedLinearElement,
-        app.scene.getNonDeletedElementsMap(),
-        app.lastPointerMoveCoords,
-        app.scene,
-        appState,
-        app.getEffectiveGridSize(),
-        event.altKey,
-      );
-      return true;
-    } else if (
-      appState.selectedLinearElement.hoverPointIndex !== null &&
-      app.lastPointerMoveEvent &&
-      appState.selectedLinearElement.initialState.lastClickedPoint >= 0 &&
-      appState.selectedLinearElement.isDragging
-    ) {
-      LinearElementEditor.handlePointDragging(
-        app.lastPointerMoveEvent,
-        app,
-        app.lastPointerMoveCoords.x,
-        app.lastPointerMoveCoords.y,
-        appState.selectedLinearElement,
-      );
-      return true;
-    }
-  }
-  return false;
-};

packages/element/src/bounds.ts

@@ -1,11 +1,12 @@
 import rough from "roughjs/bin/rough";
+
 import {
   arrayToMap,
-  type Bounds,
   invariant,
   rescalePoints,
   sizeOf,
 } from "@excalidraw/common";
+
 import {
   degreesToRadians,
   lineSegment,
@@ -14,7 +15,9 @@ import {
   pointFromArray,
   pointRotateRads,
 } from "@excalidraw/math";
+
 import { getCurvePathOps } from "@excalidraw/utils/shape";
+
 import { pointsOnBezierCurves } from "points-on-curve";
 
 import type {
@@ -25,7 +28,9 @@ import type {
   LocalPoint,
   Radians,
 } from "@excalidraw/math";
+
 import type { AppState } from "@excalidraw/excalidraw/types";
+
 import type { Mutable } from "@excalidraw/common/utility-types";
 
 import { generateRoughOptions } from "./shape";
@@ -35,20 +40,18 @@ import { getBoundTextElement, getContainerElement } from "./textElement";
 import {
   isArrowElement,
   isBoundToContainer,
-  isFrameLikeElement,
   isFreeDrawElement,
   isLinearElement,
   isLineElement,
   isTextElement,
-  isExcalidrawElement,
 } from "./typeChecks";
+
 import { getElementShape } from "./shape";
+
 import {
   deconstructDiamondElement,
   deconstructRectanguloidElement,
 } from "./utils";
-import { intersectElementWithLineSegment } from "./collision";
-import { elementOverlapsWithFrame, getContainingFrame } from "./frame";
 
 import type { Drawable, Op } from "roughjs/bin/core";
 import type { Point as RoughPoint } from "roughjs/bin/geometry";
@@ -63,7 +66,6 @@ import type {
   ExcalidrawRectanguloidElement,
   ExcalidrawTextElementWithContainer,
   NonDeleted,
-  NonDeletedExcalidrawElement,
 } from "./types";
 
 export type RectangleBox = {
@@ -76,6 +78,16 @@ export type RectangleBox = {
 
 type MaybeQuadraticSolution = [number | null, number | null] | false;
 
+/**
+ * x and y position of top left corner, x and y position of bottom right corner
+ */
+export type Bounds = readonly [
+  minX: number,
+  minY: number,
+  maxX: number,
+  maxY: number,
+];
+
 export type SceneBounds = readonly [
   sceneX: number,
   sceneY: number,
@@ -677,9 +689,8 @@ export const getMinMaxXYFromCurvePathOps = (
   return [minX, minY, maxX, maxY];
 };
 
-export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
-  points: readonly P[],
-  padding: number = 0,
+export const getBoundsFromPoints = (
+  points: ExcalidrawFreeDrawElement["points"],
 ): Bounds => {
   let minX = Infinity;
   let minY = Infinity;
@@ -693,7 +704,7 @@ export const getBoundsFromPoints = <P extends GlobalPoint | LocalPoint>(
     maxY = Math.max(maxY, y);
   }
 
-  return [minX - padding, minY - padding, maxX + padding, maxY + padding];
+  return [minX, minY, maxX, maxY];
 };
 
 const getFreeDrawElementAbsoluteCoords = (
@@ -707,9 +718,6 @@ const getFreeDrawElementAbsoluteCoords = (
   return [x1, y1, x2, y2, (x1 + x2) / 2, (y1 + y2) / 2];
 };
 
-const CARDINALITY_MARKER_SIZE = 20;
-const CROWFOOT_ARROWHEAD_SIZE = 15;
-
 /** @returns number in pixels */
 export const getArrowheadSize = (arrowhead: Arrowhead): number => {
   switch (arrowhead) {
@@ -718,14 +726,10 @@ export const getArrowheadSize = (arrowhead: Arrowhead): number => {
     case "diamond":
     case "diamond_outline":
       return 12;
-    case "cardinality_many":
-    case "cardinality_one_or_many":
-    case "cardinality_zero_or_many":
-      return CROWFOOT_ARROWHEAD_SIZE;
-    case "cardinality_one":
-    case "cardinality_exactly_one":
-    case "cardinality_zero_or_one":
-      return CARDINALITY_MARKER_SIZE;
+    case "crowfoot_many":
+    case "crowfoot_one":
+    case "crowfoot_one_or_many":
+      return 20;
     default:
       return 15;
   }
@@ -748,12 +752,7 @@ export const getArrowheadPoints = (
   shape: Drawable[],
   position: "start" | "end",
   arrowhead: Arrowhead,
-  offsetMultiplier = 0,
 ) => {
-  if (arrowhead === null) {
-    return null;
-  }
-
   if (shape.length < 1) {
     return null;
   }
@@ -834,30 +833,29 @@ export const getArrowheadPoints = (
   const lengthMultiplier =
     arrowhead === "diamond" || arrowhead === "diamond_outline" ? 0.25 : 0.5;
   const minSize = Math.min(size, length * lengthMultiplier);
-  const tx = x2 - nx * minSize * offsetMultiplier;
-  const ty = y2 - ny * minSize * offsetMultiplier;
-  const xs = tx - nx * minSize;
-  const ys = ty - ny * minSize;
+  const xs = x2 - nx * minSize;
+  const ys = y2 - ny * minSize;
 
-  if (arrowhead === "circle" || arrowhead === "circle_outline") {
-    const diameter = Math.hypot(ys - ty, xs - tx) + element.strokeWidth - 2;
-    return [tx, ty, diameter];
+  if (
+    arrowhead === "dot" ||
+    arrowhead === "circle" ||
+    arrowhead === "circle_outline"
+  ) {
+    const diameter = Math.hypot(ys - y2, xs - x2) + element.strokeWidth - 2;
+    return [x2, y2, diameter];
   }
 
   const angle = getArrowheadAngle(arrowhead);
 
-  if (
-    arrowhead === "cardinality_many" ||
-    arrowhead === "cardinality_one_or_many"
-  ) {
+  if (arrowhead === "crowfoot_many" || arrowhead === "crowfoot_one_or_many") {
     // swap (xs, ys) with (x2, y2)
     const [x3, y3] = pointRotateRads(
-      pointFrom(tx, ty),
+      pointFrom(x2, y2),
       pointFrom(xs, ys),
       degreesToRadians(-angle as Degrees),
     );
     const [x4, y4] = pointRotateRads(
-      pointFrom(tx, ty),
+      pointFrom(x2, y2),
       pointFrom(xs, ys),
       degreesToRadians(angle),
     );
@@ -867,12 +865,12 @@ export const getArrowheadPoints = (
   // Return points
   const [x3, y3] = pointRotateRads(
     pointFrom(xs, ys),
-    pointFrom(tx, ty),
+    pointFrom(x2, y2),
     ((-angle * Math.PI) / 180) as Radians,
   );
   const [x4, y4] = pointRotateRads(
     pointFrom(xs, ys),
-    pointFrom(tx, ty),
+    pointFrom(x2, y2),
     degreesToRadians(angle),
   );
 
@@ -885,9 +883,9 @@ export const getArrowheadPoints = (
       const [px, py] = element.points.length > 1 ? element.points[1] : [0, 0];
 
       [ox, oy] = pointRotateRads(
-        pointFrom(tx + minSize * 2, ty),
-        pointFrom(tx, ty),
-        Math.atan2(py - ty, px - tx) as Radians,
+        pointFrom(x2 + minSize * 2, y2),
+        pointFrom(x2, y2),
+        Math.atan2(py - y2, px - x2) as Radians,
       );
     } else {
       const [px, py] =
@@ -896,19 +894,18 @@ export const getArrowheadPoints = (
           : [0, 0];
 
       [ox, oy] = pointRotateRads(
-        pointFrom(tx - minSize * 2, ty),
-        pointFrom(tx, ty),
-        Math.atan2(ty - py, tx - px) as Radians,
+        pointFrom(x2 - minSize * 2, y2),
+        pointFrom(x2, y2),
+        Math.atan2(y2 - py, x2 - px) as Radians,
       );
     }
 
-    return [tx, ty, x3, y3, ox, oy, x4, y4];
+    return [x2, y2, x3, y3, ox, oy, x4, y4];
   }
 
-  return [tx, ty, x3, y3, x4, y4];
+  return [x2, y2, x3, y3, x4, y4];
 };
 
-// TODO reuse shape.ts
 const generateLinearElementShape = (
   element: ExcalidrawLinearElement,
 ): Drawable => {
@@ -966,7 +963,7 @@ const getLinearElementRotatedBounds = (
   }
 
   // first element is always the curve
-  const cachedShape = ShapeCache.get(element, null)?.[0];
+  const cachedShape = ShapeCache.get(element)?.[0];
   const shape = cachedShape ?? generateLinearElementShape(element);
   const ops = getCurvePathOps(shape);
   const transformXY = ([x, y]: GlobalPoint) =>
@@ -1259,17 +1256,6 @@ export const pointInsideBounds = <P extends GlobalPoint | LocalPoint>(
 ): boolean =>
   p[0] > bounds[0] && p[0] < bounds[2] && p[1] > bounds[1] && p[1] < bounds[3];
 
-// TODO make pointInsideBounds inclusive and remove this function once we
-// test nothing is breaking
-export const pointInsideBoundsInclusive = <P extends GlobalPoint | LocalPoint>(
-  p: P,
-  bounds: Bounds,
-): boolean =>
-  p[0] >= bounds[0] &&
-  p[0] <= bounds[2] &&
-  p[1] >= bounds[1] &&
-  p[1] <= bounds[3];
-
 export const doBoundsIntersect = (
   bounds1: Bounds | null,
   bounds2: Bounds | null,
@@ -1284,310 +1270,13 @@ export const doBoundsIntersect = (
   return minX1 < maxX2 && maxX1 > minX2 && minY1 < maxY2 && maxY1 > minY2;
 };
 
-export const boundsContainBounds = (outerBounds: Bounds, innerBounds: Bounds) =>
-  [
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[0], innerBounds[3]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[1]),
-    pointFrom<GlobalPoint>(innerBounds[2], innerBounds[3]),
-  ].every((point) => pointInsideBoundsInclusive(point, outerBounds));
-
-/**
- * High level helper to get elements overlapping a bounding box.
- * It can be used to get elements overlapping a selection box, for example.
- *
- */
-export const elementsOverlappingBBox = ({
-  elements,
-  elementsMap,
-  bounds,
-  type,
-  excludeElementsInFrames,
-  shouldIgnoreElementFromSelection,
-}: {
-  elements: readonly NonDeletedExcalidrawElement[];
-  elementsMap?: ElementsMap;
-  bounds: Bounds | ExcalidrawElement;
-  /**
-   * - overlap: elements overlapping or inside bounds
-   * - contain: elements inside bounds
-   **/
-  type: "contain" | "overlap";
-  excludeElementsInFrames?: boolean;
-  shouldIgnoreElementFromSelection?: (
-    element: NonDeletedExcalidrawElement,
-  ) => boolean;
-}) => {
-  if (!elementsMap) {
-    elementsMap = arrayToMap(elements) as ElementsMap;
-  }
-  const selectionBounds = isExcalidrawElement(bounds)
-    ? getElementBounds(bounds, elementsMap)
-    : bounds;
-  const [selectionX1, selectionY1, selectionX2, selectionY2] = selectionBounds;
-  const selectionEdges = [
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY1),
-      pointFrom(selectionX2, selectionY1),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY1),
-      pointFrom(selectionX2, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX2, selectionY2),
-      pointFrom(selectionX1, selectionY2),
-    ),
-    lineSegment<GlobalPoint>(
-      pointFrom(selectionX1, selectionY2),
-      pointFrom(selectionX1, selectionY1),
-    ),
-  ];
-
-  const framesInSelection = excludeElementsInFrames
-    ? new Set<NonDeletedExcalidrawElement["id"]>()
-    : null;
-  const groups: Record<string, NonDeletedExcalidrawElement[]> = {};
-  const elementsInSelection: Set<NonDeletedExcalidrawElement> = new Set();
-
-  for (const element of elements) {
-    if (shouldIgnoreElementFromSelection?.(element)) {
-      continue;
-    }
-
-    // Track only selectable top-level group members, so ignored elements such
-    // as bound text and locked elements don't affect group selection.
-    const groupId = element.groupIds.at(-1);
-    if (groupId) {
-      if (!groups[groupId]) {
-        groups[groupId] = [];
-      }
-      groups[groupId].push(element);
-    }
-
-    const strokeWidth = element.strokeWidth;
-    let labelAABB: Bounds | null = null;
-    let elementAABB = getElementBounds(element, elementsMap);
-
-    elementAABB = [
-      elementAABB[0] - strokeWidth / 2,
-      elementAABB[1] - strokeWidth / 2,
-      elementAABB[2] + strokeWidth / 2,
-      elementAABB[3] + strokeWidth / 2,
-    ] as Bounds;
-
-    // Whether the element bounds should include the bound text element bounds
-    const boundTextElement =
-      isArrowElement(element) && getBoundTextElement(element, elementsMap);
-    if (boundTextElement) {
-      const { x, y } = LinearElementEditor.getBoundTextElementPosition(
-        element,
-        boundTextElement,
-        elementsMap,
-      );
-      labelAABB = [
-        x,
-        y,
-        x + boundTextElement.width,
-        y + boundTextElement.height,
-      ] as Bounds;
-    }
-
-    // Clip element bounds by its containing frame (if any), since only the
-    // visible (frame-clipped) portion of the element is relevant for selection.
-    const associatedFrame = getContainingFrame(element, elementsMap);
-    if (
-      associatedFrame &&
-      elementOverlapsWithFrame(element, associatedFrame, elementsMap)
-    ) {
-      const frameAABB = getElementBounds(associatedFrame, elementsMap);
-      elementAABB = [
-        Math.max(elementAABB[0], frameAABB[0]),
-        Math.max(elementAABB[1], frameAABB[1]),
-        Math.min(elementAABB[2], frameAABB[2]),
-        Math.min(elementAABB[3], frameAABB[3]),
-      ] as Bounds;
-
-      labelAABB = labelAABB
-        ? ([
-            Math.max(labelAABB[0], frameAABB[0]),
-            Math.max(labelAABB[1], frameAABB[1]),
-            Math.min(labelAABB[2], frameAABB[2]),
-            Math.min(labelAABB[3], frameAABB[3]),
-          ] as Bounds)
-        : null;
-    }
-
-    const commonAABB = labelAABB
-      ? ([
-          Math.min(labelAABB[0], elementAABB[0]),
-          Math.min(labelAABB[1], elementAABB[1]),
-          Math.max(labelAABB[2], elementAABB[2]),
-          Math.max(labelAABB[3], elementAABB[3]),
-        ] as Bounds)
-      : elementAABB;
-
-    // ============== Evaluation ==============
-
-    // 1. If the selection box WRAPs the element's AABB, then add it to the
-    //    selection and move on, regardless of the selection mode.
-    //
-    //    PERF: This trick only works with axis-aligned box selection and the
-    //          current convex element shapes!
-    if (boundsContainBounds(selectionBounds, commonAABB)) {
-      if (framesInSelection && isFrameLikeElement(element)) {
-        framesInSelection.add(element.id);
-      }
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 2. Handle the case where the label is overlapped by the selection box
-    if (
-      type === "overlap" &&
-      labelAABB &&
-      doBoundsIntersect(selectionBounds, labelAABB)
-    ) {
-      elementsInSelection.add(element);
-      continue;
-    }
-
-    // 3. Handle the case where the selection is not wrapping the element, but
-    //    it does intersect the element's outline (non-AABB).
-    if (type === "overlap" && doBoundsIntersect(selectionBounds, elementAABB)) {
-      let hasIntersection = false;
-
-      // Preliminary check potential intersection imprecision
-      if (isLinearElement(element) || isFreeDrawElement(element)) {
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = element.points.some((point) => {
-          const rotatedPoint = pointRotateRads(
-            pointFrom<GlobalPoint>(element.x + point[0], element.y + point[1]),
-            center,
-            element.angle,
-          );
-
-          return pointInsideBounds(rotatedPoint, selectionBounds);
-        });
-      } else {
-        const nonRotatedElementBounds = getElementBounds(
-          element,
-          elementsMap,
-          true,
-        );
-        const center = elementCenterPoint(element, elementsMap);
-        hasIntersection = [
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[1],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[2],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              (nonRotatedElementBounds[0] + nonRotatedElementBounds[2]) / 2,
-              nonRotatedElementBounds[3],
-            ),
-            center,
-            element.angle,
-          ),
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              nonRotatedElementBounds[0],
-              (nonRotatedElementBounds[1] + nonRotatedElementBounds[3]) / 2,
-            ),
-            center,
-            element.angle,
-          ),
-        ].some((point) => {
-          return pointInsideBounds(
-            pointRotateRads(point, center, element.angle),
-            selectionBounds,
-          );
-        });
-      }
-
-      if (!hasIntersection) {
-        hasIntersection = selectionEdges.some(
-          (selectionEdge) =>
-            intersectElementWithLineSegment(
-              element,
-              elementsMap,
-              selectionEdge,
-              strokeWidth / 2,
-              true, // Stop at first hit for better performance
-            ).length > 0,
-        );
-      }
-
-      if (hasIntersection) {
-        if (framesInSelection && isFrameLikeElement(element)) {
-          framesInSelection.add(element.id);
-        }
-
-        elementsInSelection.add(element);
-        continue;
-      }
-    }
-
-    // 4. We don't need to handle when the selection is inside the element
-    //    as it is separately handled in App.
-  }
-
-  if (framesInSelection) {
-    elementsInSelection.forEach((element) => {
-      if (element.frameId && framesInSelection.has(element.frameId)) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  if (type === "overlap") {
-    Array.from(elementsInSelection).forEach((element) => {
-      const groupId = element.groupIds.at(-1);
-      const group = groupId ? groups[groupId] : null;
-
-      group?.forEach((groupElement) => elementsInSelection.add(groupElement));
-    });
-  } else if (type === "contain") {
-    elementsInSelection.forEach((element) => {
-      // note: currently we only support top-level group handling since
-      // we don't support box selecting while editing the group/subgroup
-      // see https://github.com/excalidraw/excalidraw/pull/11234#issuecomment-4387654451
-      const groupId = element.groupIds.at(-1);
-
-      const group = groupId ? groups[groupId] : null;
-
-      if (
-        group &&
-        !group.every((groupElement) => elementsInSelection.has(groupElement))
-      ) {
-        elementsInSelection.delete(element);
-      }
-    });
-  }
-
-  // to maintain original order elements (namely for group selection)
-  return elements.filter((element) => elementsInSelection.has(element));
-};
-
 export const elementCenterPoint = (
   element: ExcalidrawElement,
   elementsMap: ElementsMap,
   xOffset: number = 0,
   yOffset: number = 0,
 ) => {
-  if (isLinearElement(element) || isFreeDrawElement(element)) {
+  if (isLinearElement(element)) {
     const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
     const [x, y] = pointFrom<GlobalPoint>((x1 + x2) / 2, (y1 + y2) / 2);
 

packages/element/src/collision.ts

@@ -1,4 +1,4 @@
-import { invariant, isTransparent, type Bounds } from "@excalidraw/common";
+import { invariant, isTransparent } from "@excalidraw/common";
 import {
   curveIntersectLineSegment,
   isPointWithinBounds,
@@ -29,6 +29,7 @@ import type { FrameNameBounds } from "@excalidraw/excalidraw/types";
 
 import { isPathALoop } from "./utils";
 import {
+  type Bounds,
   doBoundsIntersect,
   elementCenterPoint,
   getCenterForBounds,
@@ -59,13 +60,8 @@ import { LinearElementEditor } from "./linearElementEditor";
 
 import { distanceToElement } from "./distance";
 
-import { getBindingGap } from "./binding";
-
-import { hasBackground } from "./comparisons";
-
 import type {
   ElementsMap,
-  ExcalidrawArrowElement,
   ExcalidrawBindableElement,
   ExcalidrawDiamondElement,
   ExcalidrawElement,
@@ -85,7 +81,7 @@ export const shouldTestInside = (element: ExcalidrawElement) => {
   }
 
   const isDraggableFromInside =
-    (hasBackground(element.type) && !isTransparent(element.backgroundColor)) ||
+    !isTransparent(element.backgroundColor) ||
     hasBoundTextElement(element) ||
     isIframeLikeElement(element) ||
     isTextElement(element);
@@ -110,12 +106,6 @@ export type HitTestArgs = {
   overrideShouldTestInside?: boolean;
 };
 
-let cachedPoint: GlobalPoint | null = null;
-let cachedElement: WeakRef<ExcalidrawElement> | null = null;
-let cachedThreshold: number = Infinity;
-let cachedHit: boolean = false;
-let cachedOverrideShouldTestInside = false;
-
 export const hitElementItself = ({
   point,
   element,
@@ -124,24 +114,6 @@ export const hitElementItself = ({
   frameNameBound = null,
   overrideShouldTestInside = false,
 }: HitTestArgs) => {
-  // Return cached result if the same point and element version is tested again
-  if (
-    cachedPoint &&
-    pointsEqual(point, cachedPoint) &&
-    cachedThreshold <= threshold &&
-    overrideShouldTestInside === cachedOverrideShouldTestInside
-  ) {
-    const derefElement = cachedElement?.deref();
-    if (
-      derefElement &&
-      derefElement.id === element.id &&
-      derefElement.version === element.version &&
-      derefElement.versionNonce === element.versionNonce
-    ) {
-      return cachedHit;
-    }
-  }
-
   // Hit test against a frame's name
   const hitFrameName = frameNameBound
     ? isPointWithinBounds(
@@ -156,11 +128,14 @@ export const hitElementItself = ({
 
   // Hit test against the extended, rotated bounding box of the element first
   const bounds = getElementBounds(element, elementsMap, true);
-  const hitBounds = isPointInRotatedBounds(
-    point,
-    bounds,
-    element.angle,
-    threshold,
+  const hitBounds = isPointWithinBounds(
+    pointFrom(bounds[0] - threshold, bounds[1] - threshold),
+    pointRotateRads(
+      point,
+      getCenterForBounds(bounds),
+      -element.angle as Radians,
+    ),
+    pointFrom(bounds[2] + threshold, bounds[3] + threshold),
   );
 
   // PERF: Bail out early if the point is not even in the
@@ -179,34 +154,7 @@ export const hitElementItself = ({
       isPointOnElementOutline(point, element, elementsMap, threshold)
     : isPointOnElementOutline(point, element, elementsMap, threshold);
 
-  const result = hitElement || hitFrameName;
-
-  // Cache end result
-  cachedPoint = point;
-  cachedElement = new WeakRef(element);
-  cachedThreshold = threshold;
-  cachedOverrideShouldTestInside = overrideShouldTestInside;
-  cachedHit = result;
-
-  return result;
-};
-
-const isPointInRotatedBounds = (
-  point: GlobalPoint,
-  bounds: Bounds,
-  angle: Radians,
-  tolerance = 0,
-) => {
-  const adjustedPoint =
-    angle === 0
-      ? point
-      : pointRotateRads(point, getCenterForBounds(bounds), -angle as Radians);
-
-  return isPointWithinBounds(
-    pointFrom(bounds[0] - tolerance, bounds[1] - tolerance),
-    adjustedPoint,
-    pointFrom(bounds[2] + tolerance, bounds[3] + tolerance),
-  );
+  return hitElement || hitFrameName;
 };
 
 export const hitElementBoundingBox = (
@@ -215,8 +163,12 @@ export const hitElementBoundingBox = (
   elementsMap: ElementsMap,
   tolerance = 0,
 ) => {
-  const bounds = getElementBounds(element, elementsMap, true);
-  return isPointInRotatedBounds(point, bounds, element.angle, tolerance);
+  let [x1, y1, x2, y2] = getElementBounds(element, elementsMap);
+  x1 -= tolerance;
+  y1 -= tolerance;
+  x2 += tolerance;
+  y2 += tolerance;
+  return isPointWithinBounds(pointFrom(x1, y1), point, pointFrom(x2, y2));
 };
 
 export const hitElementBoundingBoxOnly = (
@@ -306,7 +258,7 @@ export const getAllHoveredElementAtPoint = (
   point: Readonly<GlobalPoint>,
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
+  toleranceFn?: (element: ExcalidrawBindableElement) => number,
 ): NonDeleted<ExcalidrawBindableElement>[] => {
   const candidateElements: NonDeleted<ExcalidrawBindableElement>[] = [];
   // We need to to hit testing from front (end of the array) to back (beginning of the array)
@@ -322,14 +274,11 @@ export const getAllHoveredElementAtPoint = (
 
     if (
       isBindableElement(element, false) &&
-      bindingBorderTest(element, point, elementsMap, tolerance)
+      bindingBorderTest(element, point, elementsMap, toleranceFn?.(element))
     ) {
       candidateElements.push(element);
 
-      if (
-        hasBackground(element.type) &&
-        !isTransparent(element.backgroundColor)
-      ) {
+      if (!isTransparent(element.backgroundColor)) {
         break;
       }
     }
@@ -342,13 +291,13 @@ export const getHoveredElementForBinding = (
   point: Readonly<GlobalPoint>,
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
+  toleranceFn?: (element: ExcalidrawBindableElement) => number,
 ): NonDeleted<ExcalidrawBindableElement> | null => {
   const candidateElements = getAllHoveredElementAtPoint(
     point,
     elements,
     elementsMap,
-    tolerance,
+    toleranceFn,
   );
 
   if (!candidateElements || candidateElements.length === 0) {
@@ -367,56 +316,6 @@ export const getHoveredElementForBinding = (
     .pop() as NonDeleted<ExcalidrawBindableElement>;
 };
 
-export const getHoveredElementForFocusPoint = (
-  point: GlobalPoint,
-  arrow: ExcalidrawArrowElement,
-  elements: readonly Ordered<NonDeletedExcalidrawElement>[],
-  elementsMap: NonDeletedSceneElementsMap,
-  tolerance?: number,
-): ExcalidrawBindableElement | null => {
-  const candidateElements: NonDeleted<ExcalidrawBindableElement>[] = [];
-  // We need to to hit testing from front (end of the array) to back (beginning of the array)
-  // because array is ordered from lower z-index to highest and we want element z-index
-  // with higher z-index
-  for (let index = elements.length - 1; index >= 0; --index) {
-    const element = elements[index];
-
-    invariant(
-      !element.isDeleted,
-      "Elements in the function parameter for getAllElementsAtPositionForBinding() should not contain deleted elements",
-    );
-
-    if (
-      isBindableElement(element, false) &&
-      bindingBorderTest(element, point, elementsMap, tolerance)
-    ) {
-      candidateElements.push(element);
-    }
-  }
-
-  if (!candidateElements || candidateElements.length === 0) {
-    return null;
-  }
-
-  if (candidateElements.length === 1) {
-    return candidateElements[0];
-  }
-
-  const distanceFilteredCandidateElements = candidateElements
-    // Resolve by distance
-    .filter(
-      (el) =>
-        distanceToElement(el, elementsMap, point) <= getBindingGap(el, arrow) ||
-        isPointInElement(point, el, elementsMap),
-    );
-
-  if (distanceFilteredCandidateElements.length === 0) {
-    return null;
-  }
-
-  return distanceFilteredCandidateElements[0] as NonDeleted<ExcalidrawBindableElement>;
-};
-
 /**
  * Intersect a line with an element for binding test
  *
@@ -481,12 +380,7 @@ export const intersectElementWithLineSegment = (
     case "line":
     case "freedraw":
     case "arrow":
-      return intersectLinearOrFreeDrawWithLineSegment(
-        element,
-        line,
-        elementsMap,
-        onlyFirst,
-      );
+      return intersectLinearOrFreeDrawWithLineSegment(element, line, onlyFirst);
   }
 };
 
@@ -553,15 +447,11 @@ const lineIntersections = (
 const intersectLinearOrFreeDrawWithLineSegment = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
   segment: LineSegment<GlobalPoint>,
-  elementsMap: ElementsMap,
   onlyFirst = false,
 ): GlobalPoint[] => {
   // NOTE: This is the only one which return the decomposed elements
   // rotated! This is due to taking advantage of roughjs definitions.
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
   const intersections: GlobalPoint[] = [];
 
   for (const l of lines) {
@@ -589,9 +479,7 @@ const intersectLinearOrFreeDrawWithLineSegment = (
       continue;
     }
 
-    const hits = curveIntersectLineSegment(c, segment, {
-      iterLimit: 10,
-    });
+    const hits = curveIntersectLineSegment(c, segment);
 
     if (hits.length > 0) {
       intersections.push(...hits);

packages/element/src/comparisons.ts

@@ -16,8 +16,7 @@ export const hasStrokeColor = (type: ElementOrToolType) =>
   type === "freedraw" ||
   type === "arrow" ||
   type === "line" ||
-  type === "text" ||
-  type === "embeddable";
+  type === "text";
 
 export const hasStrokeWidth = (type: ElementOrToolType) =>
   type === "rectangle" ||
@@ -38,8 +37,6 @@ export const hasStrokeStyle = (type: ElementOrToolType) =>
   type === "arrow" ||
   type === "line";
 
-export const hasFreedrawMode = (type: ElementOrToolType) => type === "freedraw";
-
 export const canChangeRoundness = (type: ElementOrToolType) =>
   type === "rectangle" ||
   type === "iframe" ||

packages/element/src/distance.ts

@@ -48,7 +48,7 @@ export const distanceToElement = (
     case "line":
     case "arrow":
     case "freedraw":
-      return distanceToLinearOrFreeDraElement(element, elementsMap, p);
+      return distanceToLinearOrFreeDraElement(element, p);
   }
 };
 
@@ -133,13 +133,9 @@ const distanceToEllipseElement = (
 
 const distanceToLinearOrFreeDraElement = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
   p: GlobalPoint,
 ) => {
-  const [lines, curves] = deconstructLinearOrFreeDrawElement(
-    element,
-    elementsMap,
-  );
+  const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
   return Math.min(
     ...lines.map((s) => distanceToLineSegment(p, s)),
     ...curves.map((a) => curvePointDistance(a, p)),

packages/element/src/distribute.ts

@@ -1,12 +1,10 @@
 import type { AppState } from "@excalidraw/excalidraw/types";
 
-import { updateBoundElements } from "./binding";
 import { getCommonBoundingBox } from "./bounds";
+import { newElementWith } from "./mutateElement";
 
 import { getSelectedElementsByGroup } from "./groups";
 
-import type { Scene } from "./Scene";
-
 import type { ElementsMap, ExcalidrawElement } from "./types";
 
 export interface Distribution {
@@ -19,7 +17,6 @@ export const distributeElements = (
   elementsMap: ElementsMap,
   distribution: Distribution,
   appState: Readonly<AppState>,
-  scene: Scene,
 ): ExcalidrawElement[] => {
   const [start, mid, end, extent] =
     distribution.axis === "x"
@@ -69,16 +66,12 @@ export const distributeElements = (
         translation[distribution.axis] = pos - box[mid];
       }
 
-      return group.map((element) => {
-        const updatedElement = scene.mutateElement(element, {
+      return group.map((element) =>
+        newElementWith(element, {
           x: element.x + translation.x,
           y: element.y + translation.y,
-        });
-        updateBoundElements(element, scene, {
-          simultaneouslyUpdated: group,
-        });
-        return updatedElement;
-      });
+        }),
+      );
     });
   }
 
@@ -97,15 +90,11 @@ export const distributeElements = (
     pos += step;
     pos += box[extent];
 
-    return group.map((element) => {
-      const updatedElement = scene.mutateElement(element, {
+    return group.map((element) =>
+      newElementWith(element, {
         x: element.x + translation.x,
         y: element.y + translation.y,
-      });
-      updateBoundElements(element, scene, {
-        simultaneouslyUpdated: group,
-      });
-      return updatedElement;
-    });
+      }),
+    );
   });
 };

packages/element/src/dragElements.ts

@@ -1,5 +1,4 @@
 import {
-  type Bounds,
   TEXT_AUTOWRAP_THRESHOLD,
   getGridPoint,
   getFontString,
@@ -30,6 +29,7 @@ import {
 
 import type { Scene } from "./Scene";
 
+import type { Bounds } from "./bounds";
 import type { ExcalidrawElement } from "./types";
 
 export const dragSelectedElements = (

packages/element/src/duplicate.ts

@@ -111,9 +111,6 @@ export const duplicateElements = (
          * user interaction.
          */
         type: "everything";
-        // TODO remove/review this once we add frame children order migration
-        // and invariant checks
-        preserveFrameChildrenOrder?: boolean;
       }
     | {
         /**
@@ -173,8 +170,6 @@ export const duplicateElements = (
     opts.type === "in-place"
       ? opts.idsOfElementsToDuplicate
       : new Map(elements.map((el) => [el.id, el]));
-  const preserveFrameChildrenOrder =
-    opts.type === "everything" && opts.preserveFrameChildrenOrder;
 
   // For sanity
   if (opts.type === "in-place") {
@@ -255,9 +250,6 @@ export const duplicateElements = (
     elementsWithDuplicates.splice(index + 1, 0, ...castArray(elements));
   };
 
-  // main
-  // ---------------------------------------------------------------------------
-
   const frameIdsToDuplicate = new Set(
     elements
       .filter(
@@ -282,7 +274,7 @@ export const duplicateElements = (
     if (groupId) {
       const groupElements = getElementsInGroup(elements, groupId).flatMap(
         (element) =>
-          isFrameLikeElement(element) && !preserveFrameChildrenOrder
+          isFrameLikeElement(element)
             ? [...getFrameChildren(elements, element.id), element]
             : [element],
       );
@@ -298,25 +290,13 @@ export const duplicateElements = (
     // frame duplication
     // -------------------------------------------------------------------------
 
-    if (
-      !preserveFrameChildrenOrder &&
-      element.frameId &&
-      frameIdsToDuplicate.has(element.frameId)
-    ) {
+    if (element.frameId && frameIdsToDuplicate.has(element.frameId)) {
       continue;
     }
 
     if (isFrameLikeElement(element)) {
       const frameId = element.id;
 
-      if (preserveFrameChildrenOrder) {
-        insertBeforeOrAfterIndex(
-          findLastIndex(elementsWithDuplicates, (el) => el.id === frameId),
-          copyElements(element),
-        );
-        continue;
-      }
-
       const frameChildren = getFrameChildren(elements, frameId);
 
       const targetIndex = findLastIndex(elementsWithDuplicates, (el) => {

packages/element/src/elbowArrow.ts

@@ -14,7 +14,6 @@ import {
 } from "@excalidraw/math";
 
 import {
-  type Bounds,
   BinaryHeap,
   invariant,
   isAnyTrue,
@@ -55,6 +54,7 @@ import {
 import { aabbForElement, pointInsideBounds } from "./bounds";
 import { getHoveredElementForBinding } from "./collision";
 
+import type { Bounds } from "./bounds";
 import type { Heading } from "./heading";
 import type {
   Arrowhead,
@@ -915,8 +915,6 @@ export const updateElbowArrowPoints = (
   },
   options?: {
     isDragging?: boolean;
-    isBindingEnabled?: boolean;
-    isMidpointSnappingEnabled?: boolean;
   },
 ): ElementUpdate<ExcalidrawElbowArrowElement> => {
   if (arrow.points.length < 2) {
@@ -1204,8 +1202,6 @@ const getElbowArrowData = (
   options?: {
     isDragging?: boolean;
     zoom?: AppState["zoom"];
-    isBindingEnabled?: boolean;
-    isMidpointSnappingEnabled?: boolean;
   },
 ) => {
   const origStartGlobalPoint: GlobalPoint = pointTranslate<
@@ -1219,7 +1215,7 @@ const getElbowArrowData = (
 
   let hoveredStartElement = null;
   let hoveredEndElement = null;
-  if (options?.isDragging && options?.isBindingEnabled !== false) {
+  if (options?.isDragging) {
     const elements = Array.from(elementsMap.values());
     hoveredStartElement =
       getHoveredElement(
@@ -1259,8 +1255,6 @@ const getElbowArrowData = (
     hoveredStartElement,
     elementsMap,
     options?.isDragging,
-    options?.isBindingEnabled,
-    options?.isMidpointSnappingEnabled,
   );
   const endGlobalPoint = getGlobalPoint(
     {
@@ -1276,8 +1270,6 @@ const getElbowArrowData = (
     hoveredEndElement,
     elementsMap,
     options?.isDragging,
-    options?.isBindingEnabled,
-    options?.isMidpointSnappingEnabled,
   );
   const startHeading = getBindPointHeading(
     startGlobalPoint,
@@ -2124,8 +2116,8 @@ const normalizeArrowElementUpdate = (
     offsetY < -MAX_POS ||
     offsetY > MAX_POS ||
     offsetX + points[points.length - 1][0] < -MAX_POS ||
-    offsetX + points[points.length - 1][0] > MAX_POS ||
-    offsetY + points[points.length - 1][1] < -MAX_POS ||
+    offsetY + points[points.length - 1][0] > MAX_POS ||
+    offsetX + points[points.length - 1][1] < -MAX_POS ||
     offsetY + points[points.length - 1][1] > MAX_POS
   ) {
     console.error(
@@ -2221,18 +2213,14 @@ const getGlobalPoint = (
   element?: ExcalidrawBindableElement | null,
   elementsMap?: ElementsMap,
   isDragging?: boolean,
-  isBindingEnabled = true,
-  isMidpointSnappingEnabled = true,
 ): GlobalPoint => {
   if (isDragging) {
-    if (isBindingEnabled && element && elementsMap) {
+    if (element && elementsMap) {
       return bindPointToSnapToElementOutline(
         arrow,
         element,
         startOrEnd,
         elementsMap,
-        undefined,
-        isMidpointSnappingEnabled,
       );
     }
 
@@ -2288,7 +2276,7 @@ const getHoveredElement = (
     origPoint,
     elements,
     elementsMap,
-    maxBindingDistance_simple(zoom),
+    (element) => maxBindingDistance_simple(zoom),
   );
 };
 

packages/element/src/embeddable.ts

@@ -56,7 +56,7 @@ const RE_REDDIT =
 const RE_REDDIT_EMBED =
   /^<blockquote[\s\S]*?\shref=["'](https?:\/\/(?:www\.)?reddit\.com\/[^"']*)/i;
 
-const parseYouTubeLikeTimestamp = (url: string): number => {
+const parseYouTubeTimestamp = (url: string): number => {
   let timeParam: string | null | undefined;
 
   try {
@@ -85,57 +85,11 @@ const parseYouTubeLikeTimestamp = (url: string): number => {
   return parseInt(hours) * 3600 + parseInt(minutes) * 60 + parseInt(seconds);
 };
 
-const parseGoogleDriveVideoLink = (
-  url: string,
-): { fileId: string; resourceKey?: string; timestamp?: number } | null => {
-  try {
-    const urlObj = new URL(url.startsWith("http") ? url : `https://${url}`);
-    const hostname = urlObj.hostname.replace(/^www\./, "");
-    if (hostname !== "drive.google.com") {
-      return null;
-    }
-
-    let fileId: string | null = null;
-    const pathMatch = urlObj.pathname.match(/^\/file\/d\/([^/]+)(?:\/|$)/);
-    if (pathMatch?.[1]) {
-      fileId = pathMatch[1];
-    } else if (urlObj.pathname === "/open" || urlObj.pathname === "/uc") {
-      // Shared Drive links can be emitted as:
-      // - /open?id=<fileId> (common "open in Drive" format)
-      // - /uc?...&id=<fileId> (download/export endpoint often seen in copied links)
-      fileId = urlObj.searchParams.get("id");
-    }
-
-    if (!fileId || !/^[a-zA-Z0-9_-]+$/.test(fileId)) {
-      return null;
-    }
-
-    // Some Drive share links include `resourcekey` for access to link-shared
-    // files; preserve it in the preview URL so embeds keep working.
-    const resourceKey = urlObj.searchParams.get("resourcekey");
-    const timestamp = parseYouTubeLikeTimestamp(urlObj.toString());
-
-    return {
-      fileId,
-      resourceKey:
-        resourceKey && /^[a-zA-Z0-9_-]+$/.test(resourceKey)
-          ? resourceKey
-          : undefined,
-      // Drive accepts YouTube-like `t` formats (e.g. `t=90`, `t=1m30s`);
-      // normalize to seconds for a stable preview URL.
-      timestamp: timestamp > 0 ? timestamp : undefined,
-    };
-  } catch (error) {
-    return null;
-  }
-};
-
 const ALLOWED_DOMAINS = new Set([
   "youtube.com",
   "youtu.be",
   "vimeo.com",
   "player.vimeo.com",
-  "drive.google.com",
   "figma.com",
   "link.excalidraw.com",
   "gist.github.com",
@@ -154,7 +108,6 @@ const ALLOW_SAME_ORIGIN = new Set([
   "youtu.be",
   "vimeo.com",
   "player.vimeo.com",
-  "drive.google.com",
   "figma.com",
   "twitter.com",
   "x.com",
@@ -189,7 +142,7 @@ export const getEmbedLink = (
   let aspectRatio = { w: 560, h: 840 };
   const ytLink = link.match(RE_YOUTUBE);
   if (ytLink?.[2]) {
-    const startTime = parseYouTubeLikeTimestamp(originalLink);
+    const startTime = parseYouTubeTimestamp(originalLink);
     const time = startTime > 0 ? `&start=${startTime}` : ``;
     const isPortrait = link.includes("shorts");
     type = "video";
@@ -248,36 +201,6 @@ export const getEmbedLink = (
     };
   }
 
-  const googleDriveVideo = parseGoogleDriveVideoLink(link);
-  if (googleDriveVideo) {
-    type = "video";
-    const searchParams = new URLSearchParams();
-    if (googleDriveVideo.resourceKey) {
-      searchParams.set("resourcekey", googleDriveVideo.resourceKey);
-    }
-    if (googleDriveVideo.timestamp) {
-      searchParams.set("t", `${googleDriveVideo.timestamp}`);
-    }
-
-    const search = searchParams.toString();
-    link = `https://drive.google.com/file/d/${googleDriveVideo.fileId}/preview${
-      search ? `?${search}` : ""
-    }`;
-    aspectRatio = { w: 560, h: 315 };
-    embeddedLinkCache.set(originalLink, {
-      link,
-      intrinsicSize: aspectRatio,
-      type,
-      sandbox: { allowSameOrigin },
-    });
-    return {
-      link,
-      intrinsicSize: aspectRatio,
-      type,
-      sandbox: { allowSameOrigin },
-    };
-  }
-
   const figmaLink = link.match(RE_FIGMA);
   if (figmaLink) {
     type = "generic";

packages/element/src/fractionalIndex.ts

@@ -1,9 +1,6 @@
-import { arrayToMap } from "@excalidraw/common";
+import { generateNKeysBetween } from "fractional-indexing";
 
-import {
-  validateOrderKey,
-  generateNKeysBetween,
-} from "@excalidraw/fractional-indexing";
+import { arrayToMap } from "@excalidraw/common";
 
 import { mutateElement, newElementWith } from "./mutateElement";
 import { getBoundTextElement } from "./textElement";
@@ -385,13 +382,6 @@ const isValidFractionalIndex = (
     return false;
   }
 
-  try {
-    // Format validation
-    validateOrderKey(index);
-  } catch {
-    return false;
-  }
-
   if (predecessor && successor) {
     return predecessor < index && index < successor;
   }

packages/element/src/frame.ts

@@ -1,9 +1,7 @@
 import { arrayToMap } from "@excalidraw/common";
-import {
-  isPointWithinBounds,
-  pointFrom,
-  segmentsIntersectAt,
-} from "@excalidraw/math";
+import { isPointWithinBounds, pointFrom } from "@excalidraw/math";
+import { doLineSegmentsIntersect } from "@excalidraw/utils/bbox";
+import { elementsOverlappingBBox } from "@excalidraw/utils/withinBounds";
 
 import type {
   AppClassProperties,
@@ -20,13 +18,9 @@ import {
   getElementLineSegments,
   getCommonBounds,
   getElementAbsoluteCoords,
-  doBoundsIntersect,
-  getElementBounds,
-  boundsContainBounds,
 } from "./bounds";
 import { mutateElement } from "./mutateElement";
 import { getBoundTextElement, getContainerElement } from "./textElement";
-import { syncMovedIndices } from "./fractionalIndex";
 import {
   isFrameElement,
   isFrameLikeElement,
@@ -81,7 +75,7 @@ export function isElementIntersectingFrame(
 
   const intersecting = frameLineSegments.some((frameLineSegment) =>
     elementLineSegments.some((elementLineSegment) =>
-      segmentsIntersectAt(frameLineSegment, elementLineSegment),
+      doLineSegmentsIntersect(frameLineSegment, elementLineSegment),
     ),
   );
 
@@ -106,9 +100,8 @@ export const isElementContainingFrame = (
   frame: ExcalidrawFrameLikeElement,
   elementsMap: ElementsMap,
 ) => {
-  return boundsContainBounds(
-    getElementBounds(element, elementsMap),
-    getElementBounds(frame, elementsMap),
+  return getElementsWithinSelection([frame], element, elementsMap).some(
+    (e) => e.id === frame.id,
   );
 };
 
@@ -495,44 +488,10 @@ export const filterElementsEligibleAsFrameChildren = (
   return eligibleElements;
 };
 
-export const getCommonFrameId = (elements: readonly ExcalidrawElement[]) => {
-  let commonFrameId: ExcalidrawElement["frameId"] | undefined;
-
-  for (const element of elements) {
-    if (isFrameLikeElement(element) || !element.frameId) {
-      return null;
-    }
-
-    if (commonFrameId === undefined) {
-      commonFrameId = element.frameId;
-    } else if (commonFrameId !== element.frameId) {
-      return null;
-    }
-  }
-
-  return commonFrameId ?? null;
-};
-
-export const getFrameChildrenInsertionIndex = (
-  elements: readonly ExcalidrawElement[],
-  frameId: ExcalidrawFrameLikeElement["id"],
-): number | null => {
-  for (let index = elements.length - 1; index >= 0; index--) {
-    const element = elements[index];
-
-    if (element.id === frameId) {
-      return index;
-    } else if (element.frameId === frameId) {
-      return index + 1;
-    }
-  }
-
-  return null;
-};
-
 /**
- * Adds elements and their bound elements to frame. Reorders added elements to
- * be just below frame, or just above its highest child (whichever is higher).
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
  *
  * @returns mutated allElements (same data structure)
  */
@@ -540,11 +499,19 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   allElements: T,
   elementsToAdd: NonDeletedExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  appState: AppState,
 ): T => {
   const elementsMap = arrayToMap(allElements);
-  const commonFrameId = getCommonFrameId(elementsToAdd);
+  const currTargetFrameChildrenMap = new Map<ExcalidrawElement["id"], true>();
+  for (const element of allElements.values()) {
+    if (element.frameId === frame.id) {
+      currTargetFrameChildrenMap.set(element.id, true);
+    }
+  }
 
-  const finalElementsToAdd = new Set<ExcalidrawElement>();
+  const suppliedElementsToAddSet = new Set(elementsToAdd.map((el) => el.id));
+
+  const finalElementsToAdd: ExcalidrawElement[] = [];
 
   const otherFrames = new Set<ExcalidrawFrameLikeElement["id"]>();
 
@@ -555,8 +522,7 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
   }
 
   // - add bound text elements if not already in the array
-  // - keep elements already in the frame so mixed selections can be reordered
-  //   together
+  // - filter out elements that are already in the frame
   for (const element of omitGroupsContainingFrameLikes(
     allElements,
     elementsToAdd,
@@ -569,64 +535,38 @@ export const addElementsToFrame = <T extends ElementsMapOrArray>(
       continue;
     }
 
-    finalElementsToAdd.add(element);
+    // if the element is already in another frame (which is also in elementsToAdd),
+    // it means that frame and children are selected at the same time
+    // => keep original frame membership, do not add to the target frame
+    if (
+      element.frameId &&
+      appState.selectedElementIds[element.id] &&
+      appState.selectedElementIds[element.frameId]
+    ) {
+      continue;
+    }
+
+    if (!currTargetFrameChildrenMap.has(element.id)) {
+      finalElementsToAdd.push(element);
+    }
 
     const boundTextElement = getBoundTextElement(element, elementsMap);
-    if (boundTextElement && !finalElementsToAdd.has(boundTextElement)) {
-      finalElementsToAdd.add(boundTextElement);
+    if (
+      boundTextElement &&
+      !suppliedElementsToAddSet.has(boundTextElement.id) &&
+      !currTargetFrameChildrenMap.has(boundTextElement.id)
+    ) {
+      finalElementsToAdd.push(boundTextElement);
     }
   }
 
   for (const element of finalElementsToAdd) {
-    // we don't always need to update the element if it's already in the frame,
-    // but we still need to accumulate in finalElementsToAdd so we potentially
-    // reorder them if added together
-    if (element.frameId !== frame.id) {
-      mutateElement(element, elementsMap, {
-        frameId: frame.id,
-      });
-    }
+    mutateElement(element, elementsMap, {
+      frameId: frame.id,
+    });
   }
 
-  // (re)order elements to be just below the frame,
-  // or just above the highest child if that is higher
-  // (latter case is denormalized order until we migrate)
-  // ---------------------------------------------------------------------------
-
-  if (
-    !finalElementsToAdd.size ||
-    // if all elements to add already belong to the frame, then we don't want to
-    // reorder (case: we're dragging element children within the frame)
-    commonFrameId === frame.id
-  ) {
-    return allElements;
-  }
-
-  const otherElements = Array.from(allElements.values()).filter(
-    (element) => !finalElementsToAdd.has(element),
-  );
-  const insertionIndex = getFrameChildrenInsertionIndex(
-    otherElements,
-    frame.id,
-  );
-
-  if (insertionIndex === null) {
-    return allElements;
-  }
-
-  const reorderedElements = [
-    ...otherElements.slice(0, insertionIndex),
-    ...finalElementsToAdd,
-    ...otherElements.slice(insertionIndex),
-  ];
-
-  syncMovedIndices(reorderedElements, arrayToMap([...finalElementsToAdd]));
-
-  return (
-    Array.isArray(allElements)
-      ? reorderedElements
-      : new Map(reorderedElements.map((element) => [element.id, element]))
-  ) as T;
+  return allElements;
 };
 
 export const removeElementsFromFrame = (
@@ -680,11 +620,13 @@ export const replaceAllElementsInFrame = <T extends ExcalidrawElement>(
   allElements: readonly T[],
   nextElementsInFrame: ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
+  app: AppClassProperties,
 ): T[] => {
   return addElementsToFrame(
     removeAllElementsFromFrame(allElements, frame),
     nextElementsInFrame,
     frame,
+    app.state,
   ).slice();
 };
 
@@ -978,17 +920,16 @@ export const getFrameLikeTitle = (element: ExcalidrawFrameLikeElement) => {
 export const getElementsOverlappingFrame = (
   elements: readonly ExcalidrawElement[],
   frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
 ) => {
-  return elements.filter(
-    (el) =>
-      // exclude elements which are overlapping, but are in a different frame,
+  return (
+    elementsOverlappingBBox({
+      elements,
+      bounds: frame,
+      type: "overlap",
+    })
+      // removes elements who are overlapping, but are in a different frame,
       // and thus invisible in target frame
-      (!el.frameId || el.frameId === frame.id) &&
-      doBoundsIntersect(
-        getElementBounds(el, elementsMap),
-        getElementBounds(frame, elementsMap),
-      ),
+      .filter((el) => !el.frameId || el.frameId === frame.id)
   );
 };
 

packages/element/src/heading.ts

@@ -1,9 +1,4 @@
-import {
-  invariant,
-  isDevEnv,
-  isTestEnv,
-  type Bounds,
-} from "@excalidraw/common";
+import { invariant, isDevEnv, isTestEnv } from "@excalidraw/common";
 
 import {
   pointFrom,
@@ -24,7 +19,7 @@ import type {
   Vector,
 } from "@excalidraw/math";
 
-import { getCenterForBounds } from "./bounds";
+import { getCenterForBounds, type Bounds } from "./bounds";
 
 import type { ExcalidrawBindableElement } from "./types";
 

packages/element/src/index.ts

@@ -70,7 +70,6 @@ export * from "./elbowArrow";
 export * from "./elementLink";
 export * from "./embeddable";
 export * from "./flowchart";
-export * from "./arrows/focus";
 export * from "./fractionalIndex";
 export * from "./frame";
 export * from "./groups";
@@ -93,10 +92,7 @@ export * from "./store";
 export * from "./textElement";
 export * from "./textMeasurements";
 export * from "./textWrapping";
-export * from "./transform";
 export * from "./transformHandles";
 export * from "./typeChecks";
 export * from "./utils";
 export * from "./zindex";
-export * from "./arrows/helpers";
-export * from "./arrowheads";

packages/element/src/linearElementEditor.ts

@@ -9,6 +9,7 @@ import {
   vectorFromPoint,
   curveLength,
   curvePointAtLength,
+  lineSegment,
 } from "@excalidraw/math";
 
 import { getCurvePathOps } from "@excalidraw/utils/shape";
@@ -25,7 +26,7 @@ import {
 
 import {
   deconstructLinearOrFreeDrawElement,
-  getSnapOutlineMidPoint,
+  getHoveredElementForBinding,
   isPathALoop,
   moveArrowAboveBindable,
   projectFixedPointOntoDiagonal,
@@ -42,13 +43,11 @@ import type {
   NullableGridSize,
   Zoom,
 } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "@excalidraw/common";
 
 import {
   calculateFixedPointForNonElbowArrowBinding,
   getBindingStrategyForDraggingBindingElementEndpoints,
   isBindingEnabled,
-  snapToMid,
   updateBoundPoint,
 } from "./binding";
 import {
@@ -70,6 +69,7 @@ import { isLineElement } from "./typeChecks";
 
 import type { Scene } from "./Scene";
 
+import type { Bounds } from "./bounds";
 import type {
   NonDeleted,
   ExcalidrawLinearElement,
@@ -150,8 +150,6 @@ export class LinearElementEditor {
   public readonly pointerOffset: Readonly<{ x: number; y: number }>;
   public readonly hoverPointIndex: number;
   public readonly segmentMidPointHoveredCoords: GlobalPoint | null;
-  public readonly hoveredFocusPointBinding: "start" | "end" | null;
-  public readonly draggedFocusPointBinding: "start" | "end" | null;
   public readonly elbowed: boolean;
   public readonly customLineAngle: number | null;
   public readonly isEditing: boolean;
@@ -197,8 +195,6 @@ export class LinearElementEditor {
     };
     this.hoverPointIndex = -1;
     this.segmentMidPointHoveredCoords = null;
-    this.hoveredFocusPointBinding = null;
-    this.draggedFocusPointBinding = null;
     this.elbowed = isElbowArrow(element) && element.elbowed;
     this.customLineAngle = null;
     this.isEditing = isEditing;
@@ -310,11 +306,21 @@ export class LinearElementEditor {
     const customLineAngle =
       linearElementEditor.customLineAngle ??
       determineCustomLinearAngle(pivotPoint, element.points[idx]);
+    const hoveredElement = getHoveredElementForBinding(
+      pointFrom<GlobalPoint>(scenePointerX, scenePointerY),
+      elements,
+      elementsMap,
+    );
 
     // Determine if point movement should happen and how much
     let deltaX = 0;
     let deltaY = 0;
-    if (shouldRotateWithDiscreteAngle(event)) {
+    if (
+      shouldRotateWithDiscreteAngle(event) &&
+      !hoveredElement &&
+      !element.startBinding &&
+      !element.endBinding
+    ) {
       const [width, height] = LinearElementEditor._getShiftLockedDelta(
         element,
         elementsMap,
@@ -348,31 +354,19 @@ export class LinearElementEditor {
       [idx],
       deltaX,
       deltaY,
-      scenePointerX,
-      scenePointerY,
       elementsMap,
       element,
       elements,
       app,
-      shouldRotateWithDiscreteAngle(event),
+      event.shiftKey,
       event.altKey,
-      linearElementEditor,
     );
 
-    LinearElementEditor.movePoints(
-      element,
-      app.scene,
-      positions,
-      {
-        startBinding: updates?.startBinding,
-        endBinding: updates?.endBinding,
-        moveMidPointsWithElement: updates?.moveMidPointsWithElement,
-      },
-      {
-        isBindingEnabled: app.state.isBindingEnabled,
-        isMidpointSnappingEnabled: app.state.isMidpointSnappingEnabled,
-      },
-    );
+    LinearElementEditor.movePoints(element, app.scene, positions, {
+      startBinding: updates?.startBinding,
+      endBinding: updates?.endBinding,
+      moveMidPointsWithElement: updates?.moveMidPointsWithElement,
+    });
     // Set the suggested binding from the updates if available
     if (isBindingElement(element, false)) {
       if (isBindingEnabled(app.state)) {
@@ -419,15 +413,13 @@ export class LinearElementEditor {
         altFocusPoint:
           !linearElementEditor.initialState.altFocusPoint &&
           startBindingElement &&
-          updates?.suggestedBinding?.element.id !== startBindingElement.id
+          updates?.suggestedBinding?.id !== startBindingElement.id
             ? projectFixedPointOntoDiagonal(
                 element,
                 pointFrom<GlobalPoint>(element.x, element.y),
                 startBindingElement,
                 "start",
                 elementsMap,
-                app.state.zoom,
-                app.state.isMidpointSnappingEnabled,
               )
             : linearElementEditor.initialState.altFocusPoint,
       },
@@ -476,22 +468,16 @@ export class LinearElementEditor {
       });
     }
 
-    if (
-      lastClickedPoint < 0 ||
-      !selectedPointsIndices.includes(lastClickedPoint) ||
-      !element.points[lastClickedPoint]
-    ) {
-      console.error(
-        `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
-          selectedPointsIndices,
-        )}) points(0..${
-          element.points.length - 1
-        }) lastClickedPoint(${lastClickedPoint}) isElbowArrow: ${elbowed}`,
-      );
-
-      // Fall back to the actual last point as a last resort.
-      lastClickedPoint = element.points.length - 1;
-    }
+    invariant(
+      lastClickedPoint > -1 &&
+        selectedPointsIndices.includes(lastClickedPoint) &&
+        element.points[lastClickedPoint],
+      `There must be a valid lastClickedPoint in order to drag it. selectedPointsIndices(${JSON.stringify(
+        selectedPointsIndices,
+      )}) points(0..${
+        element.points.length - 1
+      }) lastClickedPoint(${lastClickedPoint})`,
+    );
 
     // point that's being dragged (out of all selected points)
     const draggingPoint = element.points[lastClickedPoint];
@@ -506,11 +492,22 @@ export class LinearElementEditor {
     const endIsSelected = selectedPointsIndices.includes(
       element.points.length - 1,
     );
+    const hoveredElement = getHoveredElementForBinding(
+      pointFrom<GlobalPoint>(scenePointerX, scenePointerY),
+      elements,
+      elementsMap,
+    );
 
     // Determine if point movement should happen and how much
     let deltaX = 0;
     let deltaY = 0;
-    if (shouldRotateWithDiscreteAngle(event) && singlePointDragged) {
+    if (
+      shouldRotateWithDiscreteAngle(event) &&
+      singlePointDragged &&
+      !hoveredElement &&
+      !element.startBinding &&
+      !element.endBinding
+    ) {
       const [width, height] = LinearElementEditor._getShiftLockedDelta(
         element,
         elementsMap,
@@ -523,6 +520,7 @@ export class LinearElementEditor {
         width + pivotPoint[0],
         height + pivotPoint[1],
       );
+
       deltaX = target[0] - draggingPoint[0];
       deltaY = target[1] - draggingPoint[1];
     } else {
@@ -543,31 +541,19 @@ export class LinearElementEditor {
       selectedPointsIndices,
       deltaX,
       deltaY,
-      scenePointerX,
-      scenePointerY,
       elementsMap,
       element,
       elements,
       app,
-      shouldRotateWithDiscreteAngle(event) && singlePointDragged,
+      event.shiftKey,
       event.altKey,
-      linearElementEditor,
     );
 
-    LinearElementEditor.movePoints(
-      element,
-      app.scene,
-      positions,
-      {
-        startBinding: updates?.startBinding,
-        endBinding: updates?.endBinding,
-        moveMidPointsWithElement: updates?.moveMidPointsWithElement,
-      },
-      {
-        isBindingEnabled: app.state.isBindingEnabled,
-        isMidpointSnappingEnabled: app.state.isMidpointSnappingEnabled,
-      },
-    );
+    LinearElementEditor.movePoints(element, app.scene, positions, {
+      startBinding: updates?.startBinding,
+      endBinding: updates?.endBinding,
+      moveMidPointsWithElement: updates?.moveMidPointsWithElement,
+    });
 
     // Set the suggested binding from the updates if available
     if (isBindingElement(element, false)) {
@@ -636,11 +622,11 @@ export class LinearElementEditor {
     const altFocusPointBindableElement =
       endIsSelected && // The "other" end (i.e. "end") is dragged
       startBindingElement &&
-      updates?.suggestedBinding?.element.id !== startBindingElement.id // The end point is not hovering the start bindable + it's binding gap
+      updates?.suggestedBinding?.id !== startBindingElement.id // The end point is not hovering the start bindable + it's binding gap
         ? startBindingElement
         : startIsSelected && // The "other" end (i.e. "start") is dragged
           endBindingElement &&
-          updates?.suggestedBinding?.element.id !== endBindingElement.id // The start point is not hovering the end bindable + it's binding gap
+          updates?.suggestedBinding?.id !== endBindingElement.id // The start point is not hovering the end bindable + it's binding gap
         ? endBindingElement
         : null;
 
@@ -660,8 +646,6 @@ export class LinearElementEditor {
                 altFocusPointBindableElement,
                 "start",
                 elementsMap,
-                app.state.zoom,
-                app.state.isMidpointSnappingEnabled,
               )
             : linearElementEditor.initialState.altFocusPoint,
       },
@@ -759,6 +743,7 @@ export class LinearElementEditor {
           ? [pointerDownState.lastClickedPoint]
           : selectedPointsIndices,
       isDragging: false,
+      pointerOffset: { x: 0, y: 0 },
       customLineAngle: null,
       initialState: {
         ...editingLinearElement.initialState,
@@ -800,7 +785,6 @@ export class LinearElementEditor {
           element.points[index + 1],
           index,
           appState.zoom,
-          elementsMap,
         )
       ) {
         midpoints.push(null);
@@ -810,7 +794,6 @@ export class LinearElementEditor {
       const segmentMidPoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
       midpoints.push(segmentMidPoint);
       index++;
@@ -898,7 +881,6 @@ export class LinearElementEditor {
     endPoint: P,
     index: number,
     zoom: Zoom,
-    elementsMap: ElementsMap,
   ) {
     if (isElbowArrow(element)) {
       if (index >= 0 && index < element.points.length) {
@@ -913,10 +895,7 @@ export class LinearElementEditor {
 
     let distance = pointDistance(startPoint, endPoint);
     if (element.points.length > 2 && element.roundness) {
-      const [lines, curves] = deconstructLinearOrFreeDrawElement(
-        element,
-        elementsMap,
-      );
+      const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
 
       invariant(
         lines.length === 0 && curves.length > 0,
@@ -936,7 +915,6 @@ export class LinearElementEditor {
   static getSegmentMidPoint(
     element: NonDeleted<ExcalidrawLinearElement>,
     index: number,
-    elementsMap: ElementsMap,
   ): GlobalPoint {
     if (isElbowArrow(element)) {
       invariant(
@@ -949,10 +927,7 @@ export class LinearElementEditor {
       return pointFrom<GlobalPoint>(element.x + p[0], element.y + p[1]);
     }
 
-    const [lines, curves] = deconstructLinearOrFreeDrawElement(
-      element,
-      elementsMap,
-    );
+    const [lines, curves] = deconstructLinearOrFreeDrawElement(element);
 
     invariant(
       (lines.length === 0 && curves.length > 0) ||
@@ -1560,10 +1535,6 @@ export class LinearElementEditor {
       endBinding?: FixedPointBinding | null;
       moveMidPointsWithElement?: boolean | null;
     },
-    options?: {
-      isBindingEnabled?: boolean;
-      isMidpointSnappingEnabled?: boolean;
-    },
   ) {
     const { points } = element;
 
@@ -1632,8 +1603,6 @@ export class LinearElementEditor {
       otherUpdates,
       {
         isDragging: Array.from(pointUpdates.values()).some((t) => t.isDragging),
-        isBindingEnabled: options?.isBindingEnabled,
-        isMidpointSnappingEnabled: options?.isMidpointSnappingEnabled,
       },
     );
   }
@@ -1748,8 +1717,6 @@ export class LinearElementEditor {
       isDragging?: boolean;
       zoom?: AppState["zoom"];
       sceneElementsMap?: NonDeletedSceneElementsMap;
-      isBindingEnabled?: boolean;
-      isMidpointSnappingEnabled?: boolean;
     },
   ) {
     if (isElbowArrow(element)) {
@@ -1770,8 +1737,6 @@ export class LinearElementEditor {
       scene.mutateElement(element, updates, {
         informMutation: true,
         isDragging: options?.isDragging ?? false,
-        isBindingEnabled: options?.isBindingEnabled,
-        isMidpointSnappingEnabled: options?.isMidpointSnappingEnabled,
       });
     } else {
       // TODO do we need to get precise coords here just to calc centers?
@@ -1867,7 +1832,6 @@ export class LinearElementEditor {
       const midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
         element,
         index + 1,
-        elementsMap,
       );
 
       x = midSegmentMidpoint[0] - boundTextElement.width / 2;
@@ -2124,28 +2088,25 @@ const pointDraggingUpdates = (
   selectedPointsIndices: readonly number[],
   deltaX: number,
   deltaY: number,
-  scenePointerX: number,
-  scenePointerY: number,
   elementsMap: NonDeletedSceneElementsMap,
   element: NonDeleted<ExcalidrawLinearElement>,
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   app: AppClassProperties,
-  angleLocked: boolean,
+  shiftKey: boolean,
   altKey: boolean,
-  linearElementEditor: LinearElementEditor,
 ): {
   positions: PointsPositionUpdates;
   updates?: PointMoveOtherUpdates;
 } => {
   const naiveDraggingPoints = new Map(
     selectedPointsIndices.map((pointIndex) => {
-      // NOTE: Avoid stale point index issue potentially caused by elbow
-      // arrows unpredictably changing the number of points during dragging
-      const point = element.points[pointIndex] ?? element.points.at(-1);
       return [
         pointIndex,
         {
-          point: pointFrom<LocalPoint>(point[0] + deltaX, point[1] + deltaY),
+          point: pointFrom<LocalPoint>(
+            element.points[pointIndex][0] + deltaX,
+            element.points[pointIndex][1] + deltaY,
+          ),
           isDragging: true,
         },
       ];
@@ -2167,104 +2128,29 @@ const pointDraggingUpdates = (
   const { start, end } = getBindingStrategyForDraggingBindingElementEndpoints(
     element,
     naiveDraggingPoints,
-    scenePointerX,
-    scenePointerY,
     elementsMap,
     elements,
     app.state,
     {
       newArrow: !!app.state.newElement,
-      angleLocked,
+      shiftKey,
       altKey,
     },
   );
 
   if (isElbowArrow(element)) {
-    const suggestedBindingElement = startIsDragged
-      ? start.element
-      : endIsDragged
-      ? end.element
-      : null;
-
     return {
       positions: naiveDraggingPoints,
       updates: {
-        suggestedBinding: suggestedBindingElement
-          ? {
-              element: suggestedBindingElement,
-              midPoint: app.state.isMidpointSnappingEnabled
-                ? snapToMid(
-                    suggestedBindingElement,
-                    elementsMap,
-                    pointFrom<GlobalPoint>(
-                      scenePointerX - linearElementEditor.pointerOffset.x,
-                      scenePointerY - linearElementEditor.pointerOffset.y,
-                    ),
-                  )
-                : undefined,
-            }
+        suggestedBinding: startIsDragged
+          ? start.element
+          : endIsDragged
+          ? end.element
           : null,
       },
     };
   }
 
-  // Handle the case where neither endpoint is being dragged
-  // but we need to update bound endpoints
-  if (!startIsDragged && !endIsDragged) {
-    const nextArrow = {
-      ...element,
-      points: element.points.map((p, idx) => {
-        return naiveDraggingPoints.get(idx)?.point ?? p;
-      }),
-    };
-    const positions = new Map(naiveDraggingPoints);
-
-    if (element.startBinding) {
-      const startBindable = elementsMap.get(element.startBinding.elementId) as
-        | ExcalidrawBindableElement
-        | undefined;
-      if (startBindable) {
-        const startPoint =
-          updateBoundPoint(
-            nextArrow,
-            "startBinding",
-            element.startBinding,
-            startBindable,
-            elementsMap,
-          ) ?? null;
-        if (startPoint) {
-          positions.set(0, { point: startPoint, isDragging: true });
-        }
-      }
-    }
-
-    if (element.endBinding) {
-      const endBindable = elementsMap.get(element.endBinding.elementId) as
-        | ExcalidrawBindableElement
-        | undefined;
-      if (endBindable) {
-        const endPoint =
-          updateBoundPoint(
-            nextArrow,
-            "endBinding",
-            element.endBinding,
-            endBindable,
-            elementsMap,
-          ) ?? null;
-        if (endPoint) {
-          positions.set(element.points.length - 1, {
-            point: endPoint,
-            isDragging: true,
-          });
-        }
-      }
-    }
-
-    return {
-      positions,
-    };
-  }
-
   if (startIsDragged === endIsDragged) {
     return {
       positions: naiveDraggingPoints,
@@ -2295,20 +2181,7 @@ const pointDraggingUpdates = (
       (updates.startBinding.mode === "orbit" ||
         !getFeatureFlag("COMPLEX_BINDINGS"))
     ) {
-      updates.suggestedBinding = start.element
-        ? {
-            element: start.element,
-            midPoint: getSnapOutlineMidPoint(
-              pointFrom<GlobalPoint>(
-                scenePointerX - linearElementEditor.pointerOffset.x,
-                scenePointerY - linearElementEditor.pointerOffset.y,
-              ),
-              start.element,
-              elementsMap,
-              app.state.zoom,
-            ),
-          }
-        : null;
+      updates.suggestedBinding = start.element;
     }
   } else if (startIsDragged) {
     updates.suggestedBinding = app.state.suggestedBinding;
@@ -2334,20 +2207,7 @@ const pointDraggingUpdates = (
       (updates.endBinding.mode === "orbit" ||
         !getFeatureFlag("COMPLEX_BINDINGS"))
     ) {
-      updates.suggestedBinding = end.element
-        ? {
-            element: end.element,
-            midPoint: getSnapOutlineMidPoint(
-              pointFrom<GlobalPoint>(
-                scenePointerX - linearElementEditor.pointerOffset.x,
-                scenePointerY - linearElementEditor.pointerOffset.y,
-              ),
-              end.element,
-              elementsMap,
-              app.state.zoom,
-            ),
-          }
-        : null;
+      updates.suggestedBinding = end.element;
     }
   } else if (endIsDragged) {
     updates.suggestedBinding = app.state.suggestedBinding;
@@ -2387,6 +2247,14 @@ const pointDraggingUpdates = (
         : updates.endBinding,
   };
 
+  // We need to use a custom intersector to ensure that if there is a big "jump"
+  // in the arrow's position, we can position it with outline avoidance
+  // pixel-perfectly and avoid "dancing" arrows.
+  const customIntersector =
+    start.focusPoint && end.focusPoint
+      ? lineSegment(start.focusPoint, end.focusPoint)
+      : undefined;
+
   // Needed to handle a special case where an existing arrow is dragged over
   // the same element it is bound to on the other side
   const startIsDraggingOverEndElement =
@@ -2417,12 +2285,12 @@ const pointDraggingUpdates = (
     ? nextArrow.points[0]
     : endBindable
     ? updateBoundPoint(
-        nextArrow,
+        element,
         "endBinding",
         nextArrow.endBinding,
         endBindable,
         elementsMap,
-        endIsDragged,
+        customIntersector,
       ) || nextArrow.points[nextArrow.points.length - 1]
     : nextArrow.points[nextArrow.points.length - 1];
 
@@ -2445,26 +2313,23 @@ const pointDraggingUpdates = (
       : startIsDraggingOverEndElement &&
         app.state.bindMode !== "inside" &&
         getFeatureFlag("COMPLEX_BINDINGS")
-      ? endLocalPoint
+      ? nextArrow.points[nextArrow.points.length - 1]
       : startBindable
       ? updateBoundPoint(
-          nextArrow,
+          element,
           "startBinding",
           nextArrow.startBinding,
           startBindable,
           elementsMap,
-          startIsDragged,
+          customIntersector,
         ) || nextArrow.points[0]
       : nextArrow.points[0];
 
   const endChanged =
-    !startIsDraggingOverEndElement &&
-    !(
-      endIsDraggingOverStartElement &&
-      app.state.bindMode !== "inside" &&
-      getFeatureFlag("COMPLEX_BINDINGS")
-    ) &&
-    !!endBindable;
+    pointDistance(
+      endLocalPoint,
+      nextArrow.points[nextArrow.points.length - 1],
+    ) !== 0;
   const startChanged =
     pointDistance(startLocalPoint, nextArrow.points[0]) !== 0;
 
@@ -2478,7 +2343,13 @@ const pointDraggingUpdates = (
   const indices = Array.from(indicesSet);
 
   return {
-    updates,
+    updates:
+      updates.startBinding || updates.suggestedBinding
+        ? {
+            startBinding: updates.startBinding,
+            suggestedBinding: updates.suggestedBinding,
+          }
+        : undefined,
     positions: new Map(
       indices.map((idx) => {
         return [

packages/element/src/mutateElement.ts

@@ -40,8 +40,6 @@ export const mutateElement = <TElement extends Mutable<ExcalidrawElement>>(
   updates: ElementUpdate<TElement>,
   options?: {
     isDragging?: boolean;
-    isBindingEnabled?: boolean;
-    isMidpointSnappingEnabled?: boolean;
   },
 ) => {
   let didChange = false;

packages/element/src/newElement.ts

@@ -4,7 +4,6 @@ import {
   DEFAULT_FONT_SIZE,
   DEFAULT_TEXT_ALIGN,
   DEFAULT_VERTICAL_ALIGN,
-  DEFAULT_STROKE_STREAMLINE,
   VERTICAL_ALIGN,
   randomInteger,
   randomId,
@@ -445,7 +444,6 @@ export const newFreeDrawElement = (
     type: "freedraw";
     points?: ExcalidrawFreeDrawElement["points"];
     simulatePressure: boolean;
-    strokeOptions?: ExcalidrawFreeDrawElement["strokeOptions"];
     pressures?: ExcalidrawFreeDrawElement["pressures"];
   } & ElementConstructorOpts,
 ): NonDeleted<ExcalidrawFreeDrawElement> => {
@@ -454,10 +452,6 @@ export const newFreeDrawElement = (
     points: opts.points || [],
     pressures: opts.pressures || [],
     simulatePressure: opts.simulatePressure,
-    strokeOptions: opts.strokeOptions ?? {
-      variability: "variable",
-      streamline: DEFAULT_STROKE_STREAMLINE,
-    },
   };
 };
 

packages/element/src/renderElement.ts

@@ -1,4 +1,5 @@
 import rough from "roughjs/bin/rough";
+import { getStroke } from "perfect-freehand";
 
 import {
   type GlobalPoint,
@@ -14,7 +15,6 @@ import {
   DEFAULT_REDUCED_GLOBAL_ALPHA,
   ELEMENT_READY_TO_ERASE_OPACITY,
   FRAME_STYLE,
-  DARK_THEME_FILTER,
   MIME_TYPES,
   THEME,
   distance,
@@ -22,8 +22,6 @@ import {
   isRTL,
   getVerticalOffset,
   invariant,
-  applyDarkModeFilter,
-  isSafari,
 } from "@excalidraw/common";
 
 import type {
@@ -80,8 +78,16 @@ import type {
   ElementsMap,
 } from "./types";
 
+import type { StrokeOptions } from "perfect-freehand";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 
+// using a stronger invert (100% vs our regular 93%) and saturate
+// as a temp hack to make images in dark theme look closer to original
+// color scheme (it's still not quite there and the colors look slightly
+// desatured, alas...)
+export const IMAGE_INVERT_FILTER =
+  "invert(100%) hue-rotate(180deg) saturate(1.25)";
+
 const isPendingImageElement = (
   element: ExcalidrawElement,
   renderConfig: StaticCanvasRenderConfig,
@@ -89,6 +95,19 @@ const isPendingImageElement = (
   isInitializedImageElement(element) &&
   !renderConfig.imageCache.has(element.fileId);
 
+const shouldResetImageFilter = (
+  element: ExcalidrawElement,
+  renderConfig: StaticCanvasRenderConfig,
+  appState: StaticCanvasAppState | InteractiveCanvasAppState,
+) => {
+  return (
+    appState.theme === THEME.DARK &&
+    isInitializedImageElement(element) &&
+    !isPendingImageElement(element, renderConfig) &&
+    renderConfig.imageCache.get(element.fileId)?.mimeType !== MIME_TYPES.svg
+  );
+};
+
 const getCanvasPadding = (element: ExcalidrawElement) => {
   switch (element.type) {
     case "freedraw":
@@ -253,6 +272,11 @@ const generateElementCanvas = (
 
   const rc = rough.canvas(canvas);
 
+  // in dark theme, revert the image color filter
+  if (shouldResetImageFilter(element, renderConfig, appState)) {
+    context.filter = IMAGE_INVERT_FILTER;
+  }
+
   drawElementOnCanvas(element, rc, context, renderConfig);
 
   context.restore();
@@ -361,9 +385,8 @@ IMAGE_ERROR_PLACEHOLDER_IMG.src = `data:${MIME_TYPES.svg},${encodeURIComponent(
 const drawImagePlaceholder = (
   element: ExcalidrawImageElement,
   context: CanvasRenderingContext2D,
-  theme: StaticCanvasRenderConfig["theme"],
 ) => {
-  context.fillStyle = theme === THEME.DARK ? "#2E2E2E" : "#E7E7E7";
+  context.fillStyle = "#E7E7E7";
   context.fillRect(0, 0, element.width, element.height);
 
   const imageMinWidthOrHeight = Math.min(element.width, element.height);
@@ -398,8 +421,7 @@ const drawElementOnCanvas = (
     case "ellipse": {
       context.lineJoin = "round";
       context.lineCap = "round";
-
-      rc.draw(ShapeCache.generateElementShape(element, renderConfig));
+      rc.draw(ShapeCache.get(element)!);
       break;
     }
     case "arrow":
@@ -407,44 +429,33 @@ const drawElementOnCanvas = (
       context.lineJoin = "round";
       context.lineCap = "round";
 
-      ShapeCache.generateElementShape(element, renderConfig).forEach(
-        (shape) => {
-          rc.draw(shape);
-        },
-      );
+      ShapeCache.get(element)!.forEach((shape) => {
+        rc.draw(shape);
+      });
       break;
     }
     case "freedraw": {
       // Draw directly to canvas
       context.save();
+      context.fillStyle = element.strokeColor;
 
-      const shapes = ShapeCache.generateElementShape(element, renderConfig);
+      const path = getFreeDrawPath2D(element) as Path2D;
+      const fillShape = ShapeCache.get(element);
 
-      for (const shape of shapes) {
-        if (typeof shape === "string") {
-          context.fillStyle = applyDarkModeFilter(
-            element.strokeColor,
-            renderConfig.theme === THEME.DARK,
-          );
-          context.fill(new Path2D(shape));
-        } else {
-          rc.draw(shape);
-        }
+      if (fillShape) {
+        rc.draw(fillShape);
       }
 
+      context.fillStyle = element.strokeColor;
+      context.fill(path);
+
       context.restore();
       break;
     }
     case "image": {
-      context.save();
-      const cacheEntry =
-        element.fileId !== null
-          ? renderConfig.imageCache.get(element.fileId)
-          : null;
       const img = isInitializedImageElement(element)
-        ? cacheEntry?.image
+        ? renderConfig.imageCache.get(element.fileId)?.image
         : undefined;
-
       if (img != null && !(img instanceof Promise)) {
         if (element.roundness && context.roundRect) {
           context.beginPath();
@@ -467,80 +478,20 @@ const drawElementOnCanvas = (
               height: img.naturalHeight,
             };
 
-        const shouldInvertImage =
-          renderConfig.theme === THEME.DARK &&
-          cacheEntry?.mimeType === MIME_TYPES.svg;
-
-        if (shouldInvertImage && isSafari) {
-          const devicePixelRatio = window.devicePixelRatio || 1;
-          const tempCanvas = document.createElement("canvas");
-          tempCanvas.width = element.width * devicePixelRatio;
-          tempCanvas.height = element.height * devicePixelRatio;
-          const tempContext = tempCanvas.getContext("2d");
-
-          if (tempContext) {
-            tempContext.scale(devicePixelRatio, devicePixelRatio);
-            tempContext.drawImage(
-              img,
-              x,
-              y,
-              width,
-              height,
-              0,
-              0,
-              element.width,
-              element.height,
-            );
-
-            const imageData = tempContext.getImageData(
-              0,
-              0,
-              tempCanvas.width,
-              tempCanvas.height,
-            );
-
-            const data = imageData.data;
-
-            for (let i = 0; i < data.length; i += 4) {
-              data[i] = 255 - data[i];
-              data[i + 1] = 255 - data[i + 1];
-              data[i + 2] = 255 - data[i + 2];
-            }
-
-            tempContext.putImageData(imageData, 0, 0);
-            context.drawImage(
-              tempCanvas,
-              0,
-              0,
-              tempCanvas.width,
-              tempCanvas.height,
-              0,
-              0,
-              element.width,
-              element.height,
-            );
-          }
-        } else {
-          if (shouldInvertImage) {
-            context.filter = DARK_THEME_FILTER;
-          }
-
-          context.drawImage(
-            img,
-            x,
-            y,
-            width,
-            height,
-            0 /* hardcoded for the selection box*/,
-            0,
-            element.width,
-            element.height,
-          );
-        }
+        context.drawImage(
+          img,
+          x,
+          y,
+          width,
+          height,
+          0 /* hardcoded for the selection box*/,
+          0,
+          element.width,
+          element.height,
+        );
       } else {
-        drawImagePlaceholder(element, context, renderConfig.theme);
+        drawImagePlaceholder(element, context);
       }
-      context.restore();
       break;
     }
     default: {
@@ -555,10 +506,7 @@ const drawElementOnCanvas = (
         context.canvas.setAttribute("dir", rtl ? "rtl" : "ltr");
         context.save();
         context.font = getFontString(element);
-        context.fillStyle = applyDarkModeFilter(
-          element.strokeColor,
-          renderConfig.theme === THEME.DARK,
-        );
+        context.fillStyle = element.strokeColor;
         context.textAlign = element.textAlign as CanvasTextAlign;
 
         // Canvas does not support multiline text by default
@@ -811,17 +759,12 @@ export const renderElement = (
         context.fillStyle = "rgba(0, 0, 200, 0.04)";
 
         context.lineWidth = FRAME_STYLE.strokeWidth / appState.zoom.value;
-        context.strokeStyle = applyDarkModeFilter(
-          FRAME_STYLE.strokeColor,
-          appState.theme === THEME.DARK,
-        );
+        context.strokeStyle = FRAME_STYLE.strokeColor;
 
         // TODO change later to only affect AI frames
         if (isMagicFrameElement(element)) {
           context.strokeStyle =
-            appState.theme === THEME.LIGHT
-              ? "#7affd7"
-              : applyDarkModeFilter("#1d8264");
+            appState.theme === THEME.LIGHT ? "#7affd7" : "#1d8264";
         }
 
         if (FRAME_STYLE.radius && context.roundRect) {
@@ -844,6 +787,11 @@ export const renderElement = (
       break;
     }
     case "freedraw": {
+      // TODO investigate if we can do this in situ. Right now we need to call
+      // beforehand because math helpers (such as getElementAbsoluteCoords)
+      // rely on existing shapes
+      ShapeCache.generateElementShape(element, null);
+
       if (renderConfig.isExporting) {
         const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
         const cx = (x1 + x2) / 2 + appState.scrollX;
@@ -887,12 +835,14 @@ export const renderElement = (
     case "text":
     case "iframe":
     case "embeddable": {
+      // TODO investigate if we can do this in situ. Right now we need to call
+      // beforehand because math helpers (such as getElementAbsoluteCoords)
+      // rely on existing shapes
+      ShapeCache.generateElementShape(element, renderConfig);
       if (renderConfig.isExporting) {
         const [x1, y1, x2, y2] = getElementAbsoluteCoords(element, elementsMap);
-        const centerX = (x1 + x2) / 2;
-        const centerY = (y1 + y2) / 2;
-        const cx = centerX + appState.scrollX;
-        const cy = centerY + appState.scrollY;
+        const cx = (x1 + x2) / 2 + appState.scrollX;
+        const cy = (y1 + y2) / 2 + appState.scrollY;
         let shiftX = (x2 - x1) / 2 - (element.x - x1);
         let shiftY = (y2 - y1) / 2 - (element.y - y1);
         if (isTextElement(element)) {
@@ -911,52 +861,70 @@ export const renderElement = (
         context.save();
         context.translate(cx, cy);
 
+        if (shouldResetImageFilter(element, renderConfig, appState)) {
+          context.filter = "none";
+        }
         const boundTextElement = getBoundTextElement(element, elementsMap);
 
         if (isArrowElement(element) && boundTextElement) {
-          // Draw arrow directly as vector and clear label hole separately.
-          // This avoids temp-canvas bitmap blit which introduces resampling blur.
+          const tempCanvas = document.createElement("canvas");
+
+          const tempCanvasContext = tempCanvas.getContext("2d")!;
+
+          // Take max dimensions of arrow canvas so that when canvas is rotated
+          // the arrow doesn't get clipped
+          const maxDim = Math.max(distance(x1, x2), distance(y1, y2));
+          const padding = getCanvasPadding(element);
+          tempCanvas.width =
+            maxDim * appState.exportScale + padding * 10 * appState.exportScale;
+          tempCanvas.height =
+            maxDim * appState.exportScale + padding * 10 * appState.exportScale;
+
+          tempCanvasContext.translate(
+            tempCanvas.width / 2,
+            tempCanvas.height / 2,
+          );
+          tempCanvasContext.scale(appState.exportScale, appState.exportScale);
+
+          // Shift the canvas to left most point of the arrow
           shiftX = element.width / 2 - (element.x - x1);
           shiftY = element.height / 2 - (element.y - y1);
 
-          context.save();
-          context.rotate(element.angle);
-          context.translate(-shiftX, -shiftY);
-          drawElementOnCanvas(element, rc, context, renderConfig);
-          context.restore();
+          tempCanvasContext.rotate(element.angle);
+          const tempRc = rough.canvas(tempCanvas);
 
+          tempCanvasContext.translate(-shiftX, -shiftY);
+
+          drawElementOnCanvas(element, tempRc, tempCanvasContext, renderConfig);
+
+          tempCanvasContext.translate(shiftX, shiftY);
+
+          tempCanvasContext.rotate(-element.angle);
+
+          // Shift the canvas to center of bound text
           const [, , , , boundTextCx, boundTextCy] = getElementAbsoluteCoords(
             boundTextElement,
             elementsMap,
           );
-          const holeX =
-            boundTextCx -
-            centerX -
-            boundTextElement.width / 2 -
-            BOUND_TEXT_PADDING;
-          const holeY =
-            boundTextCy -
-            centerY -
-            boundTextElement.height / 2 -
-            BOUND_TEXT_PADDING;
-          const holeWidth = boundTextElement.width + BOUND_TEXT_PADDING * 2;
-          const holeHeight = boundTextElement.height + BOUND_TEXT_PADDING * 2;
+          const boundTextShiftX = (x1 + x2) / 2 - boundTextCx;
+          const boundTextShiftY = (y1 + y2) / 2 - boundTextCy;
+          tempCanvasContext.translate(-boundTextShiftX, -boundTextShiftY);
 
-          const isTransparentHole =
-            "viewBackgroundColor" in appState &&
-            (appState.viewBackgroundColor === "transparent" ||
-              !appState.viewBackgroundColor);
-          if (!isTransparentHole) {
-            context.save();
-            context.fillStyle = applyDarkModeFilter(
-              renderConfig.canvasBackgroundColor,
-              renderConfig.theme === THEME.DARK,
-            );
-            context.fillRect(holeX, holeY, holeWidth, holeHeight);
-            context.restore();
-          } else {
-            context.clearRect(holeX, holeY, holeWidth, holeHeight);
-          }
+          // Clear the bound text area
+          tempCanvasContext.clearRect(
+            -boundTextElement.width / 2,
+            -boundTextElement.height / 2,
+            boundTextElement.width,
+            boundTextElement.height,
+          );
+          context.scale(1 / appState.exportScale, 1 / appState.exportScale);
+          context.drawImage(
+            tempCanvas,
+            -tempCanvas.width / 2,
+            -tempCanvas.height / 2,
+            tempCanvas.width,
+            tempCanvas.height,
+          );
         } else {
           context.rotate(element.angle);
 
@@ -1058,6 +1026,23 @@ export const renderElement = (
   context.globalAlpha = 1;
 };
 
+export const pathsCache = new WeakMap<ExcalidrawFreeDrawElement, Path2D>([]);
+
+export function generateFreeDrawShape(element: ExcalidrawFreeDrawElement) {
+  const svgPathData = getFreeDrawSvgPath(element);
+  const path = new Path2D(svgPathData);
+  pathsCache.set(element, path);
+  return path;
+}
+
+export function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement) {
+  return pathsCache.get(element);
+}
+
+export function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement) {
+  return getSvgPathFromStroke(getFreedrawOutlinePoints(element));
+}
+
 export function getFreedrawOutlineAsSegments(
   element: ExcalidrawFreeDrawElement,
   points: [number, number][],
@@ -1113,3 +1098,57 @@ export function getFreedrawOutlineAsSegments(
     ],
   );
 }
+
+export function getFreedrawOutlinePoints(element: ExcalidrawFreeDrawElement) {
+  // If input points are empty (should they ever be?) return a dot
+  const inputPoints = element.simulatePressure
+    ? element.points
+    : element.points.length
+    ? element.points.map(([x, y], i) => [x, y, element.pressures[i]])
+    : [[0, 0, 0.5]];
+
+  // Consider changing the options for simulated pressure vs real pressure
+  const options: StrokeOptions = {
+    simulatePressure: element.simulatePressure,
+    size: element.strokeWidth * 4.25,
+    thinning: 0.6,
+    smoothing: 0.5,
+    streamline: 0.5,
+    easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
+    last: true,
+  };
+
+  return getStroke(inputPoints as number[][], options) as [number, number][];
+}
+
+function med(A: number[], B: number[]) {
+  return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
+}
+
+// Trim SVG path data so number are each two decimal points. This
+// improves SVG exports, and prevents rendering errors on points
+// with long decimals.
+const TO_FIXED_PRECISION = /(\s?[A-Z]?,?-?[0-9]*\.[0-9]{0,2})(([0-9]|e|-)*)/g;
+
+function getSvgPathFromStroke(points: number[][]): string {
+  if (!points.length) {
+    return "";
+  }
+
+  const max = points.length - 1;
+
+  return points
+    .reduce(
+      (acc, point, i, arr) => {
+        if (i === max) {
+          acc.push(point, med(point, arr[0]), "L", arr[0], "Z");
+        } else {
+          acc.push(point, med(point, arr[i + 1]));
+        }
+        return acc;
+      },
+      ["M", points[0], "Q"],
+    )
+    .join(" ")
+    .replace(TO_FIXED_PRECISION, "$1");
+}

packages/element/src/resizeTest.ts

@@ -13,7 +13,6 @@ import {
 import type { GlobalPoint, LineSegment, LocalPoint } from "@excalidraw/math";
 
 import type { AppState, Zoom } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "@excalidraw/common";
 
 import { getElementAbsoluteCoords } from "./bounds";
 import {
@@ -24,6 +23,7 @@ import {
 } from "./transformHandles";
 import { isImageElement, isLinearElement } from "./typeChecks";
 
+import type { Bounds } from "./bounds";
 import type {
   TransformHandleType,
   TransformHandle,

packages/element/src/selection.ts

@@ -1,20 +1,22 @@
-import { arrayToMap, isShallowEqual, type Bounds } from "@excalidraw/common";
+import { arrayToMap, isShallowEqual } from "@excalidraw/common";
 
 import type {
   AppState,
-  BoxSelectionMode,
   InteractiveCanvasAppState,
 } from "@excalidraw/excalidraw/types";
 
-import { elementsOverlappingBBox, getElementAbsoluteCoords } from "./bounds";
+import { getElementAbsoluteCoords, getElementBounds } from "./bounds";
 import { isElementInViewport } from "./sizeHelpers";
 import {
   isBoundToContainer,
   isFrameLikeElement,
   isLinearElement,
-  isTextElement,
 } from "./typeChecks";
-import { getFrameChildren } from "./frame";
+import {
+  elementOverlapsWithFrame,
+  getContainingFrame,
+  getFrameChildren,
+} from "./frame";
 
 import { LinearElementEditor } from "./linearElementEditor";
 import { selectGroupsForSelectedElements } from "./groups";
@@ -23,27 +25,9 @@ import type {
   ElementsMap,
   ElementsMapOrArray,
   ExcalidrawElement,
-  ExcalidrawFrameLikeElement,
-  NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./types";
 
-const shouldIgnoreElementFromSelection = (
-  element: NonDeletedExcalidrawElement,
-) => element.locked || isBoundToContainer(element);
-
-const excludeElementsFromFrames = <T extends ExcalidrawElement>(
-  selectedElements: readonly T[],
-  framesInSelection: Set<ExcalidrawFrameLikeElement["id"]>,
-) => {
-  return selectedElements.filter((element) => {
-    if (element.frameId && framesInSelection.has(element.frameId)) {
-      return false;
-    }
-    return true;
-  });
-};
-
 /**
  * Frames and their containing elements are not to be selected at the same time.
  * Given an array of selected elements, if there are frames and their containing elements
@@ -63,38 +47,68 @@ export const excludeElementsInFramesFromSelection = <
     }
   });
 
-  return excludeElementsFromFrames(selectedElements, framesInSelection);
+  return selectedElements.filter((element) => {
+    if (element.frameId && framesInSelection.has(element.frameId)) {
+      return false;
+    }
+    return true;
+  });
 };
 
 export const getElementsWithinSelection = (
   elements: readonly NonDeletedExcalidrawElement[],
   selection: NonDeletedExcalidrawElement,
   elementsMap: ElementsMap,
-  // TODO remove (this flag is effectively unused AFAIK)
   excludeElementsInFrames: boolean = true,
-  boxSelectionMode: BoxSelectionMode = "contain",
-): NonDeletedExcalidrawElement[] => {
-  const [selectionStartX, selectionStartY, selectionEndX, selectionEndY] =
+) => {
+  const [selectionX1, selectionY1, selectionX2, selectionY2] =
     getElementAbsoluteCoords(selection, elementsMap);
-  const selectionX1 = Math.min(selectionStartX, selectionEndX);
-  const selectionY1 = Math.min(selectionStartY, selectionEndY);
-  const selectionX2 = Math.max(selectionStartX, selectionEndX);
-  const selectionY2 = Math.max(selectionStartY, selectionEndY);
-  const selectionBounds = [
-    selectionX1,
-    selectionY1,
-    selectionX2,
-    selectionY2,
-  ] as Bounds;
 
-  return elementsOverlappingBBox({
-    elements,
-    bounds: selectionBounds,
-    elementsMap,
-    type: boxSelectionMode,
-    shouldIgnoreElementFromSelection,
-    excludeElementsInFrames,
+  let elementsInSelection = elements.filter((element) => {
+    let [elementX1, elementY1, elementX2, elementY2] = getElementBounds(
+      element,
+      elementsMap,
+    );
+
+    const containingFrame = getContainingFrame(element, elementsMap);
+    if (containingFrame) {
+      const [fx1, fy1, fx2, fy2] = getElementBounds(
+        containingFrame,
+        elementsMap,
+      );
+
+      elementX1 = Math.max(fx1, elementX1);
+      elementY1 = Math.max(fy1, elementY1);
+      elementX2 = Math.min(fx2, elementX2);
+      elementY2 = Math.min(fy2, elementY2);
+    }
+
+    return (
+      element.locked === false &&
+      element.type !== "selection" &&
+      !isBoundToContainer(element) &&
+      selectionX1 <= elementX1 &&
+      selectionY1 <= elementY1 &&
+      selectionX2 >= elementX2 &&
+      selectionY2 >= elementY2
+    );
   });
+
+  elementsInSelection = excludeElementsInFrames
+    ? excludeElementsInFramesFromSelection(elementsInSelection)
+    : elementsInSelection;
+
+  elementsInSelection = elementsInSelection.filter((element) => {
+    const containingFrame = getContainingFrame(element, elementsMap);
+
+    if (containingFrame) {
+      return elementOverlapsWithFrame(element, containingFrame, elementsMap);
+    }
+
+    return true;
+  });
+
+  return elementsInSelection;
 };
 
 export const getVisibleAndNonSelectedElements = (
@@ -274,19 +288,3 @@ export const getSelectionStateForElements = (
     ),
   };
 };
-
-/**
- * Returns editing or single-selected text element, if any.
- */
-export const getActiveTextElement = (
-  selectedElements: readonly NonDeleted<ExcalidrawElement>[],
-  appState: Pick<AppState, "editingTextElement">,
-) => {
-  const activeTextElement =
-    appState.editingTextElement ||
-    (selectedElements.length === 1 &&
-      isTextElement(selectedElements[0]) &&
-      selectedElements[0]);
-
-  return activeTextElement || null;
-};

packages/element/src/shape.ts

@@ -1,6 +1,4 @@
 import { simplify } from "points-on-curve";
-import { getStroke } from "perfect-freehand";
-import { LaserPointer } from "@excalidraw/laser-pointer";
 
 import {
   type GeometricShape,
@@ -19,13 +17,10 @@ import {
 } from "@excalidraw/math";
 import {
   ROUGHNESS,
-  THEME,
   isTransparent,
   assertNever,
   COLOR_PALETTE,
   LINE_POLYGON_POINT_MERGE_DISTANCE,
-  applyDarkModeFilter,
-  DEFAULT_STROKE_STREAMLINE,
 } from "@excalidraw/common";
 
 import { RoughGenerator } from "roughjs/bin/generator";
@@ -41,7 +36,6 @@ import type {
 import type {
   ElementShape,
   ElementShapes,
-  SVGPathString,
 } from "@excalidraw/excalidraw/scene/types";
 
 import { elementWithCanvasCache } from "./renderElement";
@@ -58,9 +52,10 @@ import { getCornerRadius, isPathALoop } from "./utils";
 import { headingForPointIsHorizontal } from "./heading";
 
 import { canChangeRoundness } from "./comparisons";
+import { generateFreeDrawShape } from "./renderElement";
 import {
-  elementCenterPoint,
   getArrowheadPoints,
+  getCenterForBounds,
   getDiamondPoints,
   getElementAbsoluteCoords,
 } from "./bounds";
@@ -71,10 +66,10 @@ import type {
   NonDeletedExcalidrawElement,
   ExcalidrawSelectionElement,
   ExcalidrawLinearElement,
+  Arrowhead,
   ExcalidrawFreeDrawElement,
   ElementsMap,
   ExcalidrawLineElement,
-  Arrowhead,
 } from "./types";
 
 import type { Drawable, Options } from "roughjs/bin/core";
@@ -82,32 +77,29 @@ import type { Point as RoughPoint } from "roughjs/bin/geometry";
 
 export class ShapeCache {
   private static rg = new RoughGenerator();
-  private static cache = new WeakMap<
-    ExcalidrawElement,
-    { shape: ElementShape; theme: AppState["theme"] }
-  >();
+  private static cache = new WeakMap<ExcalidrawElement, ElementShape>();
 
   /**
    * Retrieves shape from cache if available. Use this only if shape
    * is optional and you have a fallback in case it's not cached.
    */
-  public static get = <T extends ExcalidrawElement>(
-    element: T,
-    theme: AppState["theme"] | null,
-  ) => {
-    const cached = ShapeCache.cache.get(element);
-    if (cached && (theme === null || cached.theme === theme)) {
-      return cached.shape as T["type"] extends keyof ElementShapes
-        ? ElementShapes[T["type"]] | undefined
-        : ElementShape | undefined;
-    }
-    return undefined;
+  public static get = <T extends ExcalidrawElement>(element: T) => {
+    return ShapeCache.cache.get(
+      element,
+    ) as T["type"] extends keyof ElementShapes
+      ? ElementShapes[T["type"]] | undefined
+      : ElementShape | undefined;
   };
 
-  public static delete = (element: ExcalidrawElement) => {
+  public static set = <T extends ExcalidrawElement>(
+    element: T,
+    shape: T["type"] extends keyof ElementShapes
+      ? ElementShapes[T["type"]]
+      : Drawable,
+  ) => ShapeCache.cache.set(element, shape);
+
+  public static delete = (element: ExcalidrawElement) =>
     ShapeCache.cache.delete(element);
-    elementWithCanvasCache.delete(element);
-  };
 
   public static destroy = () => {
     ShapeCache.cache = new WeakMap();
@@ -125,13 +117,12 @@ export class ShapeCache {
       isExporting: boolean;
       canvasBackgroundColor: AppState["viewBackgroundColor"];
       embedsValidationStatus: EmbedsValidationStatus;
-      theme: AppState["theme"];
     } | null,
   ) => {
     // when exporting, always regenerated to guarantee the latest shape
     const cachedShape = renderConfig?.isExporting
       ? undefined
-      : ShapeCache.get(element, renderConfig ? renderConfig.theme : null);
+      : ShapeCache.get(element);
 
     // `null` indicates no rc shape applicable for this element type,
     // but it's considered a valid cache value (= do not regenerate)
@@ -141,25 +132,19 @@ export class ShapeCache {
 
     elementWithCanvasCache.delete(element);
 
-    const shape = _generateElementShape(
+    const shape = generateElementShape(
       element,
       ShapeCache.rg,
       renderConfig || {
         isExporting: false,
         canvasBackgroundColor: COLOR_PALETTE.white,
         embedsValidationStatus: null,
-        theme: THEME.LIGHT,
       },
     ) as T["type"] extends keyof ElementShapes
       ? ElementShapes[T["type"]]
       : Drawable | null;
 
-    if (!renderConfig?.isExporting) {
-      ShapeCache.cache.set(element, {
-        shape,
-        theme: renderConfig?.theme || THEME.LIGHT,
-      });
-    }
+    ShapeCache.cache.set(element, shape);
 
     return shape;
   };
@@ -195,7 +180,6 @@ function adjustRoughness(element: ExcalidrawElement): number {
 export const generateRoughOptions = (
   element: ExcalidrawElement,
   continuousPath = false,
-  isDarkMode: boolean = false,
 ): Options => {
   const options: Options = {
     seed: element.seed,
@@ -220,7 +204,7 @@ export const generateRoughOptions = (
     fillWeight: element.strokeWidth / 2,
     hachureGap: element.strokeWidth * 4,
     roughness: adjustRoughness(element),
-    stroke: applyDarkModeFilter(element.strokeColor, isDarkMode),
+    stroke: element.strokeColor,
     preserveVertices:
       continuousPath || element.roughness < ROUGHNESS.cartoonist,
   };
@@ -234,7 +218,7 @@ export const generateRoughOptions = (
       options.fillStyle = element.fillStyle;
       options.fill = isTransparent(element.backgroundColor)
         ? undefined
-        : applyDarkModeFilter(element.backgroundColor, isDarkMode);
+        : element.backgroundColor;
       if (element.type === "ellipse") {
         options.curveFitting = 1;
       }
@@ -247,7 +231,7 @@ export const generateRoughOptions = (
         options.fill =
           element.backgroundColor === "transparent"
             ? undefined
-            : applyDarkModeFilter(element.backgroundColor, isDarkMode);
+            : element.backgroundColor;
       }
       return options;
     }
@@ -292,82 +276,6 @@ const modifyIframeLikeForRoughOptions = (
   return element;
 };
 
-const generateArrowheadCardinalityOne = (
-  generator: RoughGenerator,
-  arrowheadPoints: number[] | null,
-  lineOptions: Options,
-) => {
-  if (arrowheadPoints === null) {
-    return [];
-  }
-
-  const [, , x3, y3, x4, y4] = arrowheadPoints;
-
-  return [generator.line(x3, y3, x4, y4, lineOptions)];
-};
-
-const generateArrowheadLinesToTip = (
-  generator: RoughGenerator,
-  arrowheadPoints: number[] | null,
-  lineOptions: Options,
-) => {
-  if (arrowheadPoints === null) {
-    return [];
-  }
-
-  const [x2, y2, x3, y3, x4, y4] = arrowheadPoints;
-
-  return [
-    generator.line(x3, y3, x2, y2, lineOptions),
-    generator.line(x4, y4, x2, y2, lineOptions),
-  ];
-};
-
-const getArrowheadLineOptions = (
-  element: ExcalidrawLinearElement,
-  options: Options,
-) => {
-  const lineOptions = { ...options };
-
-  if (element.strokeStyle === "dotted") {
-    // for dotted arrows caps, reduce gap to make it more legible
-    const dash = getDashArrayDotted(element.strokeWidth - 1);
-    lineOptions.strokeLineDash = [dash[0], dash[1] - 1];
-  } else {
-    // for solid/dashed, keep solid arrow cap
-    delete lineOptions.strokeLineDash;
-  }
-  lineOptions.roughness = Math.min(1, lineOptions.roughness || 0);
-
-  return lineOptions;
-};
-
-const generateArrowheadOutlineCircle = (
-  generator: RoughGenerator,
-  options: Options,
-  strokeColor: string,
-  arrowheadPoints: number[] | null,
-  fill: string,
-  diameterScale = 1,
-) => {
-  if (arrowheadPoints === null) {
-    return [];
-  }
-
-  const [x, y, diameter] = arrowheadPoints;
-  const circleOptions = {
-    ...options,
-    fill,
-    fillStyle: "solid" as const,
-    stroke: strokeColor,
-    roughness: Math.min(0.5, options.roughness || 0),
-  };
-
-  delete circleOptions.strokeLineDash;
-
-  return [generator.circle(x, y, diameter * diameterScale, circleOptions)];
-};
-
 const getArrowheadShapes = (
   element: ExcalidrawLinearElement,
   shape: Drawable[],
@@ -376,55 +284,60 @@ const getArrowheadShapes = (
   generator: RoughGenerator,
   options: Options,
   canvasBackgroundColor: string,
-  isDarkMode: boolean,
 ) => {
-  if (arrowhead === null) {
+  const arrowheadPoints = getArrowheadPoints(
+    element,
+    shape,
+    position,
+    arrowhead,
+  );
+
+  if (arrowheadPoints === null) {
     return [];
   }
 
-  const strokeColor = applyDarkModeFilter(element.strokeColor, isDarkMode);
-  const backgroundFillColor = applyDarkModeFilter(
-    canvasBackgroundColor,
-    isDarkMode,
-  );
-  const cardinalityOneOrManyOffset = -0.25;
-  const cardinalityZeroCircleScale = 0.8;
+  const generateCrowfootOne = (
+    arrowheadPoints: number[] | null,
+    options: Options,
+  ) => {
+    if (arrowheadPoints === null) {
+      return [];
+    }
+
+    const [, , x3, y3, x4, y4] = arrowheadPoints;
+
+    return [generator.line(x3, y3, x4, y4, options)];
+  };
 
   switch (arrowhead) {
+    case "dot":
     case "circle":
     case "circle_outline": {
-      return generateArrowheadOutlineCircle(
-        generator,
-        options,
-        strokeColor,
-        getArrowheadPoints(element, shape, position, arrowhead),
-        arrowhead === "circle_outline" ? backgroundFillColor : strokeColor,
-      );
+      const [x, y, diameter] = arrowheadPoints;
+
+      // always use solid stroke for arrowhead
+      delete options.strokeLineDash;
+
+      return [
+        generator.circle(x, y, diameter, {
+          ...options,
+          fill:
+            arrowhead === "circle_outline"
+              ? canvasBackgroundColor
+              : element.strokeColor,
+
+          fillStyle: "solid",
+          stroke: element.strokeColor,
+          roughness: Math.min(0.5, options.roughness || 0),
+        }),
+      ];
     }
     case "triangle":
     case "triangle_outline": {
-      const arrowheadPoints = getArrowheadPoints(
-        element,
-        shape,
-        position,
-        arrowhead,
-      );
-
-      if (arrowheadPoints === null) {
-        return [];
-      }
-
       const [x, y, x2, y2, x3, y3] = arrowheadPoints;
-      const triangleOptions = {
-        ...options,
-        fill:
-          arrowhead === "triangle_outline" ? backgroundFillColor : strokeColor,
-        fillStyle: "solid" as const,
-        roughness: Math.min(1, options.roughness || 0),
-      };
 
       // always use solid stroke for arrowhead
-      delete triangleOptions.strokeLineDash;
+      delete options.strokeLineDash;
 
       return [
         generator.polygon(
@@ -434,34 +347,24 @@ const getArrowheadShapes = (
             [x3, y3],
             [x, y],
           ],
-          triangleOptions,
+          {
+            ...options,
+            fill:
+              arrowhead === "triangle_outline"
+                ? canvasBackgroundColor
+                : element.strokeColor,
+            fillStyle: "solid",
+            roughness: Math.min(1, options.roughness || 0),
+          },
         ),
       ];
     }
     case "diamond":
     case "diamond_outline": {
-      const arrowheadPoints = getArrowheadPoints(
-        element,
-        shape,
-        position,
-        arrowhead,
-      );
-
-      if (arrowheadPoints === null) {
-        return [];
-      }
-
       const [x, y, x2, y2, x3, y3, x4, y4] = arrowheadPoints;
-      const diamondOptions = {
-        ...options,
-        fill:
-          arrowhead === "diamond_outline" ? backgroundFillColor : strokeColor,
-        fillStyle: "solid" as const,
-        roughness: Math.min(1, options.roughness || 0),
-      };
 
       // always use solid stroke for arrowhead
-      delete diamondOptions.strokeLineDash;
+      delete options.strokeLineDash;
 
       return [
         generator.polygon(
@@ -472,117 +375,53 @@ const getArrowheadShapes = (
             [x4, y4],
             [x, y],
           ],
-          diamondOptions,
-        ),
-      ];
-    }
-    case "cardinality_one":
-      return generateArrowheadCardinalityOne(
-        generator,
-        getArrowheadPoints(element, shape, position, arrowhead),
-        getArrowheadLineOptions(element, options),
-      );
-    case "cardinality_many":
-      return generateArrowheadLinesToTip(
-        generator,
-        getArrowheadPoints(element, shape, position, arrowhead),
-        getArrowheadLineOptions(element, options),
-      );
-    case "cardinality_one_or_many": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadLinesToTip(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_many"),
-          lineOptions,
-        ),
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(
-            element,
-            shape,
-            position,
-            "cardinality_one",
-            cardinalityOneOrManyOffset,
-          ),
-          lineOptions,
-        ),
-      ];
-    }
-    case "cardinality_exactly_one": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_one", -0.5),
-          lineOptions,
-        ),
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_one"),
-          lineOptions,
-        ),
-      ];
-    }
-    case "cardinality_zero_or_one": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadOutlineCircle(
-          generator,
-          options,
-          strokeColor,
-          getArrowheadPoints(element, shape, position, "circle_outline", 1.5),
-          backgroundFillColor,
-          cardinalityZeroCircleScale,
-        ),
-        ...generateArrowheadCardinalityOne(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_one", -0.5),
-          lineOptions,
-        ),
-      ];
-    }
-    case "cardinality_zero_or_many": {
-      const lineOptions = getArrowheadLineOptions(element, options);
-
-      return [
-        ...generateArrowheadLinesToTip(
-          generator,
-          getArrowheadPoints(element, shape, position, "cardinality_many"),
-          lineOptions,
-        ),
-        ...generateArrowheadOutlineCircle(
-          generator,
-          options,
-          strokeColor,
-          getArrowheadPoints(element, shape, position, "circle_outline", 1.5),
-          backgroundFillColor,
-          cardinalityZeroCircleScale,
+          {
+            ...options,
+            fill:
+              arrowhead === "diamond_outline"
+                ? canvasBackgroundColor
+                : element.strokeColor,
+            fillStyle: "solid",
+            roughness: Math.min(1, options.roughness || 0),
+          },
         ),
       ];
     }
+    case "crowfoot_one":
+      return generateCrowfootOne(arrowheadPoints, options);
     case "bar":
     case "arrow":
+    case "crowfoot_many":
+    case "crowfoot_one_or_many":
     default: {
-      return generateArrowheadLinesToTip(
-        generator,
-        getArrowheadPoints(element, shape, position, arrowhead),
-        getArrowheadLineOptions(element, options),
-      );
+      const [x2, y2, x3, y3, x4, y4] = arrowheadPoints;
+
+      if (element.strokeStyle === "dotted") {
+        // for dotted arrows caps, reduce gap to make it more legible
+        const dash = getDashArrayDotted(element.strokeWidth - 1);
+        options.strokeLineDash = [dash[0], dash[1] - 1];
+      } else {
+        // for solid/dashed, keep solid arrow cap
+        delete options.strokeLineDash;
+      }
+      options.roughness = Math.min(1, options.roughness || 0);
+      return [
+        generator.line(x3, y3, x2, y2, options),
+        generator.line(x4, y4, x2, y2, options),
+        ...(arrowhead === "crowfoot_one_or_many"
+          ? generateCrowfootOne(
+              getArrowheadPoints(element, shape, position, "crowfoot_one"),
+              options,
+            )
+          : []),
+      ];
     }
   }
 };
 
 export const generateLinearCollisionShape = (
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
-): {
-  op: string;
-  data: number[];
-}[] => {
+) => {
   const generator = new RoughGenerator();
   const options: Options = {
     seed: element.seed,
@@ -591,7 +430,20 @@ export const generateLinearCollisionShape = (
     roughness: 0,
     preserveVertices: true,
   };
-  const center = elementCenterPoint(element, elementsMap);
+  const center = getCenterForBounds(
+    // Need a non-rotated center point
+    element.points.reduce(
+      (acc, point) => {
+        return [
+          Math.min(element.x + point[0], acc[0]),
+          Math.min(element.y + point[1], acc[1]),
+          Math.max(element.x + point[0], acc[2]),
+          Math.max(element.y + point[1], acc[3]),
+        ];
+      },
+      [Infinity, Infinity, -Infinity, -Infinity],
+    ),
+  );
 
   switch (element.type) {
     case "line":
@@ -750,22 +602,19 @@ export const generateLinearCollisionShape = (
  *
  * @private
  */
-const _generateElementShape = (
+const generateElementShape = (
   element: Exclude<NonDeletedExcalidrawElement, ExcalidrawSelectionElement>,
   generator: RoughGenerator,
   {
     isExporting,
     canvasBackgroundColor,
     embedsValidationStatus,
-    theme,
   }: {
     isExporting: boolean;
     canvasBackgroundColor: string;
     embedsValidationStatus: EmbedsValidationStatus | null;
-    theme?: AppState["theme"];
   },
-): ElementShape => {
-  const isDarkMode = theme === THEME.DARK;
+): Drawable | Drawable[] | null => {
   switch (element.type) {
     case "rectangle":
     case "iframe":
@@ -791,7 +640,6 @@ const _generateElementShape = (
               embedsValidationStatus,
             ),
             true,
-            isDarkMode,
           ),
         );
       } else {
@@ -807,7 +655,6 @@ const _generateElementShape = (
               embedsValidationStatus,
             ),
             false,
-            isDarkMode,
           ),
         );
       }
@@ -845,7 +692,7 @@ const _generateElementShape = (
             C ${topX} ${topY}, ${topX} ${topY}, ${topX + verticalRadius} ${
             topY + horizontalRadius
           }`,
-          generateRoughOptions(element, true, isDarkMode),
+          generateRoughOptions(element, true),
         );
       } else {
         shape = generator.polygon(
@@ -855,7 +702,7 @@ const _generateElementShape = (
             [bottomX, bottomY],
             [leftX, leftY],
           ],
-          generateRoughOptions(element, false, isDarkMode),
+          generateRoughOptions(element),
         );
       }
       return shape;
@@ -866,14 +713,14 @@ const _generateElementShape = (
         element.height / 2,
         element.width,
         element.height,
-        generateRoughOptions(element, false, isDarkMode),
+        generateRoughOptions(element),
       );
       return shape;
     }
     case "line":
     case "arrow": {
       let shape: ElementShapes[typeof element.type];
-      const options = generateRoughOptions(element, false, isDarkMode);
+      const options = generateRoughOptions(element);
 
       // points array can be empty in the beginning, so it is important to add
       // initial position to it
@@ -898,7 +745,7 @@ const _generateElementShape = (
           shape = [
             generator.path(
               generateElbowArrowShape(points, 16),
-              generateRoughOptions(element, true, isDarkMode),
+              generateRoughOptions(element, true),
             ),
           ];
         }
@@ -931,7 +778,6 @@ const _generateElementShape = (
             generator,
             options,
             canvasBackgroundColor,
-            isDarkMode,
           );
           shape.push(...shapes);
         }
@@ -949,7 +795,6 @@ const _generateElementShape = (
             generator,
             options,
             canvasBackgroundColor,
-            isDarkMode,
           );
           shape.push(...shapes);
         }
@@ -957,28 +802,23 @@ const _generateElementShape = (
       return shape;
     }
     case "freedraw": {
-      // oredered in terms of z-index [background, stroke]
-      const shapes: ElementShapes[typeof element.type] = [];
+      let shape: ElementShapes[typeof element.type];
+      generateFreeDrawShape(element);
 
-      // (1) background fill (rc shape), optional
       if (isPathALoop(element.points)) {
         // generate rough polygon to fill freedraw shape
         const simplifiedPoints = simplify(
           element.points as Mutable<LocalPoint[]>,
           0.75,
         );
-        shapes.push(
-          generator.curve(simplifiedPoints as [number, number][], {
-            ...generateRoughOptions(element, false, isDarkMode),
-            stroke: "none",
-          }),
-        );
+        shape = generator.curve(simplifiedPoints as [number, number][], {
+          ...generateRoughOptions(element),
+          stroke: "none",
+        });
+      } else {
+        shape = null;
       }
-
-      // (2) stroke
-      shapes.push(getFreeDrawSvgPath(element));
-
-      return shapes;
+      return shape;
     }
     case "frame":
     case "magicframe":
@@ -1085,7 +925,9 @@ export const getElementShape = <Point extends GlobalPoint | LocalPoint>(
       return getPolygonShape(element);
     case "arrow":
     case "line": {
-      const roughShape = ShapeCache.generateElementShape(element, null)[0];
+      const roughShape =
+        ShapeCache.get(element)?.[0] ??
+        ShapeCache.generateElementShape(element, null)[0];
       const [, , , , cx, cy] = getElementAbsoluteCoords(element, elementsMap);
 
       return shouldTestInside(element)
@@ -1161,129 +1003,3 @@ export const toggleLinePolygonState = (
 
   return ret;
 };
-
-// -----------------------------------------------------------------------------
-//                         freedraw shape helper
-// -----------------------------------------------------------------------------
-
-// NOTE not cached (-> for SVG export)
-const getFreeDrawSvgPath = (element: ExcalidrawFreeDrawElement) => {
-  return getSvgPathFromStroke(
-    getFreedrawOutlinePoints(element),
-  ) as SVGPathString;
-};
-
-/**
- * Freedraw stroke geometry tuning constants.
- *
- * These factors are not derived analytically — they were tuned empirically by
- * visually comparing rendered strokes until they matched the desired feel.
- * Treat them as magic numbers backed by visual verification.
- */
-const VARIABLE_WIDTH_FREEDRAW = {
-  /** Stroke size relative to `strokeWidth` for pressure-sensitive strokes. */
-  SIZE_FACTOR: 4.25,
-  THINNING: 0.6,
-  SMOOTHING: 0.5,
-} as const;
-
-const CONSTANT_WIDTH_FREEDRAW = {
-  /** Stroke size relative to `strokeWidth` for uniform (laser) strokes. */
-  SIZE_FACTOR: 1.4,
-} as const;
-
-const getFreedrawStreamline = (element: ExcalidrawFreeDrawElement) =>
-  element.strokeOptions?.streamline ?? DEFAULT_STROKE_STREAMLINE;
-
-/**
- * Pressure-sensitive (variable width) freedraw outline, rendered with
- * perfect-freehand. This is the original Excalidraw freedraw look.
- */
-const getVariableWidthFreedrawOutline = (
-  element: ExcalidrawFreeDrawElement,
-): [number, number][] => {
-  // If input points are empty (should they ever be?) return a dot
-  const inputPoints = element.simulatePressure
-    ? element.points
-    : element.points.length
-    ? element.points.map(
-        ([x, y], i) => [x, y, element.pressures[i]] as [number, number, number],
-      )
-    : [[0, 0, 0.5]];
-
-  return getStroke(inputPoints as number[][], {
-    simulatePressure: element.simulatePressure,
-    size: element.strokeWidth * VARIABLE_WIDTH_FREEDRAW.SIZE_FACTOR,
-    thinning: VARIABLE_WIDTH_FREEDRAW.THINNING,
-    smoothing: VARIABLE_WIDTH_FREEDRAW.SMOOTHING,
-    streamline: getFreedrawStreamline(element),
-    easing: (t) => Math.sin((t * Math.PI) / 2), // https://easings.net/#easeOutSine
-    last: true,
-  }) as [number, number][];
-};
-
-const createLaserPointer = (element: ExcalidrawFreeDrawElement) =>
-  new LaserPointer({
-    size: element.strokeWidth * CONSTANT_WIDTH_FREEDRAW.SIZE_FACTOR,
-    streamline: getFreedrawStreamline(element),
-    simplify: 0,
-    sizeMapping: (details) => Math.max(0.1, details.pressure),
-  });
-
-/**
- * Uniform (constant width) freedraw outline, rendered with the laser-pointer
- * geometry. Pressure is pinned to 1 so the stroke keeps a constant width.
- */
-const getConstantWidthFreedrawOutline = (
-  element: ExcalidrawFreeDrawElement,
-): [number, number][] => {
-  const laserPointer = createLaserPointer(element);
-  element.points.map(([x, y]) => laserPointer.addPoint([x, y, 1]));
-
-  return laserPointer
-    .getStrokeOutline()
-    .map(([x, y]) => [x, y] as [number, number]);
-};
-
-export const getFreedrawOutlinePoints = (
-  element: ExcalidrawFreeDrawElement,
-): [number, number][] => {
-  // Unknown/absent variability falls back to the original variable rendering.
-  return element.strokeOptions?.variability === "constant"
-    ? getConstantWidthFreedrawOutline(element)
-    : getVariableWidthFreedrawOutline(element);
-};
-
-const med = (A: number[], B: number[]) => {
-  return [(A[0] + B[0]) / 2, (A[1] + B[1]) / 2];
-};
-
-// Trim SVG path data so number are each two decimal points. This
-// improves SVG exports, and prevents rendering errors on points
-// with long decimals.
-const TO_FIXED_PRECISION = /(\s?[A-Z]?,?-?[0-9]*\.[0-9]{0,2})(([0-9]|e|-)*)/g;
-
-const getSvgPathFromStroke = (points: number[][]): string => {
-  if (!points.length) {
-    return "";
-  }
-
-  const max = points.length - 1;
-
-  return points
-    .reduce(
-      (acc, point, i, arr) => {
-        if (i === max) {
-          acc.push(point, med(point, arr[0]), "L", arr[0], "Z");
-        } else {
-          acc.push(point, med(point, arr[i + 1]));
-        }
-        return acc;
-      },
-      ["M", points[0], "Q"],
-    )
-    .join(" ")
-    .replace(TO_FIXED_PRECISION, "$1");
-};
-
-// -----------------------------------------------------------------------------

packages/element/src/sortElements.ts

@@ -1,56 +1,59 @@
-import { arrayToMap } from "@excalidraw/common";
+import { arrayToMapWithIndex } from "@excalidraw/common";
 
 import type { ExcalidrawElement } from "./types";
 
-const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
-  const groupIdAtLevel = (element: ExcalidrawElement, level: number) => {
-    return element.groupIds[element.groupIds.length - level - 1];
-  };
+const normalizeGroupElementOrder = (elements: readonly ExcalidrawElement[]) => {
+  const origElements: ExcalidrawElement[] = elements.slice();
+  const sortedElements = new Set<ExcalidrawElement>();
 
-  const orderLevel = (
-    levelElements: readonly ExcalidrawElement[],
-    level: number,
+  const orderInnerGroups = (
+    elements: readonly ExcalidrawElement[],
   ): ExcalidrawElement[] => {
-    const buckets = new Map<string, ExcalidrawElement[]>();
-    // Slots preserve first-occurrence order: a groupId reserves its slot
-    // the first time one of its members is seen; loose elements occupy
-    // their own slot. Groups are then expanded (and recursed into) in place.
-    const slots: (ExcalidrawElement | string)[] = [];
-
-    for (const element of levelElements) {
-      const groupId = groupIdAtLevel(element, level);
-      if (groupId === undefined) {
-        slots.push(element);
-        continue;
+    const firstGroupSig = elements[0]?.groupIds?.join("");
+    const aGroup: ExcalidrawElement[] = [elements[0]];
+    const bGroup: ExcalidrawElement[] = [];
+    for (const element of elements.slice(1)) {
+      if (element.groupIds?.join("") === firstGroupSig) {
+        aGroup.push(element);
+      } else {
+        bGroup.push(element);
       }
-      let bucket = buckets.get(groupId);
-      if (!bucket) {
-        bucket = [];
-        buckets.set(groupId, bucket);
-        slots.push(groupId);
-      }
-      bucket.push(element);
     }
-
-    return slots.flatMap((slot) =>
-      typeof slot === "string"
-        ? orderLevel(buckets.get(slot)!, level + 1)
-        : [slot],
-    );
+    return bGroup.length ? [...aGroup, ...orderInnerGroups(bGroup)] : aGroup;
   };
 
-  // `groupIds` is stored innermost-first, so the outermost group is the
-  // last entry. We recurse from level 0 (outermost) inward.
-  const sortedElements = orderLevel(elements, 0);
+  const groupHandledElements = new Map<string, true>();
+
+  origElements.forEach((element, idx) => {
+    if (groupHandledElements.has(element.id)) {
+      return;
+    }
+    if (element.groupIds?.length) {
+      const topGroup = element.groupIds[element.groupIds.length - 1];
+      const groupElements = origElements.slice(idx).filter((element) => {
+        const ret = element?.groupIds?.some((id) => id === topGroup);
+        if (ret) {
+          groupHandledElements.set(element!.id, true);
+        }
+        return ret;
+      });
+
+      for (const elem of orderInnerGroups(groupElements)) {
+        sortedElements.add(elem);
+      }
+    } else {
+      sortedElements.add(element);
+    }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
-  if (sortedElements.length !== elements.length) {
-    console.error("defragmentGroups: lost some elements... bailing!");
+  if (sortedElements.size !== elements.length) {
+    console.error("normalizeGroupElementOrder: lost some elements... bailing!");
     return elements;
   }
 
-  return sortedElements;
+  return [...sortedElements];
 };
 
 /**
@@ -65,40 +68,39 @@ const defragmentGroups = (elements: readonly ExcalidrawElement[]) => {
 const normalizeBoundElementsOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  const elementsMap = arrayToMap(elements);
+  const elementsMap = arrayToMapWithIndex(elements);
 
+  const origElements: (ExcalidrawElement | null)[] = elements.slice();
   const sortedElements = new Set<ExcalidrawElement>();
 
-  for (const element of elements) {
-    if (sortedElements.has(element)) {
-      continue;
+  origElements.forEach((element, idx) => {
+    if (!element) {
+      return;
     }
-
     if (element.boundElements?.length) {
       sortedElements.add(element);
-      for (const boundElement of element.boundElements) {
+      origElements[idx] = null;
+      element.boundElements.forEach((boundElement) => {
         const child = elementsMap.get(boundElement.id);
         if (child && boundElement.type === "text") {
-          sortedElements.add(child);
+          sortedElements.add(child[0]);
+          origElements[child[1]] = null;
         }
+      });
+    } else if (element.type === "text" && element.containerId) {
+      const parent = elementsMap.get(element.containerId);
+      if (!parent?.[0].boundElements?.find((x) => x.id === element.id)) {
+        sortedElements.add(element);
+        origElements[idx] = null;
+
+        // if element has a container and container lists it, skip this element
+        // as it'll be taken care of by the container
       }
-      continue;
+    } else {
+      sortedElements.add(element);
+      origElements[idx] = null;
     }
-
-    // if element has a container and container lists it, skip this element
-    // as it'll be taken care of by the container
-    if (
-      element.type === "text" &&
-      element.containerId &&
-      elementsMap
-        .get(element.containerId)
-        ?.boundElements?.some((el) => el.id === element.id)
-    ) {
-      continue;
-    }
-
-    sortedElements.add(element);
-  }
+  });
 
   // if there's a bug which resulted in losing some of the elements, return
   // original instead as that's better than losing data
@@ -115,5 +117,5 @@ const normalizeBoundElementsOrder = (
 export const normalizeElementOrder = (
   elements: readonly ExcalidrawElement[],
 ) => {
-  return normalizeBoundElementsOrder(defragmentGroups(elements));
+  return normalizeBoundElementsOrder(normalizeGroupElementOrder(elements));
 };

packages/element/src/textElement.ts

@@ -347,7 +347,6 @@ export const getContainerCenter = (
     midSegmentMidpoint = LinearElementEditor.getSegmentMidPoint(
       container,
       index + 1,
-      elementsMap,
     );
   }
   return { x: midSegmentMidpoint[0], y: midSegmentMidpoint[1] };
@@ -442,8 +441,7 @@ const VALID_CONTAINER_TYPES = new Set([
 
 export const isValidTextContainer = (element: {
   type: ExcalidrawElementType;
-}): element is ExcalidrawTextContainer =>
-  VALID_CONTAINER_TYPES.has(element.type);
+}) => VALID_CONTAINER_TYPES.has(element.type);
 
 export const computeContainerDimensionForBoundText = (
   dimension: number,

packages/element/src/textWrapping.ts

@@ -4,22 +4,6 @@ import { charWidth, getLineWidth } from "./textMeasurements";
 
 import type { FontString } from "./types";
 
-/**
- * This module approximates browser-like soft wrapping for Excalidraw text.
- *
- * The flow is:
- * 1. `parseTokens()` splits a hard line into breakable tokens using a unicode-aware regex.
- * 2. `getWrappedTextLines()` reflows each hard line into one or more visual lines and
- *    records where each visual line came from in the source text.
- * 3. `wrapLine()` assembles tokens into lines, and `wrapWord()` handles a single token
- *    that is wider than the available width.
- * 4. `trimLine()` / `trimLineEndAtSoftBreak()` mirror browser behavior around trailing
- *    whitespace so the rendered text stays consistent with what users see on canvas.
- *
- * Mostly, you'll want to use wrapText(). getWrappedTextLines() is for callers
- * that need metadata such as mapping visual lines back to `originalText`
- * for caret placement or future editor features.
- */
 let cachedCjkRegex: RegExp | undefined;
 let cachedLineBreakRegex: RegExp | undefined;
 let cachedEmojiRegex: RegExp | undefined;
@@ -374,10 +358,6 @@ const Break = {
 
 /**
  * Breaks the line into the tokens based on the found line break opporutnities.
- *
- * Note: tokenization normalizes to NFC first so decomposed graphemes are treated as
- * their composed variants for wrapping. Any code that needs exact source offsets should
- * keep in mind that this assumes the input text is already NFC-normalized.
  */
 export const parseTokens = (line: string) => {
   const breakLineRegex = getLineBreakRegex();
@@ -390,120 +370,56 @@ export const parseTokens = (line: string) => {
 
 /**
  * Wraps the original text into the lines based on the given width.
- *
- * This is a convenience adapter over `getWrappedTextLines()` for call sites
- * that only need the rendered wrapped string and not the source offsets.
  */
 export const wrapText = (
   text: string,
   font: FontString,
   maxWidth: number,
 ): string => {
-  return getWrappedTextLines(text, font, maxWidth)
-    .map((line) => line.text)
-    .join("\n");
-};
-
-/**
- * A single rendered visual line produced from the original text.
- *
- * `start` and `end` are end-exclusive code-unit offsets into the original text, and do
- * not include synthetic soft line breaks inserted by this module. If trailing whitespace
- * was trimmed away at a wrap boundary, `end` points to the last rendered character.
- */
-export type WrappedTextLine = {
-  text: string;
-  start: number;
-  end: number;
-};
-
-/**
- * Splits only on existing hard line breaks and preserves original offsets.
- */
-const getHardLineBreaks = (text: string): WrappedTextLine[] => {
-  let offset = 0;
-
-  return text.split("\n").map((line) => {
-    const start = offset;
-    const end = start + line.length;
-
-    offset = end + 1;
-
-    return {
-      text: line,
-      start,
-      end,
-    };
-  });
-};
-
-/**
- * Returns the rendered visual lines together with their source offsets.
- *
- * This is the source-of-truth wrapping pipeline for callers that need more than the
- * final wrapped string, for example caret placement or future editor/rich-text mapping.
- */
-export const getWrappedTextLines = (
-  text: string,
-  font: FontString,
-  maxWidth: number,
-): WrappedTextLine[] => {
   // if maxWidth is not finite or NaN which can happen in case of bugs in
   // computation, we need to make sure we don't continue as we'll end up
   // in an infinite loop
   if (!Number.isFinite(maxWidth) || maxWidth < 0) {
-    return getHardLineBreaks(text);
+    return text;
   }
 
-  const lines: WrappedTextLine[] = [];
-  let offset = 0;
+  const lines: Array<string> = [];
+  const originalLines = text.split("\n");
 
-  for (const originalLine of text.split("\n")) {
-    const originalLineWidth = getLineWidth(originalLine, font);
+  for (const originalLine of originalLines) {
+    const currentLineWidth = getLineWidth(originalLine, font);
 
-    if (originalLineWidth <= maxWidth) {
-      lines.push({
-        text: originalLine,
-        start: offset,
-        end: offset + originalLine.length,
-      });
-    } else {
-      lines.push(...wrapLine(originalLine, font, maxWidth, offset));
+    if (currentLineWidth <= maxWidth) {
+      lines.push(originalLine);
+      continue;
     }
 
-    offset += originalLine.length + 1;
+    const wrappedLine = wrapLine(originalLine, font, maxWidth);
+    lines.push(...wrappedLine);
   }
 
-  return lines;
+  return lines.join("\n");
 };
 
 /**
- * Wraps a single hard line into one or more visual lines.
- *
- * The line-local offsets are tracked in original-text code units so
- * we can map the visual line back to the source.
+ * Wraps the original line into the lines based on the given width.
  */
 const wrapLine = (
   line: string,
   font: FontString,
   maxWidth: number,
-  lineStart: number,
-): WrappedTextLine[] => {
-  const lines: WrappedTextLine[] = [];
+): string[] => {
+  const lines: Array<string> = [];
   const tokens = parseTokens(line);
+  const tokenIterator = tokens[Symbol.iterator]();
 
   let currentLine = "";
-  let currentLineStart = lineStart;
-  let currentLineEnd = lineStart;
   let currentLineWidth = 0;
-  // Tracks the next token's code-unit position in the original source string.
-  let tokenOffset = lineStart;
-  let tokenIndex = 0;
 
-  while (tokenIndex < tokens.length) {
-    const token = tokens[tokenIndex];
-    const tokenStart = tokenOffset;
-    const tokenEnd = tokenStart + token.length;
+  let iterator = tokenIterator.next();
+
+  while (!iterator.done) {
+    const token = iterator.value;
     const testLine = currentLine + token;
 
     // cache single codepoint whitespace, CJK or emoji width calc. as kerning should not apply here
@@ -513,59 +429,37 @@ const wrapLine = (
 
     // build up the current line, skipping length check for possibly trailing whitespaces
     if (/\s/.test(token) || testLineWidth <= maxWidth) {
-      if (!currentLine) {
-        currentLineStart = tokenStart;
-      }
       currentLine = testLine;
-      currentLineEnd = tokenEnd;
       currentLineWidth = testLineWidth;
-      tokenOffset = tokenEnd;
-      tokenIndex++;
+      iterator = tokenIterator.next();
       continue;
     }
 
     // current line is empty => just the token (word) is longer than `maxWidth` and needs to be wrapped
     if (!currentLine) {
-      const wrappedWord = wrapWord(token, font, maxWidth, tokenStart);
-      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? {
-        text: "",
-        start: tokenStart,
-        end: tokenStart,
-      };
+      const wrappedWord = wrapWord(token, font, maxWidth);
+      const trailingLine = wrappedWord[wrappedWord.length - 1] ?? "";
       const precedingLines = wrappedWord.slice(0, -1);
 
       lines.push(...precedingLines);
 
       // trailing line of the wrapped word might still be joined with next token/s
-      currentLine = trailingLine.text;
-      currentLineStart = trailingLine.start;
-      currentLineEnd = trailingLine.end;
-      currentLineWidth = getLineWidth(trailingLine.text, font);
-      tokenOffset = tokenEnd;
-      tokenIndex++;
+      currentLine = trailingLine;
+      currentLineWidth = getLineWidth(trailingLine, font);
+      iterator = tokenIterator.next();
     } else {
       // push & reset, but don't iterate on the next token, as we didn't use it yet!
-      lines.push(
-        trimLineEndAtSoftBreak(currentLine, currentLineStart, currentLineEnd),
-      );
+      lines.push(currentLine.trimEnd());
 
       // purposefully not iterating and not setting `currentLine` to `token`, so that we could use a simple !currentLine check above
       currentLine = "";
-      currentLineStart = tokenStart;
-      currentLineEnd = tokenStart;
       currentLineWidth = 0;
     }
   }
 
   // iterator done, push the trailing line if exists
   if (currentLine) {
-    const trailingLine = trimLine(
-      currentLine,
-      currentLineStart,
-      currentLineEnd,
-      font,
-      maxWidth,
-    );
+    const trailingLine = trimLine(currentLine, font, maxWidth);
     lines.push(trailingLine);
   }
 
@@ -573,100 +467,59 @@ const wrapLine = (
 };
 
 /**
- * Wraps a single word that could not be placed on an empty line as-is.
+ * Wraps the word into the lines based on the given width.
  */
 const wrapWord = (
   word: string,
   font: FontString,
   maxWidth: number,
-  wordStart: number,
-): WrappedTextLine[] => {
+): Array<string> => {
   // multi-codepoint emojis are already broken apart and shouldn't be broken further
   if (getEmojiRegex().test(word)) {
-    return [
-      {
-        text: word,
-        start: wordStart,
-        end: wordStart + word.length,
-      },
-    ];
+    return [word];
   }
 
   satisfiesWordInvariant(word);
 
-  const lines: WrappedTextLine[] = [];
+  const lines: Array<string> = [];
   const chars = Array.from(word);
 
   let currentLine = "";
-  let currentLineStart = wordStart;
-  let currentLineEnd = wordStart;
   let currentLineWidth = 0;
-  let offset = wordStart;
 
   for (const char of chars) {
-    const charStart = offset;
-    const charEnd = charStart + char.length;
     const _charWidth = charWidth.calculate(char, font);
     const testLineWidth = currentLineWidth + _charWidth;
 
     if (testLineWidth <= maxWidth) {
-      if (!currentLine) {
-        currentLineStart = charStart;
-      }
       currentLine = currentLine + char;
-      currentLineEnd = charEnd;
       currentLineWidth = testLineWidth;
-      offset = charEnd;
       continue;
     }
 
     if (currentLine) {
-      lines.push({
-        text: currentLine,
-        start: currentLineStart,
-        end: currentLineEnd,
-      });
+      lines.push(currentLine);
     }
 
     currentLine = char;
-    currentLineStart = charStart;
-    currentLineEnd = charEnd;
     currentLineWidth = _charWidth;
-    offset = charEnd;
   }
 
   if (currentLine) {
-    lines.push({
-      text: currentLine,
-      start: currentLineStart,
-      end: currentLineEnd,
-    });
+    lines.push(currentLine);
   }
 
   return lines;
 };
 
 /**
- * Trims trailing whitespace that is exceeding the `maxWidth`.
- *
- * Used for the trailing visual line of a hard line, where some trailing
- * whitespace may still be visible if it fits into the available width.
+ * Similarly to browsers, does not trim all trailing whitespaces, but only those exceeding the `maxWidth`.
  */
-const trimLine = (
-  line: string,
-  start: number,
-  end: number,
-  font: FontString,
-  maxWidth: number,
-): WrappedTextLine => {
+const trimLine = (line: string, font: FontString, maxWidth: number) => {
   const shouldTrimWhitespaces = getLineWidth(line, font) > maxWidth;
 
   if (!shouldTrimWhitespaces) {
-    return {
-      text: line,
-      start,
-      end,
-    };
+    return line;
   }
 
   // defensively default to `trimeEnd` in case the regex does not match
@@ -690,30 +543,7 @@ const trimLine = (
     trimmedLineWidth = testLineWidth;
   }
 
-  return {
-    text: trimmedLine,
-    start,
-    end: end - (line.length - trimmedLine.length),
-  };
-};
-
-/**
- * Used for internal soft-wrap boundaries, where trailing whitespace should not
- * survive into the rendered line even though it still exists in the original
- * text.
- */
-const trimLineEndAtSoftBreak = (
-  line: string,
-  start: number,
-  end: number,
-): WrappedTextLine => {
-  const trimmedLine = line.trimEnd();
-
-  return {
-    text: trimmedLine,
-    start,
-    end: end - (line.length - trimmedLine.length),
-  };
+  return trimmedLine;
 };
 
 /**

packages/element/src/transformHandles.ts

@@ -11,7 +11,6 @@ import type {
   InteractiveCanvasAppState,
   Zoom,
 } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "@excalidraw/common";
 
 import { getElementAbsoluteCoords } from "./bounds";
 import {
@@ -21,6 +20,7 @@ import {
   isLinearElement,
 } from "./typeChecks";
 
+import type { Bounds } from "./bounds";
 import type {
   ElementsMap,
   ExcalidrawElement,

packages/element/src/typeChecks.ts

@@ -6,6 +6,7 @@ import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
 
 import type { MarkNonNullable } from "@excalidraw/common/utility-types";
 
+import type { Bounds } from "./bounds";
 import type {
   ExcalidrawElement,
   ExcalidrawTextElement,
@@ -355,6 +356,15 @@ export const getDefaultRoundnessTypeForElement = (
   return null;
 };
 
+// TODO: Move this to @excalidraw/math
+export const isBounds = (box: unknown): box is Bounds =>
+  Array.isArray(box) &&
+  box.length === 4 &&
+  typeof box[0] === "number" &&
+  typeof box[1] === "number" &&
+  typeof box[2] === "number" &&
+  typeof box[3] === "number";
+
 export const getLinearElementSubType = (
   element: ExcalidrawLinearElement,
 ): ExcalidrawLinearElementSubType => {
@@ -392,23 +402,3 @@ export const canBecomePolygon = (
     (points.length === 3 && !pointsEqual(points[0], points[points.length - 1]))
   );
 };
-
-export const isEligibleFrameChildType = (type: ElementOrToolType) => {
-  switch (type) {
-    case "rectangle":
-    case "diamond":
-    case "ellipse":
-    case "arrow":
-    case "line":
-    case "freedraw":
-    case "text":
-    case "image":
-    case "frame":
-    case "embeddable": {
-      return true;
-    }
-    default: {
-      return false;
-    }
-  }
-};

packages/element/src/types.ts

@@ -15,7 +15,7 @@ import type {
   ValueOf,
 } from "@excalidraw/common/utility-types";
 
-export type ChartType = "bar" | "line" | "radar";
+export type ChartType = "bar" | "line";
 export type FillStyle = "hachure" | "cross-hatch" | "solid" | "zigzag";
 export type FontFamilyKeys = keyof typeof FONT_FAMILY;
 export type FontFamilyValues = typeof FONT_FAMILY[FontFamilyKeys];
@@ -303,32 +303,19 @@ export type PointsPositionUpdates = Map<
   { point: LocalPoint; isDragging?: boolean }
 >;
 
-export type CardinalityArrowhead =
-  | "cardinality_one"
-  | "cardinality_many"
-  | "cardinality_one_or_many"
-  | "cardinality_exactly_one"
-  | "cardinality_zero_or_one"
-  | "cardinality_zero_or_many";
-
-export type ArrowheadLegacy =
-  | "dot"
-  | "crowfoot_one"
-  | "crowfoot_many"
-  | "crowfoot_one_or_many";
-
 export type Arrowhead =
   | "arrow"
   | "bar"
+  | "dot" // legacy. Do not use for new elements.
   | "circle"
   | "circle_outline"
   | "triangle"
   | "triangle_outline"
   | "diamond"
   | "diamond_outline"
-  | CardinalityArrowhead;
-
-export type AnyArrowhead = Arrowhead | ArrowheadLegacy;
+  | "crowfoot_one"
+  | "crowfoot_many"
+  | "crowfoot_one_or_many";
 
 export type ExcalidrawLinearElement = _ExcalidrawElementBase &
   Readonly<{
@@ -384,20 +371,12 @@ export type ExcalidrawElbowArrowElement = Merge<
   }
 >;
 
-export type StrokeVariability = "variable" | "constant";
-
-export type StrokeOptions = Readonly<{
-  variability: StrokeVariability;
-  streamline: number;
-}>;
-
 export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase &
   Readonly<{
     type: "freedraw";
     points: readonly LocalPoint[];
     pressures: readonly number[];
     simulatePressure: boolean;
-    strokeOptions: StrokeOptions;
   }>;
 
 export type FileId = string & { _brand: "FileId" };

packages/element/src/utils.ts

@@ -7,7 +7,6 @@ import {
 } from "@excalidraw/common";
 
 import {
-  bezierEquation,
   curve,
   curveCatmullRomCubicApproxPoints,
   curveOffsetPoints,
@@ -28,30 +27,19 @@ import {
 
 import type { Curve, LineSegment, LocalPoint } from "@excalidraw/math";
 
-import type {
-  AppState,
-  NormalizedZoomValue,
-  Zoom,
-} from "@excalidraw/excalidraw/types";
+import type { NormalizedZoomValue, Zoom } from "@excalidraw/excalidraw/types";
 
 import { elementCenterPoint, getDiamondPoints } from "./bounds";
 
 import { generateLinearCollisionShape } from "./shape";
 
-import { hitElementItself, isPointInElement } from "./collision";
+import { isPointInElement } from "./collision";
 import { LinearElementEditor } from "./linearElementEditor";
 import { isRectangularElement } from "./typeChecks";
-import { maxBindingDistance_simple } from "./binding";
-
-import {
-  getGlobalFixedPointForBindableElement,
-  normalizeFixedPoint,
-} from "./binding";
 
 import type {
   ElementsMap,
   ExcalidrawArrowElement,
-  ExcalidrawBindableElement,
   ExcalidrawDiamondElement,
   ExcalidrawElement,
   ExcalidrawFreeDrawElement,
@@ -124,7 +112,6 @@ const setElementShapesCacheEntry = <T extends ExcalidrawElement>(
  */
 export function deconstructLinearOrFreeDrawElement(
   element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement,
-  elementsMap: ElementsMap,
 ): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
   const cachedShape = getElementShapesCacheEntry(element, 0);
 
@@ -132,7 +119,10 @@ export function deconstructLinearOrFreeDrawElement(
     return cachedShape;
   }
 
-  const ops = generateLinearCollisionShape(element, elementsMap);
+  const ops = generateLinearCollisionShape(element) as {
+    op: string;
+    data: number[];
+  }[];
   const lines = [];
   const curves = [];
 
@@ -339,10 +329,24 @@ export function deconstructRectanguloidElement(
   return shape;
 }
 
-export function getDiamondBaseCorners(
+/**
+ * Get the **unrotated** building components of a diamond element
+ * in the form of line segments and curves as a tuple, in this order.
+ *
+ * @param element The element to deconstruct
+ * @param offset An optional offset
+ * @returns Tuple of line **unrotated** segments (0) and curves (1)
+ */
+export function deconstructDiamondElement(
   element: ExcalidrawDiamondElement,
   offset: number = 0,
-): Curve<GlobalPoint>[] {
+): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
+  const cachedShape = getElementShapesCacheEntry(element, offset);
+
+  if (cachedShape) {
+    return cachedShape;
+  }
+
   const [topX, topY, rightX, rightY, bottomX, bottomY, leftX, leftY] =
     getDiamondPoints(element);
   const verticalRadius = element.roundness
@@ -359,7 +363,7 @@ export function getDiamondBaseCorners(
     pointFrom(element.x + leftX, element.y + leftY),
   ];
 
-  return [
+  const baseCorners = [
     curve(
       pointFrom<GlobalPoint>(
         right[0] - verticalRadius,
@@ -409,27 +413,6 @@ export function getDiamondBaseCorners(
       ),
     ), // TOP
   ];
-}
-
-/**
- * Get the **unrotated** building components of a diamond element
- * in the form of line segments and curves as a tuple, in this order.
- *
- * @param element The element to deconstruct
- * @param offset An optional offset
- * @returns Tuple of line **unrotated** segments (0) and curves (1)
- */
-export function deconstructDiamondElement(
-  element: ExcalidrawDiamondElement,
-  offset: number = 0,
-): [LineSegment<GlobalPoint>[], Curve<GlobalPoint>[]] {
-  const cachedShape = getElementShapesCacheEntry(element, offset);
-
-  if (cachedShape) {
-    return cachedShape;
-  }
-
-  const baseCorners = getDiamondBaseCorners(element, offset);
 
   const corners = baseCorners.map(
     (corner) =>
@@ -587,131 +570,28 @@ const getDiagonalsForBindableElement = (
   return [diagonalOne, diagonalTwo];
 };
 
-export const getSnapOutlineMidPoint = (
-  point: GlobalPoint,
-  element: ExcalidrawBindableElement,
-  elementsMap: ElementsMap,
-  zoom: AppState["zoom"],
-) => {
-  const center = elementCenterPoint(element, elementsMap);
-  const sideMidpoints =
-    element.type === "diamond"
-      ? getDiamondBaseCorners(element).map((curve) => {
-          const point = bezierEquation(curve, 0.5);
-          const rotatedPoint = pointRotateRads(point, center, element.angle);
-
-          return pointFrom<GlobalPoint>(rotatedPoint[0], rotatedPoint[1]);
-        })
-      : [
-          // RIGHT midpoint
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              element.x + element.width,
-              element.y + element.height / 2,
-            ),
-            center,
-            element.angle,
-          ),
-          // BOTTOM midpoint
-          pointRotateRads(
-            pointFrom<GlobalPoint>(
-              element.x + element.width / 2,
-              element.y + element.height,
-            ),
-            center,
-            element.angle,
-          ),
-          // LEFT midpoint
-          pointRotateRads(
-            pointFrom<GlobalPoint>(element.x, element.y + element.height / 2),
-            center,
-            element.angle,
-          ),
-          // TOP midpoint
-          pointRotateRads(
-            pointFrom<GlobalPoint>(element.x + element.width / 2, element.y),
-            center,
-            element.angle,
-          ),
-        ];
-  const candidate = sideMidpoints.find(
-    (midpoint) =>
-      pointDistance(point, midpoint) <=
-        maxBindingDistance_simple(zoom) + element.strokeWidth / 2 &&
-      !hitElementItself({
-        point,
-        element,
-        threshold: 0,
-        elementsMap,
-        overrideShouldTestInside: true,
-      }),
-  );
-
-  return candidate;
-};
-
 export const projectFixedPointOntoDiagonal = (
   arrow: ExcalidrawArrowElement,
   point: GlobalPoint,
-  element: ExcalidrawBindableElement,
+  element: ExcalidrawElement,
   startOrEnd: "start" | "end",
   elementsMap: ElementsMap,
-  zoom: AppState["zoom"],
-  isMidpointSnappingEnabled: boolean = true,
 ): GlobalPoint | null => {
   invariant(arrow.points.length >= 2, "Arrow must have at least two points");
   if (arrow.width < 3 && arrow.height < 3) {
     return null;
   }
 
-  if (isMidpointSnappingEnabled) {
-    const sideMidPoint = getSnapOutlineMidPoint(
-      point,
-      element,
-      elementsMap,
-      zoom,
-    );
-    if (sideMidPoint) {
-      return sideMidPoint;
-    }
-  }
-
-  // Do the projection onto the diagonals (or center lines
-  // for non-rectangular shapes)
   const [diagonalOne, diagonalTwo] = getDiagonalsForBindableElement(
     element,
     elementsMap,
   );
 
-  // To avoid working with stale arrow state, we use the opposite focus point
-  // of the current endpoint, which will always be unchanged during moving of
-  // the endpoint. This is only needed when the arrow has only two points.
-  let a = LinearElementEditor.getPointAtIndexGlobalCoordinates(
+  const a = LinearElementEditor.getPointAtIndexGlobalCoordinates(
     arrow,
     startOrEnd === "start" ? 1 : arrow.points.length - 2,
     elementsMap,
   );
-  if (arrow.points.length === 2) {
-    const otherBinding =
-      startOrEnd === "start" ? arrow.endBinding : arrow.startBinding;
-    const otherBindable =
-      otherBinding &&
-      (elementsMap.get(otherBinding.elementId) as
-        | ExcalidrawBindableElement
-        | undefined);
-    const otherFocusPoint =
-      otherBinding &&
-      otherBindable &&
-      getGlobalFixedPointForBindableElement(
-        normalizeFixedPoint(otherBinding.fixedPoint),
-        otherBindable,
-        elementsMap,
-      );
-    if (otherFocusPoint) {
-      a = otherFocusPoint;
-    }
-  }
-
   const b = pointFromVector<GlobalPoint>(
     vectorScale(
       vectorFromPoint(point, a),
@@ -723,22 +603,18 @@ export const projectFixedPointOntoDiagonal = (
     ),
     a,
   );
-  const intersector = lineSegment<GlobalPoint>(b, a);
+  const intersector = lineSegment<GlobalPoint>(point, b);
   const p1 = lineSegmentIntersectionPoints(diagonalOne, intersector);
   const p2 = lineSegmentIntersectionPoints(diagonalTwo, intersector);
   const d1 = p1 && pointDistance(a, p1);
   const d2 = p2 && pointDistance(a, p2);
 
-  let projection = null;
+  let p = null;
   if (d1 != null && d2 != null) {
-    projection = d1 < d2 ? p1 : p2;
+    p = d1 < d2 ? p1 : p2;
   } else {
-    projection = p1 || p2 || null;
+    p = p1 || p2 || null;
   }
 
-  if (projection && isPointInElement(projection, element, elementsMap)) {
-    return projection;
-  }
-
-  return null;
+  return p && isPointInElement(p, element, elementsMap) ? p : null;
 };

packages/element/src/zindex.ts

@@ -1,7 +1,5 @@
 import { arrayToMap, findIndex, findLastIndex } from "@excalidraw/common";
 
-import { isFiniteNumber } from "@excalidraw/math";
-
 import type { AppState } from "@excalidraw/excalidraw/types";
 import type { GlobalPoint } from "@excalidraw/math";
 
@@ -158,11 +156,12 @@ export const moveArrowAboveBindable = (
   elements: readonly Ordered<NonDeletedExcalidrawElement>[],
   elementsMap: NonDeletedSceneElementsMap,
   scene: Scene,
-  hit?: NonDeletedExcalidrawElement,
 ): readonly OrderedExcalidrawElement[] => {
-  const hoveredElement = hit
-    ? hit
-    : getHoveredElementForBinding(point, elements, elementsMap);
+  const hoveredElement = getHoveredElementForBinding(
+    point,
+    elements,
+    elementsMap,
+  );
 
   if (!hoveredElement) {
     return elements;
@@ -315,46 +314,12 @@ const getTargetElementsMap = <T extends ExcalidrawElement>(
   }, new Map<string, ExcalidrawElement>());
 };
 
-const hasSameElementIds = (
-  prevElements: readonly ExcalidrawElement[],
-  nextElements: readonly ExcalidrawElement[],
-) => {
-  if (prevElements.length !== nextElements.length) {
-    console.error(
-      "z-index reordering failed: resulting array have different lengths",
-    );
-    return false;
-  }
-
-  const prevElementIdCounts = new Map<ExcalidrawElement["id"], number>();
-  for (const element of prevElements) {
-    prevElementIdCounts.set(
-      element.id,
-      (prevElementIdCounts.get(element.id) || 0) + 1,
-    );
-  }
-
-  for (const element of nextElements) {
-    const count = prevElementIdCounts.get(element.id);
-    if (!count) {
-      console.error(
-        "z-index reordering failed: element id mismatch / duplicate ids",
-      );
-      return false;
-    }
-    prevElementIdCounts.set(element.id, count - 1);
-  }
-
-  return true;
-};
-
 const shiftElementsByOne = (
   elements: readonly ExcalidrawElement[],
   appState: AppState,
   direction: "left" | "right",
   scene: Scene,
 ) => {
-  const originalElements = elements;
   const indicesToMove = getIndicesToMove(elements, appState);
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
 
@@ -425,10 +390,6 @@ const shiftElementsByOne = (
           ];
   });
 
-  if (!hasSameElementIds(originalElements, elements)) {
-    return originalElements;
-  }
-
   syncMovedIndices(elements, targetElementsMap);
 
   return elements;
@@ -442,20 +403,11 @@ const shiftElementsToEnd = (
   elementsToBeMoved?: readonly ExcalidrawElement[],
 ) => {
   const indicesToMove = getIndicesToMove(elements, appState, elementsToBeMoved);
-
-  // Nothing to move (e.g. `elementsToBeMoved` is empty because all selected
-  // elements were frame children handled in a prior pass). Bail out early —
-  // otherwise `leadingIndex`/`trailingIndex` below resolve to `undefined` and
-  // the resulting `slice()` calls overlap, duplicating elements.
-  if (indicesToMove.length === 0) {
-    return elements;
-  }
-
   const targetElementsMap = getTargetElementsMap(elements, indicesToMove);
   const displacedElements: ExcalidrawElement[] = [];
 
-  let leadingIndex: number | undefined;
-  let trailingIndex: number | undefined;
+  let leadingIndex: number;
+  let trailingIndex: number;
   if (direction === "left") {
     if (containingFrame) {
       leadingIndex = findIndex(elements, (el) =>
@@ -500,19 +452,6 @@ const shiftElementsToEnd = (
     leadingIndex = 0;
   }
 
-  const isValidIndex = (index: number | undefined): index is number => {
-    return isFiniteNumber(index) && index >= 0;
-  };
-
-  if (
-    !isValidIndex(leadingIndex) ||
-    !isValidIndex(trailingIndex) ||
-    leadingIndex > trailingIndex ||
-    indicesToMove.some((index) => index < leadingIndex || index > trailingIndex)
-  ) {
-    return elements;
-  }
-
   for (let index = leadingIndex; index < trailingIndex + 1; index++) {
     if (!indicesToMove.includes(index)) {
       displacedElements.push(elements[index]);
@@ -537,10 +476,6 @@ const shiftElementsToEnd = (
           ...trailingElements,
         ];
 
-  if (!hasSameElementIds(elements, nextElements)) {
-    return elements;
-  }
-
   syncMovedIndices(nextElements, targetElementsMap);
 
   return nextElements;
@@ -609,7 +544,7 @@ function shiftElementsAccountingForFrames(
 
   for (const [frameId, children] of frameChildrenSets) {
     nextElements = shiftFunction(
-      nextElements,
+      allElements,
       appState,
       direction,
       frameId,

packages/element/tests/__snapshots__/linearElementEditor.test.tsx.snap

@@ -17,7 +17,7 @@ exports[`Test Linear Elements > Test bound text element > should match styles fo
   class="excalidraw-wysiwyg"
   data-type="wysiwyg"
   dir="auto"
-  style="position: absolute; display: inline-block; min-height: 1em; backface-visibility: hidden; margin: 0px; padding: 0px; border: 0px; outline: 0; resize: none; background: transparent; overflow: hidden; z-index: var(--zIndex-wysiwyg); word-break: break-word; white-space: pre-wrap; overflow-wrap: break-word; box-sizing: content-box; width: 10.5px; height: 26.25px; left: 35px; top: 7.5px; transform: translate(0px, 0px) scale(1) rotate(0deg); text-align: center; vertical-align: middle; color: rgb(30, 30, 30); opacity: 1; max-height: 992.5px; font: Emoji 20px 20px; line-height: 1.25; font-family: Excalifont, Xiaolai, sans-serif, Segoe UI Emoji;"
+  style="position: absolute; display: inline-block; min-height: 1em; backface-visibility: hidden; margin: 0px; padding: 0px; border: 0px; outline: 0; resize: none; background: transparent; overflow: hidden; z-index: var(--zIndex-wysiwyg); word-break: break-word; white-space: pre-wrap; overflow-wrap: break-word; box-sizing: content-box; width: 10.5px; height: 26.25px; left: 35px; top: 7.5px; transform: translate(0px, 0px) scale(1) rotate(0deg); text-align: center; vertical-align: middle; color: rgb(30, 30, 30); opacity: 1; filter: var(--theme-filter); max-height: 992.5px; font: Emoji 20px 20px; line-height: 1.25; font-family: Excalifont, Xiaolai, sans-serif, Segoe UI Emoji;"
   tabindex="0"
   wrap="off"
 />

packages/element/tests/binding.test.tsx

@@ -178,64 +178,6 @@ describe("binding for simple arrows", () => {
     });
   });
 
-  describe("self-binding (both ends to the same element) single-click finalize", () => {
-    // rect spans x:200..400, y:200..400; orbit ring is ~15px outside the outline
-    const INSIDE: [number, number] = [250, 250];
-    const ORBIT_LEFT: [number, number] = [187, 300];
-    const ORBIT_RIGHT: [number, number] = [413, 300];
-    const MIDDLE: [number, number] = [550, 100];
-
-    beforeEach(async () => {
-      mouse.reset();
-      await act(() => setLanguage(defaultLang));
-      await render(<Excalidraw handleKeyboardGlobally={true} />);
-      UI.createElement("rectangle", {
-        x: 200,
-        y: 200,
-        width: 200,
-        height: 200,
-      });
-    });
-
-    const drawSelfArrow = (start: [number, number], end: [number, number]) => {
-      UI.clickTool("arrow");
-      mouse.reset();
-      mouse.clickAt(...start);
-      mouse.moveTo(...MIDDLE);
-      mouse.clickAt(...MIDDLE); // commit a middle point so it's a multi-point arrow
-      mouse.moveTo(...end);
-      mouse.clickAt(...end); // single click at the end
-    };
-
-    it("orbit -> orbit finalizes on a single click", () => {
-      drawSelfArrow(ORBIT_LEFT, ORBIT_RIGHT);
-
-      const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
-      expect(h.state.multiElement).toBe(null);
-      expect(h.state.activeTool.type).toBe("selection");
-      expect(arrow.startBinding?.elementId).toBe(arrow.endBinding?.elementId);
-      expect(arrow.endBinding?.elementId).not.toBe(undefined);
-    });
-
-    it("inside -> orbit finalizes on a single click", () => {
-      drawSelfArrow(INSIDE, ORBIT_RIGHT);
-
-      const arrow = h.elements[h.elements.length - 1] as ExcalidrawArrowElement;
-      expect(h.state.multiElement).toBe(null);
-      expect(h.state.activeTool.type).toBe("selection");
-      expect(arrow.startBinding?.elementId).toBe(arrow.endBinding?.elementId);
-      expect(arrow.endBinding?.elementId).not.toBe(undefined);
-    });
-
-    it("inside -> inside keep in multi-point mode (no single-click finalize)", () => {
-      drawSelfArrow(INSIDE, [INSIDE[0] + 50, INSIDE[1] + 50]); // end dropped inside the rect
-
-      // ambiguous → must be confirmed with a second click, so still in progress
-      expect(h.state.multiElement).not.toBe(null);
-      expect(h.state.activeTool.type).toBe("arrow");
-    });
-  });
-
   describe("when arrow is outside of shape", () => {
     beforeEach(async () => {
       mouse.reset();
@@ -461,7 +403,6 @@ describe("binding for simple arrows", () => {
       mouse.moveTo(340, 251);
       mouse.moveTo(410, 251);
       mouse.clickAt(410, 251);
-      mouse.clickAt(410, 251);
       const arrow = h.elements[h.elements.length - 1] as any;
 
       expect(arrow.startBinding?.elementId).toBe(rectLeft.id);
@@ -506,7 +447,6 @@ describe("binding for simple arrows", () => {
       mouse.moveTo(350, 251);
       mouse.moveTo(410, 251);
       mouse.clickAt(410, 251);
-      mouse.clickAt(410, 251);
 
       const arrow = API.getSelectedElement() as ExcalidrawArrowElement;
 

packages/element/tests/bounds.test.ts

@@ -1,14 +1,10 @@
 import { pointFrom } from "@excalidraw/math";
-import { arrayToMap, type Bounds, ROUNDNESS } from "@excalidraw/common";
-import { API } from "@excalidraw/excalidraw/tests/helpers/api";
+
+import { arrayToMap, ROUNDNESS } from "@excalidraw/common";
 
 import type { LocalPoint } from "@excalidraw/math";
 
-import {
-  elementsOverlappingBBox,
-  getElementAbsoluteCoords,
-  getElementBounds,
-} from "../src/bounds";
+import { getElementAbsoluteCoords, getElementBounds } from "../src/bounds";
 
 import type { ExcalidrawElement, ExcalidrawLinearElement } from "../src/types";
 
@@ -145,65 +141,3 @@ describe("getElementBounds", () => {
     expect(y2).toEqual(319.8162855827246);
   });
 });
-
-const makeElement = (x: number, y: number, width: number, height: number) =>
-  API.createElement({
-    type: "rectangle",
-    x,
-    y,
-    width,
-    height,
-  });
-
-const makeBBox = (
-  minX: number,
-  minY: number,
-  maxX: number,
-  maxY: number,
-): Bounds => [minX, minY, maxX, maxY];
-
-describe("elementsOverlappingBBox()", () => {
-  it("should return elements that overlap bbox", () => {
-    const bbox = makeBBox(0, 0, 100, 100);
-
-    const rectOutside = makeElement(110, 110, 100, 100);
-    const rectInside = makeElement(10, 10, 85, 85);
-    const rectContainingBBox = makeElement(-10, -10, 110, 110);
-    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
-
-    expect(
-      elementsOverlappingBBox({
-        bounds: bbox,
-        type: "overlap",
-        elements: [
-          rectOutside,
-          rectInside,
-          rectContainingBBox,
-          rectOverlappingTopLeft,
-        ],
-      }),
-    ).toEqual([rectInside, rectOverlappingTopLeft]);
-  });
-
-  it("should return elements inside/containing bbox", () => {
-    const bbox = makeBBox(0, 0, 100, 100);
-
-    const rectOutside = makeElement(110, 110, 100, 100);
-    const rectInside = makeElement(10, 10, 85, 85);
-    const rectContainingBBox = makeElement(-10, -10, 110, 110);
-    const rectOverlappingTopLeft = makeElement(-10, -10, 50, 50);
-
-    expect(
-      elementsOverlappingBBox({
-        bounds: bbox,
-        type: "contain",
-        elements: [
-          rectOutside,
-          rectInside,
-          rectContainingBBox,
-          rectOverlappingTopLeft,
-        ],
-      }),
-    ).toEqual([rectInside]);
-  });
-});

packages/element/tests/collision.test.tsx

@@ -1,18 +1,14 @@
-import { arrayToMap, reseed } from "@excalidraw/common";
 import { type GlobalPoint, type LocalPoint, pointFrom } from "@excalidraw/math";
 import { Excalidraw } from "@excalidraw/excalidraw";
-import { API } from "@excalidraw/excalidraw/tests/helpers/api";
 import { UI } from "@excalidraw/excalidraw/tests/helpers/ui";
 import "@excalidraw/utils/test-utils";
 import { render } from "@excalidraw/excalidraw/tests/test-utils";
 
-import * as distance from "../src/distance";
 import { hitElementItself } from "../src/collision";
 
 describe("check rotated elements can be hit:", () => {
   beforeEach(async () => {
     localStorage.clear();
-    reseed(7);
     await render(<Excalidraw handleKeyboardGlobally={true} />);
   });
 
@@ -29,6 +25,8 @@ describe("check rotated elements can be hit:", () => {
         [-4, -302],
       ] as LocalPoint[],
     });
+    //const p = [120, -211];
+    //const p = [0, 13];
     const hit = hitElementItself({
       point: pointFrom<GlobalPoint>(88, -68),
       element: window.h.elements[0],
@@ -38,183 +36,3 @@ describe("check rotated elements can be hit:", () => {
     expect(hit).toBe(true);
   });
 });
-
-describe("hitElementItself cache", () => {
-  beforeEach(async () => {
-    // reset cache
-    hitElementItself({
-      point: pointFrom<GlobalPoint>(50, 50),
-      element: API.createElement({
-        type: "rectangle",
-        x: 0,
-        y: 0,
-        width: 100,
-        height: 100,
-        backgroundColor: "#ffffff",
-      }),
-      threshold: Infinity,
-      elementsMap: new Map([]),
-    });
-
-    localStorage.clear();
-    reseed(7);
-    await render(<Excalidraw handleKeyboardGlobally={true} />);
-  });
-
-  it("reuses cached result when threshold increases", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "#ffffff",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(100.5, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 1,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    distanceSpy.mockRestore();
-  });
-
-  it("does not reuse cache when threshold decreases", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(105, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 6,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(2);
-    distanceSpy.mockRestore();
-  });
-
-  it("invalidates cache when element version changes", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "#ffffff",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(100.5, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 1,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    const movedElement = {
-      ...element,
-      version: element.version + 1,
-      versionNonce: element.versionNonce + 1,
-    };
-
-    expect(
-      hitElementItself({
-        point,
-        element: movedElement,
-        threshold: 1,
-        elementsMap,
-      }),
-    ).toBe(true);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(2);
-    distanceSpy.mockRestore();
-  });
-
-  it("override does not affect caching", () => {
-    const element = API.createElement({
-      type: "rectangle",
-      x: 0,
-      y: 0,
-      width: 100,
-      height: 100,
-      backgroundColor: "transparent",
-    });
-    const elementsMap = arrayToMap([element]);
-    const point = pointFrom<GlobalPoint>(50, 50);
-
-    const distanceSpy = jest.spyOn(distance, "distanceToElement");
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-      }),
-    ).toBe(false);
-
-    expect(distanceSpy).toHaveBeenCalledTimes(1);
-
-    expect(
-      hitElementItself({
-        point,
-        element,
-        threshold: 10,
-        elementsMap,
-        overrideShouldTestInside: true,
-      }),
-    ).toBe(true);
-  });
-});