@excalidraw/excalidraw 0.15.2-6675-381ef0c → 0.15.2-6690-6186765

package/types/element/newElement.d.ts

@@ -1,17 +1,22 @@
-import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer } from "../element/types";
+import { ExcalidrawElement, ExcalidrawImageElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues, ExcalidrawTextContainer, ExcalidrawFrameElement, ExcalidrawEmbeddableElement } from "../element/types";
 import { AppState } from "../types";
 import { MarkOptional, Mutable } from "../utility-types";
-type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity">;
+export type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity">;
 export declare const newElement: (opts: {
     type: ExcalidrawGenericElement["type"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
+export declare const newEmbeddableElement: (opts: {
+    type: "embeddable";
+    validated: ExcalidrawEmbeddableElement["validated"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawEmbeddableElement>;
+export declare const newFrameElement: (opts: ElementConstructorOpts) => NonDeleted<ExcalidrawFrameElement>;
 export declare const newTextElement: (opts: {
     text: string;
     fontSize?: number;
     fontFamily?: FontFamilyValues;
     textAlign?: TextAlign;
     verticalAlign?: VerticalAlign;
-    containerId?: ExcalidrawTextContainer["id"];
+    containerId?: ExcalidrawTextContainer["id"] | null;
     lineHeight?: ExcalidrawTextElement["lineHeight"];
     strokeWidth?: ExcalidrawTextElement["strokeWidth"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
@@ -35,8 +40,8 @@ export declare const newFreeDrawElement: (opts: {
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
 export declare const newLinearElement: (opts: {
     type: ExcalidrawLinearElement["type"];
-    startArrowhead: Arrowhead | null;
-    endArrowhead: Arrowhead | null;
+    startArrowhead?: Arrowhead | null;
+    endArrowhead?: Arrowhead | null;
     points?: ExcalidrawLinearElement["points"];
 } & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
 export declare const newImageElement: (opts: {
@@ -55,6 +60,11 @@ 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
@@ -84,4 +94,3 @@ export declare const duplicateElements: (elements: readonly ExcalidrawElement[],
     /** NOTE also updates version flags and `updated` */
     randomizeSeed: boolean;
 }) => ExcalidrawElement[];
-export {};

package/types/element/sizeHelpers.d.ts

@@ -1,6 +1,13 @@
 import { ExcalidrawElement } from "./types";
-import { AppState } from "../types";
+import { AppState, Zoom } from "../types";
 export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
+export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {
+    zoom: Zoom;
+    offsetLeft: number;
+    offsetTop: number;
+    scrollX: number;
+    scrollY: number;
+}) => boolean;
 /**
  * Makes a perfect shape or diagonal/horizontal/vertical line
  */

package/types/element/textElement.d.ts

@@ -6,7 +6,7 @@ export declare const normalizeText: (text: string) => string;
 export declare const splitIntoLines: (text: string) => string[];
 export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null) => void;
 export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
 export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
     x: number;
     y: number;
@@ -47,10 +47,6 @@ export declare const getBoundTextElement: (element: ExcalidrawElement | null) =>
 export declare const getContainerElement: (element: (ExcalidrawElement & {
     containerId: ExcalidrawElement["id"] | null;
 }) | null) => ExcalidrawElement | null;
-export declare const getContainerDims: (element: ExcalidrawElement) => {
-    width: number;
-    height: number;
-};
 export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState) => {
     x: number;
     y: number;
@@ -69,9 +65,11 @@ export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExca
 export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
 export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number) => ExcalidrawTextContainer | null;
 declare const VALID_CONTAINER_TYPES: Set<string>;
-export declare const isValidTextContainer: (element: ExcalidrawElement) => boolean;
+export declare const isValidTextContainer: (element: {
+    type: ExcalidrawElement["type"];
+}) => boolean;
 export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>) => number;
-export declare const getBoundTextMaxWidth: (container: ExcalidrawElement) => number;
+export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement?: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
 export declare const isMeasureTextSupported: () => boolean;
 export declare const getDefaultLineHeight: (fontFamily: FontFamilyValues) => number & {

package/types/element/textWysiwyg.d.ts

@@ -15,7 +15,7 @@ export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords,
     }) => void;
     getViewportCoords: (x: number, y: number) => [number, number];
     element: ExcalidrawTextElement;
-    canvas: HTMLCanvasElement | null;
+    canvas: HTMLCanvasElement;
     excalidrawContainer: HTMLDivElement | null;
     app: App;
 }) => void;

package/types/element/transformHandles.d.ts

@@ -1,5 +1,5 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import { AppState, Zoom } from "../types";
+import { InteractiveCanvasAppState, Zoom } from "../types";
 export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
 export type TransformHandleType = TransformHandleDirection | "rotation";
 export type TransformHandle = [number, number, number, number];
@@ -13,11 +13,18 @@ export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     n: boolean;
     w: boolean;
 };
+export declare const OMIT_SIDES_FOR_FRAME: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+    rotation: boolean;
+};
 export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
     s?: boolean | undefined;
     e?: boolean | undefined;
-    n?: boolean | undefined;
     w?: boolean | undefined;
+    n?: boolean | undefined;
     nw?: boolean | undefined;
     ne?: boolean | undefined;
     sw?: boolean | undefined;
@@ -25,4 +32,4 @@ export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [
     rotation?: boolean | undefined;
 }, margin?: number) => TransformHandles;
 export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, pointerType?: PointerType) => TransformHandles;
-export declare const shouldShowBoundingBox: (elements: NonDeletedExcalidrawElement[], appState: AppState) => boolean;
+export declare const shouldShowBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState) => boolean;

package/types/element/typeChecks.d.ts

@@ -1,10 +1,12 @@
 import { AppState } from "../types";
 import { MarkNonNullable } from "../utility-types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, RoundnessType } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType } from "./types";
 export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
 export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
 export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
+export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
 export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
+export declare const isFrameElement: (element: ExcalidrawElement | null) => element is ExcalidrawFrameElement;
 export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
 export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
 export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;

package/types/element/types.d.ts

@@ -49,6 +49,7 @@ type _ExcalidrawElementBase = Readonly<{
     /** List of groups the element belongs to.
         Ordered from deepest to shallowest. */
     groupIds: readonly GroupId[];
+    frameId: string | null;
     /** other elements that are bound to this element */
     boundElements: readonly Readonly<{
         id: ExcalidrawLinearElement["id"];
@@ -72,6 +73,17 @@ export type ExcalidrawDiamondElement = _ExcalidrawElementBase & {
 export type ExcalidrawEllipseElement = _ExcalidrawElementBase & {
     type: "ellipse";
 };
+export type ExcalidrawEmbeddableElement = _ExcalidrawElementBase & Readonly<{
+    type: "embeddable";
+    /**
+     * indicates whether the embeddable src (url) has been validated for rendering.
+     * null value indicates that the validation is pending. We reset the
+     * value on each restore (or url change) so that we can guarantee
+     * the validation came from a trusted source (the editor). Also because we
+     * may not have access to host-app supplied url validator during restore.
+     */
+    validated: boolean | null;
+}>;
 export type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
     type: "image";
     fileId: FileId | null;
@@ -81,6 +93,10 @@ export type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
     scale: [number, number];
 }>;
 export type InitializedExcalidrawImageElement = MarkNonNullable<ExcalidrawImageElement, "fileId">;
+export type ExcalidrawFrameElement = _ExcalidrawElementBase & {
+    type: "frame";
+    name: string | null;
+};
 /**
  * These are elements that don't have any additional properties.
  */
@@ -90,7 +106,7 @@ export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRe
  * no computed data. The list of all ExcalidrawElements should be shareable
  * between peers and contain no state local to the peer.
  */
-export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement;
+export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement | ExcalidrawFrameElement | ExcalidrawEmbeddableElement;
 export type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
     isDeleted: boolean;
 };
@@ -113,8 +129,8 @@ export type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
         _brand: "unitlessLineHeight";
     };
 }>;
