@dwelle/excalidraw 0.4.0-d8d86cf → 0.4.0-da7ef3e

package/types/element/textElement.d.ts

@@ -1,23 +1,44 @@
-import { ExcalidrawElement, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontString, NonDeletedExcalidrawElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, FontFamilyValues, FontString, NonDeletedExcalidrawElement } from "./types";
 import { MaybeTransformHandleType } from "./transformHandles";
 import { AppState } from "../types";
+import { ExtractSetType } from "../utility-types";
 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 measureText: (text: string, font: FontString, maxWidth?: number | null) => {
+export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
+export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
+    x: number;
+    y: number;
+};
+export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => {
     width: number;
     height: number;
     baseline: number;
 };
-export declare const getApproxLineHeight: (font: FontString) => number;
+export declare const measureBaseline: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"], wrapInContainer?: boolean) => number;
+/**
+ * To get unitless line-height (if unknown) we can calculate it by dividing
+ * height-per-line by fontSize.
+ */
+export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => number & {
+    _brand: "unitlessLineHeight";
+};
+/**
+ * We calculate the line height from the font size and the unitless line height,
+ * aligning with the W3C spec.
+ */
+export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const getTextWidth: (text: string, font: FontString) => number;
+export declare const getTextHeight: (text: string, fontSize: number, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
+export declare const parseTokens: (text: string) => string[];
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
     getCache: (font: FontString) => number[];
 };
-export declare const getApproxMinLineWidth: (font: FontString) => number;
-export declare const getApproxMinLineHeight: (font: FontString) => number;
+export declare const getApproxMinLineWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
 export declare const getMinCharWidth: (font: FontString) => number;
 export declare const getMaxCharWidth: (font: FontString) => number;
 export declare const getApproxCharsToFitInWidth: (font: FontString, width: number) => number;
@@ -26,14 +47,14 @@ 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;
 };
+export declare const getContainerCoords: (container: NonDeletedExcalidrawElement) => {
+    x: number;
+    y: number;
+};
 export declare const getTextElementAngle: (textElement: ExcalidrawTextElement) => number;
 export declare const getBoundTextElementOffset: (boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
@@ -41,5 +62,17 @@ export declare const getBoundTextElementPosition: (container: ExcalidrawElement,
     y: number;
 } | undefined;
 export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
+export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
 export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number) => ExcalidrawTextContainer | null;
-export declare const isValidTextContainer: (element: ExcalidrawElement) => boolean;
+declare const VALID_CONTAINER_TYPES: Set<string>;
+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, 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 & {
+    _brand: "unitlessLineHeight";
+};
+export {};

package/types/element/textWysiwyg.d.ts

@@ -1,5 +1,10 @@
-import { ExcalidrawElement, ExcalidrawTextElement } from "./types";
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawTextContainer } from "./types";
 import App from "../components/App";
