@dwelle/excalidraw 0.3.4

package/types/element/newElement.d.ts

@@ -0,0 +1,45 @@
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawGenericElement, NonDeleted, TextAlign, GroupId, VerticalAlign, Arrowhead, ExcalidrawFreeDrawElement, FontFamilyValues } from "../element/types";
+import { AppState } from "../types";
+declare type ElementConstructorOpts = MarkOptional<Omit<ExcalidrawGenericElement, "id" | "type" | "isDeleted">, "width" | "height" | "angle" | "groupIds" | "boundElementIds" | "seed" | "version" | "versionNonce">;
+export declare const newElement: (opts: {
+    type: ExcalidrawGenericElement["type"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawGenericElement>;
+export declare const newTextElement: (opts: {
+    text: string;
+    fontSize: number;
+    fontFamily: FontFamilyValues;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawTextElement>;
+export declare const updateTextElement: (element: ExcalidrawTextElement, { text, isDeleted }: {
+    text: string;
+    isDeleted?: boolean | undefined;
+}) => ExcalidrawTextElement;
+export declare const newFreeDrawElement: (opts: {
+    type: "freedraw";
+    points?: ExcalidrawFreeDrawElement["points"];
+    simulatePressure: boolean;
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawFreeDrawElement>;
+export declare const newLinearElement: (opts: {
+    type: ExcalidrawLinearElement["type"];
+    startArrowhead: Arrowhead | null;
+    endArrowhead: Arrowhead | null;
+    points?: ExcalidrawLinearElement["points"];
+} & ElementConstructorOpts) => NonDeleted<ExcalidrawLinearElement>;
+export declare const deepCopyElement: (val: any, depth?: number) => any;
+/**
+ * Duplicate an element, often used in the alt-drag operation.
+ * Note that this method has gotten a bit complicated since the
+ * introduction of gruoping/ungrouping elements.
+ * @param editingGroupId The current group being edited. The new
+ *                       element will inherit this group and its
+ *                       parents.
+ * @param groupIdMapForOperation A Map that maps old group IDs to
+ *                               duplicated ones. If you are duplicating
+ *                               multiple elements at once, share this map
+ *                               amongst all of them
+ * @param element Element to duplicate
+ * @param overrides Any element properties to override
+ */
+export declare const duplicateElement: <TElement extends Mutable<ExcalidrawElement>>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, overrides?: Partial<TElement> | undefined) => TElement;
+export {};

package/types/element/resizeElements.d.ts

@@ -0,0 +1,9 @@
+import { ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted } from "./types";
+import { MaybeTransformHandleType, TransformHandleDirection } from "./transformHandles";
+import { PointerDownState } from "../types";
+export declare const normalizeAngle: (angle: number) => number;
+export declare const transformElements: (pointerDownState: PointerDownState, transformHandleType: MaybeTransformHandleType, selectedElements: readonly NonDeletedExcalidrawElement[], resizeArrowDirection: "origin" | "end", isRotateWithDiscreteAngle: boolean, isResizeCenterPoint: boolean, shouldKeepSidesRatio: boolean, pointerX: number, pointerY: number, centerX: number, centerY: number) => boolean;
+export declare const reshapeSingleTwoPointElement: (element: NonDeleted<ExcalidrawLinearElement>, resizeArrowDirection: "origin" | "end", isRotateWithDiscreteAngle: boolean, pointerX: number, pointerY: number) => void;
+export declare const resizeSingleElement: (stateAtResizeStart: NonDeletedExcalidrawElement, shouldKeepSidesRatio: boolean, element: NonDeletedExcalidrawElement, transformHandleDirection: TransformHandleDirection, isResizeFromCenter: boolean, pointerX: number, pointerY: number) => void;
+export declare const getResizeOffsetXY: (transformHandleType: MaybeTransformHandleType, selectedElements: NonDeletedExcalidrawElement[], x: number, y: number) => [number, number];
+export declare const getResizeArrowDirection: (transformHandleType: MaybeTransformHandleType, element: NonDeleted<ExcalidrawLinearElement>) => "origin" | "end";

package/types/element/resizeTest.d.ts

@@ -0,0 +1,13 @@
+import { ExcalidrawElement, PointerType, NonDeletedExcalidrawElement } from "./types";
+import { MaybeTransformHandleType } from "./transformHandles";
+import { AppState, Zoom } from "../types";
+export declare const resizeTest: (element: NonDeletedExcalidrawElement, appState: AppState, x: number, y: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
+export declare const getElementWithTransformHandleType: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => {
+    element: NonDeletedExcalidrawElement;
+    transformHandleType: MaybeTransformHandleType;
+} | null;
+export declare const getTransformHandleTypeFromCoords: ([x1, y1, x2, y2]: readonly [number, number, number, number], scenePointerX: number, scenePointerY: number, zoom: Zoom, pointerType: PointerType) => MaybeTransformHandleType;
+export declare const getCursorForResizingElement: (resizingElement: {
+    element?: ExcalidrawElement;
+    transformHandleType: MaybeTransformHandleType;
+}) => string;

package/types/element/showSelectedShapeActions.d.ts

@@ -0,0 +1,3 @@
+import { AppState } from "../types";
+import { NonDeletedExcalidrawElement } from "./types";
+export declare const showSelectedShapeActions: (appState: AppState, elements: readonly NonDeletedExcalidrawElement[]) => boolean;

package/types/element/sizeHelpers.d.ts

@@ -0,0 +1,16 @@
+import { ExcalidrawElement } from "./types";
+export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
+/**
+ * Makes a perfect shape or diagonal/horizontal/vertical line
+ */
+export declare const getPerfectElementSize: (elementType: string, width: number, height: number) => {
+    width: number;
+    height: number;
+};
+export declare const resizePerfectLineForNWHandler: (element: ExcalidrawElement, x: number, y: number) => void;
+export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
+    width: ExcalidrawElement["width"];
+    height: ExcalidrawElement["height"];
+    x: ExcalidrawElement["x"];
+    y: ExcalidrawElement["y"];
+};

package/types/element/textElement.d.ts

@@ -0,0 +1,2 @@
+import { ExcalidrawTextElement } from "./types";
+export declare const redrawTextBoundingBox: (element: ExcalidrawTextElement) => void;

package/types/element/textWysiwyg.d.ts

@@ -0,0 +1,15 @@
+import { ExcalidrawElement } from "./types";
+import { AppState } from "../types";
+export declare const textWysiwyg: ({ id, appState, onChange, onSubmit, getViewportCoords, element, canvas, excalidrawContainer, }: {
+    id: ExcalidrawElement["id"];
+    appState: AppState;
+    onChange?: ((text: string) => void) | undefined;
+    onSubmit: (data: {
+        text: string;
+        viaKeyboard: boolean;
+    }) => void;
+    getViewportCoords: (x: number, y: number) => [number, number];
+    element: ExcalidrawElement;
+    canvas: HTMLCanvasElement | null;
+    excalidrawContainer: HTMLDivElement | null;
+}) => void;

package/types/element/transformHandles.d.ts

@@ -0,0 +1,28 @@
+import { ExcalidrawElement, PointerType } from "./types";
+import { Bounds } from "./bounds";
+import { 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<{
+    [T in TransformHandleType]: TransformHandle;
+}>;
+export declare type MaybeTransformHandleType = TransformHandleType | false;
+export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
+    e: boolean;
+    s: boolean;
+    n: boolean;
+    w: boolean;
+};
+export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2]: Bounds, angle: number, zoom: Zoom, pointerType: PointerType, omitSides?: {
+    e?: boolean | undefined;
+    s?: boolean | undefined;
+    n?: boolean | undefined;
+    w?: boolean | undefined;
+    nw?: boolean | undefined;
+    ne?: boolean | undefined;
+    sw?: boolean | undefined;
+    se?: boolean | undefined;
+    rotation?: boolean | undefined;
+}) => TransformHandles;
+export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, pointerType?: PointerType) => TransformHandles;

package/types/element/typeChecks.d.ts

@@ -0,0 +1,11 @@
+import { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawGenericElement, ExcalidrawFreeDrawElement } from "./types";
+export declare const isGenericElement: (element: ExcalidrawElement | null) => element is ExcalidrawGenericElement;
+export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
+export declare const isFreeDrawElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawFreeDrawElement;
+export declare const isFreeDrawElementType: (elementType: ExcalidrawElement["type"]) => boolean;
+export declare const isLinearElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawLinearElement;
+export declare const isLinearElementType: (elementType: ExcalidrawElement["type"]) => boolean;
+export declare const isBindingElement: (element?: ExcalidrawElement | null | undefined) => element is ExcalidrawLinearElement;
+export declare const isBindingElementType: (elementType: ExcalidrawElement["type"]) => boolean;
+export declare const isBindableElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
+export declare const isExcalidrawElement: (element: any) => boolean;

package/types/element/types.d.ts

@@ -0,0 +1,106 @@
+import { Point } from "../types";
+import { FONT_FAMILY } 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 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 = "left" | "center" | "right";
+export declare type VerticalAlign = "top" | "middle";
+declare type _ExcalidrawElementBase = Readonly<{
+    id: string;
+    x: number;
+    y: number;
+    strokeColor: string;
+    backgroundColor: string;
+    fillStyle: FillStyle;
+    strokeWidth: number;
+    strokeStyle: StrokeStyle;
+    strokeSharpness: StrokeSharpness;
+    roughness: number;
+    opacity: number;
+    width: number;
+    height: number;
+    angle: number;
+    /** Random integer used to seed shape generation so that the roughjs shape
+        doesn't differ across renders. */
+    seed: number;
+    /** Integer that is sequentially incremented on each change. Used to reconcile
+        elements during collaboration or when saving to server. */
+    version: number;
+    /** Random integer that is regenerated on each change.
+        Used for deterministic reconciliation of updates during collaboration,
+        in case the versions (see above) are identical. */
+    versionNonce: number;
+    isDeleted: boolean;
+    /** List of groups the element belongs to.
+        Ordered from deepest to shallowest. */
+    groupIds: readonly GroupId[];
+    /** Ids of (linear) elements that are bound to this element. */
+    boundElementIds: readonly ExcalidrawLinearElement["id"][] | null;
+}>;
+export declare type ExcalidrawSelectionElement = _ExcalidrawElementBase & {
+    type: "selection";
+};
+export declare type ExcalidrawRectangleElement = _ExcalidrawElementBase & {
+    type: "rectangle";
+};
+export declare type ExcalidrawDiamondElement = _ExcalidrawElementBase & {
+    type: "diamond";
+};
+export declare type ExcalidrawEllipseElement = _ExcalidrawElementBase & {
+    type: "ellipse";
+};
+/**
+ * These are elements that don't have any additional properties.
+ */
+export declare 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;
+export declare type NonDeleted<TElement extends ExcalidrawElement> = TElement & {
+    isDeleted: false;
+};
+export declare type NonDeletedExcalidrawElement = NonDeleted<ExcalidrawElement>;
+export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
+    type: "text";
+    fontSize: number;
+    fontFamily: FontFamilyValues;
+    text: string;
+    baseline: number;
+    textAlign: TextAlign;
+    verticalAlign: VerticalAlign;
+}>;
+export declare type ExcalidrawBindableElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawEllipseElement | ExcalidrawTextElement;
+export declare type PointBinding = {
+    elementId: ExcalidrawBindableElement["id"];
+    focus: number;
+    gap: number;
+};
+export declare type Arrowhead = "arrow" | "bar" | "dot";
+export declare type ExcalidrawLinearElement = _ExcalidrawElementBase & Readonly<{
+    type: "line" | "arrow";
+    points: readonly Point[];
+    lastCommittedPoint: Point | null;
+    startBinding: PointBinding | null;
+    endBinding: PointBinding | null;
+    startArrowhead: Arrowhead | null;
+    endArrowhead: Arrowhead | null;
+}>;
+export declare type ExcalidrawFreeDrawElement = _ExcalidrawElementBase & Readonly<{
+    type: "freedraw";
+    points: readonly Point[];
+    pressures: readonly number[];
+    simulatePressure: boolean;
+    lastCommittedPoint: Point | null;
+}>;
+export {};

package/types/errors.d.ts

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

package/types/ga.d.ts

@@ -0,0 +1,63 @@
+/**
+ * This is a 2D Projective Geometric Algebra implementation.
+ *
+ * For wider context on geometric algebra visit see https://bivector.net.
+ *
+ * For this specific algebra see cheatsheet https://bivector.net/2DPGA.pdf.
+ *
+ * Converted from generator written by enki, with a ton of added on top.
+ *
+ * This library uses 8-vectors to represent points, directions and lines
+ * in 2D space.
+ *
+ * An array `[a, b, c, d, e, f, g, h]` represents a n(8)vector:
+ *   a + b*e0 + c*e1 + d*e2 + e*e01 + f*e20 + g*e12 + h*e012
+ *
+ * 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 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 [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number
+];
+export declare const nvector: (value?: number, index?: number) => NVector;
+export declare const toString: (nvector: NVector) => string;
+export declare const reverse: (nvector: NVector) => NVector;
+export declare const dual: (nvector: NVector) => NVector;
+export declare const conjugate: (nvector: NVector) => NVector;
+export declare const involute: (nvector: NVector) => NVector;
+export declare const add: (a: NVector, b: NVector | number) => NVector;
+export declare const sub: (a: NVector, b: NVector | number) => NVector;
+export declare const mul: (a: NVector, b: NVector | number) => NVector;
+export declare const mulScalar: (a: NVector, b: NVector) => number;
+export declare const meet: (a: NVector, b: NVector) => NVector;
+export declare const join: (a: NVector, b: NVector) => NVector;
+export declare const joinScalar: (a: NVector, b: NVector) => number;
+export declare const dot: (a: NVector, b: NVector) => NVector;
+export declare const norm: (a: NVector) => number;
+export declare const inorm: (a: NVector) => number;
+export declare const normalized: (a: NVector) => NVector;
+export declare const inormalized: (a: NVector) => NVector;
+export declare const E0: NVector;
+export declare const E1: NVector;
+export declare const E2: NVector;
+export declare const E01: NVector;
+export declare const E20: NVector;
+export declare const E12: NVector;
+export declare const E012: NVector;
+export declare const I: NVector;
+export {};

package/types/gadirections.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A direction is stored as an array `[0, 0, 0, 0, y, x, 0, 0]` representing
+ * vector `(x, y)`.
+ */
+export declare const from: (point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const fromTo: (from: readonly [number, number, number, number, number, number, number, number], to: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const orthogonal: (direction: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const orthogonalToLine: (line: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];

package/types/galines.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A line is stored as an array `[0, c, a, b, 0, 0, 0, 0]` representing:
+ *   c * e0 + a * e1 + b*e2
+ *
+ * This maps to a standard formula `a * x + b * y + c`.
+ *
+ * `(-b, a)` correponds to a 2D vector parallel to the line. The lines
+ * have a natural orientation, corresponding to that vector.
+ *
+ * The magnitude ("norm") of the line is `sqrt(a ^ 2 + b ^ 2)`.
+ * `c / norm(line)` is the oriented distance from line to origin.
+ */
+export declare const vector: (x: number, y: number) => readonly [number, number, number, number, number, number, number, number];
+export declare const equation: (a: number, b: number, c: number) => readonly [number, number, number, number, number, number, number, number];
+export declare const through: (from: readonly [number, number, number, number, number, number, number, number], to: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const orthogonal: (line: readonly [number, number, number, number, number, number, number, number], point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const orthogonalThrough: (against: readonly [number, number, number, number, number, number, number, number], intersection: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const parallel: (line: readonly [number, number, number, number, number, number, number, number], distance: number) => readonly [number, number, number, number, number, number, number, number];
+export declare const parallelThrough: (line: readonly [number, number, number, number, number, number, number, number], point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const distance: (line1: readonly [number, number, number, number, number, number, number, number], line2: readonly [number, number, number, number, number, number, number, number]) => number;
+export declare const angle: (line1: readonly [number, number, number, number, number, number, number, number], line2: readonly [number, number, number, number, number, number, number, number]) => number;
+export declare const sign: (line: readonly [number, number, number, number, number, number, number, number]) => number;

package/types/gapoints.d.ts

@@ -0,0 +1,7 @@
+export declare const from: ([x, y]: readonly [number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const toTuple: (point: readonly [number, number, number, number, number, number, number, number]) => [number, number];
+export declare const abs: (point: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const intersect: (line1: readonly [number, number, number, number, number, number, number, number], line2: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const project: (point: readonly [number, number, number, number, number, number, number, number], line: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const distance: (point1: readonly [number, number, number, number, number, number, number, number], point2: readonly [number, number, number, number, number, number, number, number]) => number;
+export declare const distanceToLine: (point: readonly [number, number, number, number, number, number, number, number], line: readonly [number, number, number, number, number, number, number, number]) => number;

package/types/gatransforms.d.ts

@@ -0,0 +1,10 @@
+import { Line, Direction, Point } from "./ga";
+/**
+ * TODO: docs
+ */
+export declare const rotation: (pivot: readonly [number, number, number, number, number, number, number, number], angle: number) => readonly [number, number, number, number, number, number, number, number];
+export declare const translation: (direction: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const translationOrthogonal: (direction: readonly [number, number, number, number, number, number, number, number], distance: number) => readonly [number, number, number, number, number, number, number, number];
+export declare const translationAlong: (line: readonly [number, number, number, number, number, number, number, number], distance: number) => readonly [number, number, number, number, number, number, number, number];
+export declare const compose: (motor1: readonly [number, number, number, number, number, number, number, number], motor2: readonly [number, number, number, number, number, number, number, number]) => readonly [number, number, number, number, number, number, number, number];
+export declare const apply: (motor: readonly [number, number, number, number, number, number, number, number], nvector: Point | Direction | Line) => Point | Direction | Line;

package/types/gesture.d.ts

@@ -0,0 +1,6 @@
+import { PointerCoords } from "./types";
+export declare const getCenter: (pointers: Map<number, PointerCoords>) => {
+    x: number;
+    y: number;
+};
+export declare const getDistance: ([a, b]: readonly PointerCoords[]) => number;

package/types/groups.d.ts

@@ -0,0 +1,26 @@
+import { GroupId, ExcalidrawElement, NonDeleted } from "./element/types";
+import { AppState } from "./types";
+export declare const selectGroup: (groupId: GroupId, appState: AppState, elements: readonly NonDeleted<ExcalidrawElement>[]) => AppState;
+/**
+ * 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 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[];
+export declare const getSelectedGroupIdForElement: (element: ExcalidrawElement, selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string | undefined;
+export declare const getNewGroupIdsForDuplication: (groupIds: ExcalidrawElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
+export declare const addToGroup: (prevGroupIds: ExcalidrawElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
+export declare const removeFromSelectedGroups: (groupIds: ExcalidrawElement["groupIds"], selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string[];

package/types/history.d.ts

@@ -0,0 +1,52 @@
+import { AppState } from "./types";
+import { ExcalidrawElement } from "./element/types";
+export interface HistoryEntry {
+    appState: ReturnType<typeof clearAppStatePropertiesForHistory>;
+    elements: ExcalidrawElement[];
+}
+declare const clearAppStatePropertiesForHistory: (appState: AppState) => {
+    selectedElementIds: {
+        [id: string]: boolean;
+    };
+    selectedGroupIds: {
+        [groupId: string]: boolean;
+    };
+    viewBackgroundColor: string;
+    editingLinearElement: import("./element/linearElementEditor").LinearElementEditor | null;
+    editingGroupId: string | null;
+    name: string;
+};
+declare class History {
+    private elementCache;
+    private recording;
+    private stateHistory;
+    private redoStack;
+    private lastEntry;
+    private hydrateHistoryEntry;
+    private dehydrateHistoryEntry;
+    getSnapshotForTest(): {
+        recording: boolean;
+        stateHistory: HistoryEntry[];
+        redoStack: HistoryEntry[];
+    };
+    clear(): void;
+    private generateEntry;
+    shouldCreateEntry(nextEntry: HistoryEntry): boolean;
+    pushEntry(appState: AppState, elements: readonly ExcalidrawElement[]): void;
+    clearRedoStack(): void;
+    redoOnce(): HistoryEntry | null;
+    undoOnce(): HistoryEntry | null;
+    /**
+     * Updates history's `lastEntry` to latest app state. This is necessary
+     *  when doing undo/redo which itself doesn't commit to history, but updates
+     *  app state in a way that would break `shouldCreateEntry` which relies on
+     *  `lastEntry` to reflect last comittable history state.
+     * We can't update `lastEntry` from within history when calling undo/redo
+     *  because the action potentially mutates appState/elements before storing
+     *  it.
+     */
+    setCurrentState(appState: AppState, elements: readonly ExcalidrawElement[]): void;
+    resumeRecording(): void;
+    record(state: AppState, elements: readonly ExcalidrawElement[]): void;
+}
+export default History;

package/types/hooks/useCallbackRefState.d.ts

@@ -0,0 +1 @@
+export declare const useCallbackRefState: <T>() => readonly [T | null, (value: T | null) => void];

package/types/i18n.d.ts

@@ -0,0 +1,15 @@
+export interface Language {
+    code: string;
+    label: string;
+    rtl?: boolean;
+}
+export declare const defaultLang: {
+    code: string;
+    label: string;
+};
+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?: {
+    [key: string]: string;
+} | undefined) => string;

package/types/keys.d.ts

@@ -0,0 +1,61 @@
+export declare const isDarwin: boolean;
+export declare const isWindows: boolean;
+export declare const CODES: {
+    readonly EQUAL: "Equal";
+    readonly MINUS: "Minus";
+    readonly NUM_ADD: "NumpadAdd";
+    readonly NUM_SUBTRACT: "NumpadSubtract";
+    readonly NUM_ZERO: "Numpad0";
+    readonly BRACKET_RIGHT: "BracketRight";
+    readonly BRACKET_LEFT: "BracketLeft";
+    readonly ONE: "Digit1";
+    readonly TWO: "Digit2";
+    readonly NINE: "Digit9";
+    readonly QUOTE: "Quote";
+    readonly ZERO: "Digit0";
+    readonly SLASH: "Slash";
+    readonly C: "KeyC";
+    readonly D: "KeyD";
+    readonly G: "KeyG";
+    readonly F: "KeyF";
+    readonly H: "KeyH";
+    readonly V: "KeyV";
+    readonly X: "KeyX";
+    readonly Z: "KeyZ";
+    readonly R: "KeyR";
+};
+export declare const KEYS: {
+    readonly ARROW_DOWN: "ArrowDown";
+    readonly ARROW_LEFT: "ArrowLeft";
+    readonly ARROW_RIGHT: "ArrowRight";
+    readonly ARROW_UP: "ArrowUp";
+    readonly BACKSPACE: "Backspace";
+    readonly ALT: "Alt";
+    readonly CTRL_OR_CMD: "metaKey" | "ctrlKey";
+    readonly DELETE: "Delete";
+    readonly ENTER: "Enter";
+    readonly ESCAPE: "Escape";
+    readonly QUESTION_MARK: "?";
+    readonly SPACE: " ";
+    readonly TAB: "Tab";
+    readonly A: "a";
+    readonly D: "d";
+    readonly E: "e";
+    readonly G: "g";
+    readonly L: "l";
+    readonly O: "o";
+    readonly P: "p";
+    readonly Q: "q";
+    readonly R: "r";
+    readonly S: "s";
+    readonly T: "t";
+    readonly V: "v";
+    readonly X: "x";
+    readonly Y: "y";
+    readonly Z: "z";
+};
+export declare type Key = keyof typeof KEYS;
+export declare const isArrowKey: (key: string) => boolean;
+export declare const getResizeCenterPointKey: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const getResizeWithSidesSameLengthKey: (event: MouseEvent | KeyboardEvent) => boolean;
+export declare const getRotateWithDiscreteAngleKey: (event: MouseEvent | KeyboardEvent) => boolean;

package/types/math.d.ts

@@ -0,0 +1,20 @@
+import { Point, Zoom } from "./types";
+import { ExcalidrawLinearElement } from "./element/types";
+export declare const rotate: (x1: number, y1: number, x2: number, y2: number, angle: number) => [number, number];
+export declare const rotatePoint: (point: readonly [number, number], center: readonly [number, number], angle: number) => [number, number];
+export declare const adjustXYWithRotation: (sides: {
+    n?: boolean;
+    e?: boolean;
+    s?: boolean;
+    w?: boolean;
+}, x: number, y: number, angle: number, deltaX1: number, deltaY1: number, deltaX2: number, deltaY2: number) => [number, number];
+export declare const getPointOnAPath: (point: readonly [number, number], path: Point[]) => {
+    x: number;
+    y: number;
+    segment: number;
+} | null;
+export declare const distance2d: (x1: number, y1: number, x2: number, y2: number) => 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 getGridPoint: (x: number, y: number, gridSize: number | null) => [number, number];