Separate more things

packages/common/keys.ts

@@ -1,6 +1,6 @@
 import { isDarwin } from "./constants";
 
-import type { ValueOf } from "./utility-types";
+import type { ValueOf } from "../excalidraw/utility-types";
 
 export const CODES = {
   EQUAL: "Equal",

packages/common/url.ts

@@ -1,6 +1,6 @@
 import { sanitizeUrl } from "@braintree/sanitize-url";
 
-import { escapeDoubleQuotes } from "../utils";
+import { escapeDoubleQuotes } from "./utils";
 
 export const normalizeLink = (link: string) => {
   link = link.trim();

packages/common/utils.ts

@@ -1245,3 +1245,60 @@ export const escapeDoubleQuotes = (str: string) => {
 
 export const castArray = <T>(value: T | T[]): T[] =>
   Array.isArray(value) ? value : [value];
+
+
+// TODO_SEP: perhaps could be refactored away?
+
+// TODO: Rounding this point causes some shake when free drawing
+export const getGridPoint = (
+  x: number,
+  y: number,
+  gridSize: NullableGridSize,
+): [number, number] => {
+  if (gridSize) {
+    return [
+      Math.round(x / gridSize) * gridSize,
+      Math.round(y / gridSize) * gridSize,
+    ];
+  }
+  return [x, y];
+};
+
+export const elementsAreInSameGroup = (
+  elements: readonly ExcalidrawElement[],
+) => {
+  const allGroups = elements.flatMap((element) => element.groupIds);
+  const groupCount = new Map<string, number>();
+  let maxGroup = 0;
+
+  for (const group of allGroups) {
+    groupCount.set(group, (groupCount.get(group) ?? 0) + 1);
+    if (groupCount.get(group)! > maxGroup) {
+      maxGroup = groupCount.get(group)!;
+    }
+  }
+
+  return maxGroup === elements.length;
+};
+
+export const isInGroup = (element: NonDeletedExcalidrawElement) => {
+  return element.groupIds.length > 0;
+};
+
+export const getNewGroupIdsForDuplication = (
+  groupIds: ExcalidrawElement["groupIds"],
+  editingGroupId: AppState["editingGroupId"],
+  mapper: (groupId: GroupId) => GroupId,
+) => {
+  const copy = [...groupIds];
+  const positionOfEditingGroupId = editingGroupId
+    ? groupIds.indexOf(editingGroupId)
+    : -1;
+  const endIndex =
+    positionOfEditingGroupId > -1 ? positionOfEditingGroupId : groupIds.length;
+  for (let index = 0; index < endIndex; index++) {
+    copy[index] = mapper(copy[index]);
+  }
+
+  return copy;
+};

packages/element/frame.ts

@@ -16,8 +16,8 @@ import {
   getContainerElement,
 } from "./element/textElement";
 import { isFrameElement, isFrameLikeElement } from "./element/typeChecks";
-import { getElementsInGroup, selectGroupsFromGivenElements } from "./groups";
+import { getElementsInGroup, selectGroupsFromGivenElements } from "../excalidraw/groups";
-import { getElementsWithinSelection, getSelectedElements } from "./scene";
+import { getElementsWithinSelection, getSelectedElements } from "../excalidraw/scene";
 import { arrayToMap } from "./utils";
 
 import type {
@@ -28,13 +28,13 @@ import type {
   NonDeleted,
   NonDeletedExcalidrawElement,
 } from "./element/types";
-import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
+import type { ExcalidrawElementsIncludingDeleted } from "../excalidraw/scene/Scene";
 import type {
   AppClassProperties,
   AppState,
   StaticCanvasAppState,
-} from "./types";
+} from "../excalidraw/types";
-import type { ReadonlySetLike } from "./utility-types";
+import type { ReadonlySetLike } from "../excalidraw/utility-types";
 
 // --------------------------- Frame State ------------------------------------
 export const bindElementsToFramesAfterDuplication = (
@@ -99,59 +99,6 @@ export const getElementsCompletelyInFrame = (
       element.frameId === frame.id,
   );
 
-export const isElementContainingFrame = (
-  element: ExcalidrawElement,
-  frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
-) => {
-  return getElementsWithinSelection([frame], element, elementsMap).some(
-    (e) => e.id === frame.id,
-  );
-};
-
-export const getElementsIntersectingFrame = (
-  elements: readonly ExcalidrawElement[],
-  frame: ExcalidrawFrameLikeElement,
-) => {
-  const elementsMap = arrayToMap(elements);
-  return elements.filter((element) =>
-    isElementIntersectingFrame(element, frame, elementsMap),
-  );
-};
-
-export const elementsAreInFrameBounds = (
-  elements: readonly ExcalidrawElement[],
-  frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
-) => {
-  const [frameX1, frameY1, frameX2, frameY2] = getElementAbsoluteCoords(
-    frame,
-    elementsMap,
-  );
-
-  const [elementX1, elementY1, elementX2, elementY2] =
-    getCommonBounds(elements);
-
-  return (
-    frameX1 <= elementX1 &&
-    frameY1 <= elementY1 &&
-    frameX2 >= elementX2 &&
-    frameY2 >= elementY2
-  );
-};
-
-export const elementOverlapsWithFrame = (
-  element: ExcalidrawElement,
-  frame: ExcalidrawFrameLikeElement,
-  elementsMap: ElementsMap,
-) => {
-  return (
-    elementsAreInFrameBounds([element], frame, elementsMap) ||
-    isElementIntersectingFrame(element, frame, elementsMap) ||
-    isElementContainingFrame(element, frame, elementsMap)
-  );
-};
-
 export const isCursorInFrame = (
   cursorCoords: {
     x: number;

packages/excalidraw/groups.ts

@@ -294,24 +294,6 @@ export const getSelectedGroupIdForElement = (
   selectedGroupIds: { [groupId: string]: boolean },
 ) => element.groupIds.find((groupId) => selectedGroupIds[groupId]);
 
-export const getNewGroupIdsForDuplication = (
-  groupIds: ExcalidrawElement["groupIds"],
-  editingGroupId: AppState["editingGroupId"],
-  mapper: (groupId: GroupId) => GroupId,
-) => {
-  const copy = [...groupIds];
-  const positionOfEditingGroupId = editingGroupId
-    ? groupIds.indexOf(editingGroupId)
-    : -1;
-  const endIndex =
-    positionOfEditingGroupId > -1 ? positionOfEditingGroupId : groupIds.length;
-  for (let index = 0; index < endIndex; index++) {
-    copy[index] = mapper(copy[index]);
-  }
-
-  return copy;
-};
-
 export const addToGroup = (
   prevGroupIds: ExcalidrawElement["groupIds"],
   newGroupId: GroupId,
@@ -377,24 +359,3 @@ export const getNonDeletedGroupIds = (elements: ElementsMap) => {
 
   return nonDeletedGroupIds;
 };
-
-export const elementsAreInSameGroup = (
-  elements: readonly ExcalidrawElement[],
-) => {
-  const allGroups = elements.flatMap((element) => element.groupIds);
-  const groupCount = new Map<string, number>();
-  let maxGroup = 0;
-
-  for (const group of allGroups) {
-    groupCount.set(group, (groupCount.get(group) ?? 0) + 1);
-    if (groupCount.get(group)! > maxGroup) {
-      maxGroup = groupCount.get(group)!;
-    }
-  }
-
-  return maxGroup === elements.length;
-};
-
-export const isInGroup = (element: NonDeletedExcalidrawElement) => {
-  return element.groupIds.length > 0;
-};

packages/excalidraw/snapping.ts

@@ -1411,18 +1411,3 @@ export const isActiveToolNonLinearSnappable = (
     activeToolType === TOOL_TYPE.text
   );
 };
-
-// TODO: Rounding this point causes some shake when free drawing
-export const getGridPoint = (
-  x: number,
-  y: number,
-  gridSize: NullableGridSize,
-): [number, number] => {
-  if (gridSize) {
-    return [
-      Math.round(x / gridSize) * gridSize,
-      Math.round(y / gridSize) * gridSize,
-    ];
-  }
-  return [x, y];
-};