@excalidraw/excalidraw 0.17.1-c0b80a0 → 0.17.1-c329470

package/dist/excalidraw/element/newElement.d.ts

@@ -1,4 +1,4 @@
-import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement } from "./types";
+import type { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawIframeElement, ElementsMap, ExcalidrawArrowElement, FixedSegment, ExcalidrawElbowArrowElement } from "./types";
 import type { AppState } from "../types";
 import type { MarkOptional, Mutable } from "../utility-types";
 export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
@@ -45,13 +45,14 @@ export declare const newLinearElement: (opts: {
     type: ExcalidrawLinearElement["type"];
     points?: ExcalidrawLinearElement["points"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
-export declare const newArrowElement: (opts: {
+export declare const newArrowElement: <T extends boolean>(opts: {
     type: ExcalidrawArrowElement["type"];
-    startArrowhead?: Arrowhead | null;
-    endArrowhead?: Arrowhead | null;
-    points?: ExcalidrawArrowElement["points"];
-    elbowed?: boolean;
-} & ElementConstructorOpts) => NonDeleted<ExcalidrawArrowElement>;
+    startArrowhead?: Arrowhead | null | undefined;
+    endArrowhead?: Arrowhead | null | undefined;
+    points?: readonly import("../../math").LocalPoint[] | undefined;
+    elbowed?: T | undefined;
+    fixedSegments?: FixedSegment[] | null | undefined;
+} & Omit<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData"> & Partial<Pick<Omit<ExcalidrawGenericElement, "id" | "isDeleted" | "updated" | "type">, "angle" | "link" | "width" | "height" | "backgroundColor" | "strokeColor" | "fillStyle" | "strokeWidth" | "strokeStyle" | "roundness" | "roughness" | "opacity" | "seed" | "version" | "versionNonce" | "index" | "groupIds" | "frameId" | "boundElements" | "locked" | "customData">>) => T extends true ? NonDeleted<ExcalidrawElbowArrowElement> : NonDeleted<ExcalidrawArrowElement>;
 export declare const newImageElement: (opts: {
     type: ExcalidrawImageElement["type"];
     status?: ExcalidrawImageElement["status"];
@@ -69,11 +70,6 @@ export declare const newImageElement: (opts: {
  * Typed arrays and other non-null objects.
  */
 export declare const deepCopyElement: <T extends ExcalidrawElement>(val: T) => Mutable<T>;
-/**
- * utility wrapper to generate new id. In test env it reuses the old + postfix
- * for test assertions.
- */
-export declare const regenerateId: (previousId: string | null) => string;
 /**
  * Duplicate an element, often used in the alt-drag operation.
  * Note that this method has gotten a bit complicated since the

package/dist/excalidraw/element/newElement.js

@@ -6,7 +6,7 @@ import { getElementAbsoluteCoords } from ".";
 import { getResizedElementAbsoluteCoords } from "./bounds";
 import { measureText, normalizeText, getBoundTextMaxWidth, } from "./textElement";
 import { wrapText } from "./textWrapping";
-import { DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, VERTICAL_ALIGN, } from "../constants";
+import { DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, ORIG_ID, VERTICAL_ALIGN, } from "../constants";
 import { getLineHeight } from "../fonts";
 const _newElementBase = (type, { x, y, strokeColor = DEFAULT_ELEMENT_PROPS.strokeColor, backgroundColor = DEFAULT_ELEMENT_PROPS.backgroundColor, fillStyle = DEFAULT_ELEMENT_PROPS.fillStyle, strokeWidth = DEFAULT_ELEMENT_PROPS.strokeWidth, strokeStyle = DEFAULT_ELEMENT_PROPS.strokeStyle, roughness = DEFAULT_ELEMENT_PROPS.roughness, opacity = DEFAULT_ELEMENT_PROPS.opacity, width = 0, height = 0, angle = 0, groupIds = [], frameId = null, index = null, roundness = null, boundElements = null, link = null, locked = DEFAULT_ELEMENT_PROPS.locked, ...rest }) => {
     // assign type to guard against excess properties
@@ -214,6 +214,21 @@ export const newLinearElement = (opts) => {
     };
 };
 export const newArrowElement = (opts) => {
+    if (opts.elbowed) {
+        return {
+            ..._newElementBase(opts.type, opts),
+            points: opts.points || [],
+            lastCommittedPoint: null,
+            startBinding: null,
+            endBinding: null,
+            startArrowhead: opts.startArrowhead || null,
+            endArrowhead: opts.endArrowhead || null,
+            elbowed: true,
+            fixedSegments: opts.fixedSegments || [],
+            startIsSpecial: false,
+            endIsSpecial: false,
+        };
+    }
     return {
         ..._newElementBase(opts.type, opts),
         points: opts.points || [],
@@ -222,7 +237,7 @@ export const newArrowElement = (opts) => {
         endBinding: null,
         startArrowhead: opts.startArrowhead || null,
         endArrowhead: opts.endArrowhead || null,
-        elbowed: opts.elbowed || false,
+        elbowed: false,
     };
 };
 export const newImageElement = (opts) => {
@@ -300,23 +315,17 @@ const _deepCopyElement = (val, depth = 0) => {
 export const deepCopyElement = (val) => {
     return _deepCopyElement(val);
 };
+const __test__defineOrigId = (clonedObj, origId) => {
+    Object.defineProperty(clonedObj, ORIG_ID, {
+        value: origId,
+        writable: false,
+        enumerable: false,
+    });
+};
 /**
- * utility wrapper to generate new id. In test env it reuses the old + postfix
- * for test assertions.
+ * utility wrapper to generate new id.
  */
-export const regenerateId = (
-/** supply null if no previous id exists */
-previousId) => {
-    if (isTestEnv() && previousId) {
-        let nextId = `${previousId}_copy`;
-        // `window.h` may not be defined in some unit tests
-        if (window.h?.app
-            ?.getSceneElementsIncludingDeleted()
-            .find((el) => el.id === nextId)) {
-            nextId += "_copy";
-        }
-        return nextId;
-    }
+const regenerateId = () => {
     return randomId();
 };
 /**
@@ -335,13 +344,16 @@ previousId) => {
  */
 export const duplicateElement = (editingGroupId, groupIdMapForOperation, element, overrides) => {
     let copy = deepCopyElement(element);
-    copy.id = regenerateId(copy.id);
+    if (isTestEnv()) {
+        __test__defineOrigId(copy, element.id);
+    }
+    copy.id = regenerateId();
     copy.boundElements = null;
     copy.updated = getUpdatedTimestamp();
     copy.seed = randomInteger();
     copy.groupIds = getNewGroupIdsForDuplication(copy.groupIds, editingGroupId, (groupId) => {
         if (!groupIdMapForOperation.has(groupId)) {
-            groupIdMapForOperation.set(groupId, regenerateId(groupId));
+            groupIdMapForOperation.set(groupId, regenerateId());
         }
         return groupIdMapForOperation.get(groupId);
     });
@@ -373,7 +385,7 @@ export const duplicateElements = (elements, opts) => {
         // if we haven't migrated the element id, but an old element with the same
         // id exists, generate a new id for it and return it
         if (origElementsMap.has(id)) {
-            const newId = regenerateId(id);
+            const newId = regenerateId();
             elementNewIdsMap.set(id, newId);
             return newId;
         }
@@ -384,6 +396,9 @@ export const duplicateElements = (elements, opts) => {
     for (const element of elements) {
         const clonedElement = _deepCopyElement(element);
         clonedElement.id = maybeGetNewId(element.id);
+        if (isTestEnv()) {
+            __test__defineOrigId(clonedElement, element.id);
+        }
         if (opts?.randomizeSeed) {
             clonedElement.seed = randomInteger();
             bumpVersion(clonedElement);
@@ -391,7 +406,7 @@ export const duplicateElements = (elements, opts) => {
         if (clonedElement.groupIds) {
             clonedElement.groupIds = clonedElement.groupIds.map((groupId) => {
                 if (!groupNewIdsMap.has(groupId)) {
-                    groupNewIdsMap.set(groupId, regenerateId(groupId));
+                    groupNewIdsMap.set(groupId, regenerateId());
                 }
                 return groupNewIdsMap.get(groupId);
             });

package/dist/excalidraw/element/resizeElements.d.ts

@@ -1,16 +1,31 @@
-import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ElementsMap, NonDeletedSceneElementsMap, SceneElementsMap } from "./types";
+import type { ExcalidrawLinearElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, NonDeleted, ExcalidrawElement, ElementsMap, SceneElementsMap } from "./types";
+import type { BoundingBox } from "./bounds";
 import type { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
 import type { PointerDownState } from "../types";
-export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
+import type Scene from "../scene/Scene";
+import { type LocalPoint } from "../../math";
+export declare const transformElements: (originalElements: PointerDownState["originalElements"], transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: SceneElementsMap, scene: Scene, shouldRotateWithDiscreteAngle: boolean, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
 export declare const rescalePointsInElement: (element: NonDeletedExcalidrawElement, width: number, height: number, normalizePoints: boolean) => {
-    points: import("../../math").LocalPoint[];
+    points: LocalPoint[];
 } | {
     points?: undefined;
 };
 export declare const measureFontSizeFromWidth: (element: NonDeleted<ExcalidrawTextElement>, elementsMap: ElementsMap, nextWidth: number) => {
     size: number;
 } | null;
-export declare const resizeSingleElement: (originalElements: PointerDownState["originalElements"], shouldMaintainAspectRatio: boolean, element: NonDeletedExcalidrawElement, elementsMap: SceneElementsMap, transformHandleDirection: TransformHandleDirection, shouldResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
-export declare const resizeMultipleElements: (originalElements: PointerDownState["originalElements"], selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: NonDeletedSceneElementsMap | SceneElementsMap, transformHandleType: TransformHandleDirection, shouldResizeFromCenter: boolean, shouldMaintainAspectRatio: boolean, pointerX: number, pointerY: number) => void;
 export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap, x: number, y: number) => [number, number];
 export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";
+export declare const resizeSingleElement: (nextWidth: number, nextHeight: number, latestElement: ExcalidrawElement, origElement: ExcalidrawElement, elementsMap: ElementsMap, originalElementsMap: ElementsMap, handleDirection: TransformHandleDirection, { shouldInformMutation, shouldMaintainAspectRatio, shouldResizeFromCenter, }?: {
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+    shouldInformMutation?: boolean | undefined;
+}) => void;
+export declare const resizeMultipleElements: (selectedElements: readonly NonDeletedExcalidrawElement[], elementsMap: ElementsMap, handleDirection: TransformHandleDirection, scene: Scene, originalElementsMap: ElementsMap, { shouldMaintainAspectRatio, shouldResizeFromCenter, flipByX, flipByY, nextHeight, nextWidth, originalBoundingBox, }?: {
+    nextWidth?: number | undefined;
+    nextHeight?: number | undefined;
+    shouldMaintainAspectRatio?: boolean | undefined;
+    shouldResizeFromCenter?: boolean | undefined;
+    flipByX?: boolean | undefined;
+    flipByY?: boolean | undefined;
+    originalBoundingBox?: BoundingBox | undefined;
+}) => void;