+export declare const updateOriginalContainerCache: (id: ExcalidrawTextContainer["id"], height: ExcalidrawTextContainer["height"]) => {
+    height: ExcalidrawTextContainer["height"];
+};
+export declare const resetOriginalContainerCache: (id: ExcalidrawTextContainer["id"]) => void;
+export declare const getOriginalContainerHeightFromCache: (id: ExcalidrawTextContainer["id"]) => number | null;
 export declare const textWysiwyg: ({ id, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, app, }: {
     id: ExcalidrawElement["id"];
     onChange?: ((text: string) => void) | undefined;
@@ -10,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,23 +1,30 @@
 import { ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-import { AppState, Zoom } from "../types";
-export declare type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
-export declare type TransformHandleType = TransformHandleDirection | "rotation";
-export declare type TransformHandle = [number, number, number, number];
-export declare type TransformHandles = Partial<{
+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];
+export type TransformHandles = Partial<{
     [T in TransformHandleType]: TransformHandle;
 }>;
-export declare type MaybeTransformHandleType = TransformHandleType | false;
+export type MaybeTransformHandleType = TransformHandleType | false;
 export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
     e: boolean;
     s: boolean;
     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,9 +1,12 @@
 import { AppState } from "../types";
-import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer } from "./types";
+import { MarkNonNullable } from "../utility-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;
@@ -14,5 +17,13 @@ export declare const isBindingElementType: (elementType: AppState["activeTool"][
 export declare const isBindableElement: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawBindableElement;
 export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
 export declare const isExcalidrawElement: (element: any) => boolean;
-export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
+export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
+export declare const isUsingAdaptiveRadius: (type: string) => boolean;
+export declare const isUsingProportionalRadius: (type: string) => boolean;
+export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
+export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
+    type: 2;
+} | {
+    type: 3;
+} | null;

package/types/element/types.d.ts

@@ -1,21 +1,23 @@
 import { Point } from "../types";
-import { FONT_FAMILY, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
-export declare type ChartType = "bar" | "line";
-export declare type FillStyle = "hachure" | "cross-hatch" | "solid";
-export declare type FontFamilyKeys = keyof typeof FONT_FAMILY;
-export declare type FontFamilyValues = typeof FONT_FAMILY[FontFamilyKeys];
-export declare type Theme = typeof THEME[keyof typeof THEME];
-export declare type FontString = string & {
+import { FONT_FAMILY, ROUNDNESS, TEXT_ALIGN, THEME, VERTICAL_ALIGN } from "../constants";
+import { MarkNonNullable, ValueOf } from "../utility-types";
+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];
+export type Theme = typeof THEME[keyof typeof THEME];
+export type FontString = string & {
     _brand: "fontString";
 };
-export declare type GroupId = string;
-export declare type PointerType = "mouse" | "pen" | "touch";
-export declare type StrokeSharpness = "round" | "sharp";
-export declare type StrokeStyle = "solid" | "dashed" | "dotted";
-export declare type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
-declare type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
-export declare type VerticalAlign = typeof VERTICAL_ALIGN[VerticalAlignKeys];
-declare type _ExcalidrawElementBase = Readonly<{
+export type GroupId = string;
+export type PointerType = "mouse" | "pen" | "touch";
+export type StrokeRoundness = "round" | "sharp";
+export type RoundnessType = ValueOf<typeof ROUNDNESS>;
+export type StrokeStyle = "solid" | "dashed" | "dotted";
+export type TextAlign = typeof TEXT_ALIGN[keyof typeof TEXT_ALIGN];
+type VerticalAlignKeys = keyof typeof VERTICAL_ALIGN;
+export type VerticalAlign = typeof VERTICAL_ALIGN[VerticalAlignKeys];
+type _ExcalidrawElementBase = Readonly<{
     id: string;
     x: number;
     y: number;
@@ -24,7 +26,10 @@ declare type _ExcalidrawElementBase = Readonly<{
     fillStyle: FillStyle;
     strokeWidth: number;
     strokeStyle: StrokeStyle;
-    strokeSharpness: StrokeSharpness;
+    roundness: null | {
+        type: RoundnessType;
+        value?: number;
+    };
     roughness: number;
     opacity: number;
     width: number;
@@ -44,6 +49,7 @@ declare 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"];
@@ -55,19 +61,30 @@ declare type _ExcalidrawElementBase = Readonly<{
     locked: boolean;
     customData?: Record<string, any>;
 }>;
-export declare type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
+export type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
     type: "selection";
 };
-export declare type ExcalidrawRectangleElement = _ExcalidrawElementBase & {
+export type ExcalidrawRectangleElement = _ExcalidrawElementBase & {
     type: "rectangle";
 };
-export declare type ExcalidrawDiamondElement = _ExcalidrawElementBase & {
+export type ExcalidrawDiamondElement = _ExcalidrawElementBase & {
     type: "diamond";
 };
-export declare type ExcalidrawEllipseElement = _ExcalidrawElementBase & {
+export type ExcalidrawEllipseElement = _ExcalidrawElementBase & {
     type: "ellipse";
 };
-export declare type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
+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;
     /** whether respective file is persisted */
@@ -75,22 +92,26 @@ export declare type ExcalidrawImageElement = _ExcalidrawElementBase & Readonly<{
     /** X and Y scale factors <-1, 1>, used for image axis flipping */
     scale: [number, number];
 }>;
-export declare type InitializedExcalidrawImageElement = MarkNonNullable<ExcalidrawImageElement, "fileId">;
+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.
  */
-export declare type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
+export type ExcalidrawGenericElement = ExcalidrawSelectionElement | ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement;
 /**
  * ExcalidrawElement should be JSON serializable and (eventually) contain
  * no computed data. The list of all ExcalidrawElements should be shareable
  * between peers and contain no state local to the peer.
  */
-export declare type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement;
-export declare type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
+export type ExcalidrawElement = ExcalidrawGenericElement | ExcalidrawTextElement | ExcalidrawLinearElement | ExcalidrawFreeDrawElement | ExcalidrawImageElement | ExcalidrawFrameElement | ExcalidrawEmbeddableElement;
+export type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
     isDeleted: boolean;
 };
-export declare type NonDeletedExcalidrawElement = NonDeleted<ExcalidrawElement>;
-export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
+export type NonDeletedExcalidrawElement = NonDeleted<ExcalidrawElement>;
+export type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     type: "text";
     fontSize: number;
     fontFamily: FontFamilyValues;
@@ -100,19 +121,26 @@ export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     verticalAlign: VerticalAlign;
     containerId: ExcalidrawGenericElement["id"] | null;
     originalText: string;
+    /**
+     * Unitless line height (aligned to W3C). To get line height in px, multiply
+     *  with font size (using `getLineHeightInPx` helper).
+     */
+    lineHeight: number & {
+        _brand: "unitlessLineHeight";
+    };
 }>;
-export declare type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement;
-export declare type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawImageElement | ExcalidrawArrowEleement;
-export declare type ExcalidrawTextElementWithContainer = {
+export type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement | ExcalidrawImageElement | ExcalidrawEmbeddableElement | ExcalidrawFrameElement;
+export type ExcalidrawTextContainer = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawArrowElement;
+export type ExcalidrawTextElementWithContainer = {
     containerId: ExcalidrawTextContainer["id"];
 } & ExcalidrawTextElement;
-export declare type PointBinding = {
+export type PointBinding = {
     elementId: ExcalidrawBindableElement["id"];
     focus: number;
     gap: number;
 };
-export declare type Arrowhead = "arrow" | "bar" | "dot" | "triangle";
-export declare type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
+export type Arrowhead = "arrow" | "bar" | "dot" | "triangle";
+export type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
     type: "line" | "arrow";
     points: readonly Point[];
     lastCommittedPoint: Point | null;
@@ -121,17 +149,17 @@ export declare type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<
     startArrowhead: Arrowhead | null;
     endArrowhead: Arrowhead | null;
 }>;
-export declare type ExcalidrawArrowEleement = ExcalidrawLinearElement & Readonly<{
+export type ExcalidrawArrowElement = ExcalidrawLinearElement & Readonly<{
     type: "arrow";
 }>;
-export declare type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
+export type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
     type: "freedraw";
     points: readonly Point[];
     pressures: readonly number[];
     simulatePressure: boolean;
     lastCommittedPoint: Point | null;
 }>;
-export declare type FileId = string & {
+export type FileId = string & {
     _brand: "FileId";
 };
 export {};

package/types/emitter.d.ts

@@ -1,4 +1,4 @@
-declare type Subscriber<T extends any[]> = (...payload: T) => void;
+type Subscriber<T extends any[]> = (...payload: T) => void;
 export declare class Emitter<T extends any[] = []> {
     subscribers: Subscriber<T>[];
     value: T | undefined;

package/types/errors.d.ts

@@ -1,4 +1,4 @@
-declare type CANVAS_ERROR_NAMES = "CANVAS_ERROR" | "CANVAS_POSSIBLY_TOO_BIG";
+type CANVAS_ERROR_NAMES = "CANVAS_ERROR" | "CANVAS_POSSIBLY_TOO_BIG";
 export declare class CanvasError extends Error {
     constructor(message?: string, name?: CANVAS_ERROR_NAMES);
 }

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 returns 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/ga.d.ts

@@ -16,15 +16,15 @@
  * See GAPoint, GALine, GADirection and GATransform modules for common
  * operations.
  */
-export declare type Point = NVector;
-export declare type Direction = NVector;
-export declare type Line = NVector;
-export declare type Transform = NVector;
+export type Point = NVector;
+export type Direction = NVector;
+export type Line = NVector;
+export type Transform = NVector;
 export declare const point: (x: number, y: number) => NVector;
 export declare const origin: () => NVector;
 export declare const direction: (x: number, y: number) => NVector;
 export declare const offset: (x: number, y: number) => NVector;
-declare type NVector = readonly [
+type NVector = readonly [
     number,
     number,
     number,

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/useCreatePortalContainer.d.ts

@@ -0,0 +1,4 @@
+export declare const useCreatePortalContainer: (opts?: {
+    className?: string;
+    parentSelector?: string;
+}) => HTMLDivElement | null;

package/types/hooks/useLibraryItemSvg.d.ts

@@ -0,0 +1,11 @@
+import { LibraryItem } from "../types";
+export type SvgCache = Map<LibraryItem["id"], SVGSVGElement>;
+export declare const libraryItemSvgsCache: import("jotai").PrimitiveAtom<SvgCache> & {
+    init: SvgCache;
+};
+export declare const useLibraryItemSvg: (id: LibraryItem["id"] | null, elements: LibraryItem["elements"] | undefined, svgCache: SvgCache) => SVGSVGElement | undefined;
+export declare const useLibraryCache: () => {
+    clearLibraryCache: () => void;
+    deleteItemsFromLibraryCache: (items: LibraryItem["id"][]) => void;
+    svgCache: SvgCache;
+};

package/types/hooks/useOutsideClick.d.ts

@@ -1,2 +1,19 @@
-/// <reference types="react" />
-export declare const useOutsideClickHook: (handler: (event: Event) => void) => import("react").MutableRefObject<null>;
+export declare function useOutsideClick<T extends HTMLElement>(ref: React.RefObject<T>, 
+/** if performance is of concern, memoize the callback */
+callback: (event: Event) => void, 
+/**
+ * Optional callback which is called on every click.
+ *
+ * Should return `true` if click should be considered as inside the container,
+ * and `false` if it falls outside and should call the `callback`.
+ *
+ * Returning `true` overrides the default behavior and `callback` won't be
+ * called.
+ *
+ * Returning `undefined` will fallback to the default behavior.
+ */
+isInside?: (event: Event & {
+    target: HTMLElement;
+}, 
+/** the element of the passed ref */
+container: T) => boolean | undefined): void;

package/types/hooks/useScrollPosition.d.ts

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

package/types/hooks/useStable.d.ts

@@ -0,0 +1 @@
+export declare const useStable: <T extends Record<string, any>>(value: T) => T;

package/types/hooks/useTransition.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare const useTransition: typeof React.useTransition;

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,6 +13,12 @@ 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;
-} | undefined) => string;
+} | null | undefined, fallback?: string) => string;
+export declare const useI18n: () => {
+    t: (path: NestedKeyOf<typeof fallbackLangData>, replacement?: {
+        [key: string]: string | number;
+    } | null | undefined, fallback?: string) => string;
+    langCode: string;
+};