-export type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
-export type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement | ExcalidrawArrowElement;
+export type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement | ExcalidrawEmbeddableElement | ExcalidrawFrameElement;
+export type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawArrowElement;
 export type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;

package/types/frame.d.ts

@@ -0,0 +1,40 @@
+import { ExcalidrawElement, ExcalidrawFrameElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
+import { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
+import { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
+export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameElement) => boolean;
+export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameElement) => boolean;
+export declare const isCursorInFrame: (cursorCoords: {
+    x: number;
+    y: number;
+}, frame: NonDeleted<ExcalidrawFrameElement>) => boolean;
+export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
+export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameElement) => boolean;
+/**
+ * Returns a map of frameId to frame elements. Includes empty frames.
+ */
+export declare const groupByFrames: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
+export declare const getFrameElements: (allElements: ExcalidrawElementsIncludingDeleted, frameId: string) => ExcalidrawElement[];
+export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+export declare const getElementsInNewFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap?: Map<string, ExcalidrawElement>) => ExcalidrawFrameElement | null;
+export declare const addElementsToFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameElement) => ExcalidrawElement[];
+export declare const removeElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, elementsToRemove: NonDeletedExcalidrawElement[], appState: AppState) => ExcalidrawElement[];
+export declare const removeAllElementsFromFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+export declare const replaceAllElementsInFrame: (allElements: ExcalidrawElementsIncludingDeleted, nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameElement, appState: AppState) => ExcalidrawElement[];
+/** does not mutate elements, but return new ones */
+export declare const updateFrameMembershipOfSelectedElements: (allElements: ExcalidrawElementsIncludingDeleted, appState: AppState, app: AppClassProperties) => ExcalidrawElementsIncludingDeleted;
+/**
+ * filters out elements that are inside groups that contain a frame element
+ * anywhere in the group tree
+ */
+export declare const omitGroupsContainingFrames: (allElements: ExcalidrawElementsIncludingDeleted, selectedElements?: readonly ExcalidrawElement[]) => ExcalidrawElement[];
+/**
+ * depending on the appState, return target frame, which is the frame the given element
+ * is going to be added to or remove from
+ */
+export declare const getTargetFrame: (element: ExcalidrawElement, appState: StaticCanvasAppState) => ExcalidrawFrameElement | null;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElements: ExcalidrawElementsIncludingDeleted, appState: StaticCanvasAppState) => boolean;

package/types/groups.d.ts

@@ -1,18 +1,21 @@
-import { GroupId, ExcalidrawElement, NonDeleted } from "./element/types";
-import { AppState } from "./types";
-export declare const selectGroup: (groupId: GroupId, appState: AppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => AppState;
+import { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
+import { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
+import { Mutable } from "./utility-types";
+export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
+export declare const selectGroupsForSelectedElements: {
+    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedExcalidrawElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
+    clearCache(): void;
+};
 /**
  * If the element's group is selected, don't render an individual
  * selection border around it.
  */
-export declare const isSelectedViaGroup: (appState: AppState, element: ExcalidrawElement) => boolean;
-export declare const getSelectedGroupForElement: (appState: AppState, element: ExcalidrawElement) => string | undefined;
-export declare const getSelectedGroupIds: (appState: AppState) => GroupId[];
-/**
- * When you select an element, you often want to actually select the whole group it's in, unless
- * you're currently editing that group.
- */
-export declare const selectGroupsForSelectedElements: (appState: AppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => AppState;
+export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => boolean;
+export declare const getSelectedGroupForElement: (appState: InteractiveCanvasAppState, element: ExcalidrawElement) => string | undefined;
+export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
+export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<ExcalidrawElement>[], appState: InteractiveCanvasAppState) => {
+    [groupId: string]: boolean;
+};
 export declare const editGroupForSelectedElement: (appState: AppState, element: NonDeleted<ExcalidrawElement>) => AppState;
 export declare const isElementInGroup: (element: ExcalidrawElement, groupId: string) => boolean;
 export declare const getElementsInGroup: (elements: readonly ExcalidrawElement[], groupId: string) => ExcalidrawElement[];
@@ -25,3 +28,4 @@ export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["gro
     [groupId: string]: boolean;
 }) => string[];
 export declare const getMaximumGroups: (elements: ExcalidrawElement[]) => ExcalidrawElement[][];
+export declare const elementsAreInSameGroup: (elements: ExcalidrawElement[]) => boolean;

package/types/history.d.ts

@@ -5,9 +5,9 @@ export interface HistoryEntry {
     elements: ExcalidrawElement[];
 }
 declare const clearAppStatePropertiesForHistory: (appState: AppState) => {
-    selectedElementIds: {
-        [id: string]: boolean;
-    };
+    selectedElementIds: Readonly<{
+        [id: string]: true;
+    }>;
     selectedGroupIds: {
         [groupId: string]: boolean;
     };

package/types/hooks/useOutsideClick.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="react" />
 export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T>, 
 /** if performance is of concern, memoize the callback */
 callback: (event: Event) => void, 

package/types/hooks/useScrollPosition.d.ts

@@ -1,2 +1 @@
-/// <reference types="react" />
 export declare const useScrollPosition: <T extends HTMLElement>(elementRef: import("react").RefObject<T>) => number;

package/types/i18n.d.ts

@@ -1,8 +1,11 @@
+import fallbackLangData from "./locales/en.json";
+import { NestedKeyOf } from "./utility-types";
 export interface Language {
     code: string;
     label: string;
     rtl?: boolean;
 }
+export type TranslationKeys = NestedKeyOf<typeof fallbackLangData>;
 export declare const defaultLang: {
     code: string;
     label: string;
@@ -10,11 +13,11 @@ export declare const defaultLang: {
 export declare const languages: Language[];
 export declare const setLanguage: (lang: Language) => Promise<void>;
 export declare const getLanguage: () => Language;
-export declare const t: (path: string, replacement?: {
+export declare const t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
     [key: string]: string | number;
 } | null | undefined, fallback?: string) => string;
 export declare const useI18n: () => {
-    t: (path: string, replacement?: {
+    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
         [key: string]: string | number;
     } | null | undefined, fallback?: string) => string;
     langCode: string;

package/types/keys.d.ts

@@ -8,6 +8,7 @@ export declare const CODES: {
     readonly BRACKET_LEFT: "BracketLeft";
     readonly ONE: "Digit1";
     readonly TWO: "Digit2";
+    readonly THREE: "Digit3";
     readonly NINE: "Digit9";
     readonly QUOTE: "Quote";
     readonly ZERO: "Digit0";
@@ -39,6 +40,7 @@ export declare const KEYS: {
     readonly CHEVRON_RIGHT: ">";
     readonly PERIOD: ".";
     readonly COMMA: ",";
+    readonly SUBTRACT: "-";
     readonly A: "a";
     readonly C: "c";
     readonly D: "d";
@@ -59,6 +61,7 @@ export declare const KEYS: {
     readonly Y: "y";
     readonly Z: "z";
     readonly K: "k";
+    readonly W: "w";
     readonly 0: "0";
     readonly 1: "1";
     readonly 2: "2";

package/types/math.d.ts

@@ -17,6 +17,7 @@ export declare const distance2d: (x1: number, y1: number, x2: number, y2: number
 export declare const centerPoint: (a: readonly [number, number], b: readonly [number, number]) => readonly [number, number];
 export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
 export declare const isPointInPolygon: (points: Point[], x: number, y: number) => boolean;
+export declare const isPointWithinBounds: (p: readonly [number, number], q: readonly [number, number], r: readonly [number, number]) => boolean;
 export declare const getGridPoint: (x: number, y: number, gridSize: number | null) => [number, number];
 export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
 export declare const getControlPointsForBezierCurve: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => [number, number][] | null;

package/types/packages/excalidraw/dist/excalidraw.development.d.ts

@@ -1,2 +1,2 @@
-export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
-export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
+export = __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__;
+export = __WEBPACK_EXTERNAL_MODULE_react_jsx_runtime__;