@zsviczian/excalidraw 0.17.6-18 → 0.17.6-19

package/types/excalidraw/fractionalIndex.d.ts

@@ -1,48 +1,48 @@
-import type { ExcalidrawElement, OrderedExcalidrawElement } from "./element/types";
-/**
- * Envisioned relation between array order and fractional indices:
- *
- * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
- * - it's undesirable to perform reorder for each related operation, therefore it's necessary to cache the order defined by fractional indices into an ordered data structure
- * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
- * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple excalidraw versions etc.
- * - it's necessary to always keep the fractional indices in sync with the array order
- * - elements with invalid indices should be detected and synced, without altering the already valid indices
- *
- * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
- * - as the fractional indices are encoded as part of the elements, it opens up possibilities for incremental-like APIs
- * - re-order based on fractional indices should be part of (multiplayer) operations such as reconciliation & undo/redo
- * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
- *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
- */
-/**
- * Ensure that all elements have valid fractional indices.
- *
- * @throws `InvalidFractionalIndexError` if invalid index is detected.
- */
-export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
-    shouldThrow: boolean;
-    includeBoundTextValidation: boolean;
-    ignoreLogs?: true | undefined;
-    reconciliationContext?: {
-        localElements: ReadonlyArray<ExcalidrawElement>;
-        remoteElements: ReadonlyArray<ExcalidrawElement>;
-    } | undefined;
-}) => void;
-/**
- * Order the elements based on the fractional indices.
- * - when fractional indices are identical, break the tie based on the element id
- * - when there is no fractional index in one of the elements, respect the order of the array
- */
-export declare const orderByFractionalIndex: (elements: OrderedExcalidrawElement[]) => OrderedExcalidrawElement[];
-/**
- * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
- * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
- */
-export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: Map<string, ExcalidrawElement>) => OrderedExcalidrawElement[];
-/**
- * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
- *
- * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
- */
-export declare const syncInvalidIndices: (elements: readonly ExcalidrawElement[]) => OrderedExcalidrawElement[];
+import type { ExcalidrawElement, OrderedExcalidrawElement } from "./element/types";
+/**
+ * Envisioned relation between array order and fractional indices:
+ *
+ * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
+ * - it's undesirable to perform reorder for each related operation, therefore it's necessary to cache the order defined by fractional indices into an ordered data structure
+ * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
+ * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple excalidraw versions etc.
+ * - it's necessary to always keep the fractional indices in sync with the array order
+ * - elements with invalid indices should be detected and synced, without altering the already valid indices
+ *
+ * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
+ * - as the fractional indices are encoded as part of the elements, it opens up possibilities for incremental-like APIs
+ * - re-order based on fractional indices should be part of (multiplayer) operations such as reconciliation & undo/redo
+ * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
+ *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
+ */
+/**
+ * Ensure that all elements have valid fractional indices.
+ *
+ * @throws `InvalidFractionalIndexError` if invalid index is detected.
+ */
+export declare const validateFractionalIndices: (elements: readonly ExcalidrawElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
+    shouldThrow: boolean;
+    includeBoundTextValidation: boolean;
+    ignoreLogs?: true | undefined;
+    reconciliationContext?: {
+        localElements: ReadonlyArray<ExcalidrawElement>;
+        remoteElements: ReadonlyArray<ExcalidrawElement>;
+    } | undefined;
+}) => void;
+/**
+ * Order the elements based on the fractional indices.
+ * - when fractional indices are identical, break the tie based on the element id
+ * - when there is no fractional index in one of the elements, respect the order of the array
+ */
+export declare const orderByFractionalIndex: (elements: OrderedExcalidrawElement[]) => OrderedExcalidrawElement[];
+/**
+ * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
+ * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
+ */
+export declare const syncMovedIndices: (elements: readonly ExcalidrawElement[], movedElements: Map<string, ExcalidrawElement>) => OrderedExcalidrawElement[];
+/**
+ * Synchronizes all invalid fractional indices with the array order by mutating passed elements.
+ *
+ * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
+ */
+export declare const syncInvalidIndices: (elements: readonly ExcalidrawElement[]) => OrderedExcalidrawElement[];

package/types/excalidraw/frame.d.ts

@@ -1,63 +1,63 @@
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
-import type { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
-import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
-import type { ReadonlySetLike } from "./utility-types";
-export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
-export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
-export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
-export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
-export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
-export declare const isCursorInFrame: (cursorCoords: {
-    x: number;
-    y: number;
-}, frame: NonDeleted<ExcalidrawFrameLikeElement>, elementsMap: ElementsMap) => boolean;
-export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
-export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
-/**
- * Returns a map of frameId to frame elements. Includes empty frames.
- */
-export declare const groupByFrameLikes: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
-export declare const getFrameChildren: (allElements: ElementsMapOrArray, frameId: string) => ExcalidrawElement[];
-export declare const getFrameLikeElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameLikeElement[];
-/**
- * Returns ExcalidrawFrameElements and non-frame-children elements.
- *
- * Considers children as root elements if they point to a frame parent
- * non-existing in the elements set.
- *
- * Considers non-frame bound elements (container or arrow labels) as root.
- */
-export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
-export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
-export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
-/** */
-export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
-/**
- * Retains (or repairs for target frame) the ordering invriant where children
- * elements come right before the parent frame:
- * [el, el, child, child, frame, el]
- *
- * @returns mutated allElements (same data structure)
- */
-export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => T;
-export declare const removeElementsFromFrame: (elementsToRemove: ReadonlySetLike<NonDeletedExcalidrawElement>, elementsMap: ElementsMap) => void;
-export declare const removeAllElementsFromFrame: <T extends ExcalidrawElement>(allElements: readonly T[], frame: ExcalidrawFrameLikeElement) => readonly T[];
-export declare const replaceAllElementsInFrame: <T extends ExcalidrawElement>(allElements: readonly T[], nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, app: AppClassProperties) => T[];
-/** does not mutate elements, but returns new ones */
-export declare const updateFrameMembershipOfSelectedElements: <T extends ElementsMapOrArray>(allElements: T, appState: AppState, app: AppClassProperties) => T;
-/**
- * filters out elements that are inside groups that contain a frame element
- * anywhere in the group tree
- */
-export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, 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, elementsMap: ElementsMap, appState: StaticCanvasAppState) => import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | null;
-export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState) => boolean;
-export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement) => string;
-export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];
+import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted, NonDeletedExcalidrawElement } from "./element/types";
+import type { AppClassProperties, AppState, StaticCanvasAppState } from "./types";
+import type { ExcalidrawElementsIncludingDeleted } from "./scene/Scene";
+import type { ReadonlySetLike } from "./utility-types";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly ExcalidrawElement[], oldElements: readonly ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
+export declare function isElementIntersectingFrame(element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap): boolean;
+export declare const getElementsCompletelyInFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const isElementContainingFrame: (elements: readonly ExcalidrawElement[], element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const getElementsIntersectingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
+export declare const elementsAreInFrameBounds: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const elementOverlapsWithFrame: (element: ExcalidrawElement, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const isCursorInFrame: (cursorCoords: {
+    x: number;
+    y: number;
+}, frame: NonDeleted<ExcalidrawFrameLikeElement>, elementsMap: ElementsMap) => boolean;
+export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
+export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedExcalidrawElement[], groupIds: readonly string[], frame: ExcalidrawFrameLikeElement) => boolean;
+/**
+ * Returns a map of frameId to frame elements. Includes empty frames.
+ */
+export declare const groupByFrameLikes: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
+export declare const getFrameChildren: (allElements: ElementsMapOrArray, frameId: string) => ExcalidrawElement[];
+export declare const getFrameLikeElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameLikeElement[];
+/**
+ * Returns ExcalidrawFrameElements and non-frame-children elements.
+ *
+ * Considers children as root elements if they point to a frame parent
+ * non-existing in the elements set.
+ *
+ * Considers non-frame bound elements (container or arrow labels) as root.
+ */
+export declare const getRootElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawElement[];
+export declare const getElementsInResizingFrame: (allElements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const getElementsInNewFrame: (elements: ExcalidrawElementsIncludingDeleted, frame: ExcalidrawFrameLikeElement, elementsMap: ElementsMap) => ExcalidrawElement[];
+export declare const getContainingFrame: (element: ExcalidrawElement, elementsMap: ElementsMap) => ExcalidrawFrameLikeElement | null;
+/** */
+export declare const filterElementsEligibleAsFrameChildren: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => ExcalidrawElement[];
+/**
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
+ *
+ * @returns mutated allElements (same data structure)
+ */
+export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: NonDeletedExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => T;
+export declare const removeElementsFromFrame: (elementsToRemove: ReadonlySetLike<NonDeletedExcalidrawElement>, elementsMap: ElementsMap) => void;
+export declare const removeAllElementsFromFrame: <T extends ExcalidrawElement>(allElements: readonly T[], frame: ExcalidrawFrameLikeElement) => readonly T[];
+export declare const replaceAllElementsInFrame: <T extends ExcalidrawElement>(allElements: readonly T[], nextElementsInFrame: ExcalidrawElement[], frame: ExcalidrawFrameLikeElement, app: AppClassProperties) => T[];
+/** does not mutate elements, but returns new ones */
+export declare const updateFrameMembershipOfSelectedElements: <T extends ElementsMapOrArray>(allElements: T, appState: AppState, app: AppClassProperties) => T;
+/**
+ * filters out elements that are inside groups that contain a frame element
+ * anywhere in the group tree
+ */
+export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, 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, elementsMap: ElementsMap, appState: StaticCanvasAppState) => import("./element/types").ExcalidrawFrameElement | import("./element/types").ExcalidrawMagicFrameElement | null;
+export declare const isElementInFrame: (element: ExcalidrawElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState) => boolean;
+export declare const getFrameLikeTitle: (element: ExcalidrawFrameLikeElement) => string;
+export declare const getElementsOverlappingFrame: (elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement) => NonDeletedExcalidrawElement[];

package/types/excalidraw/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 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;
+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/excalidraw/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/excalidraw/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)` corresponds 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/excalidraw/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/excalidraw/gatransforms.d.ts

@@ -0,0 +1,10 @@
+import type { 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/excalidraw/gesture.d.ts

@@ -1,6 +1,6 @@
-import type { PointerCoords } from "./types";
-export declare const getCenter: (pointers: Map<number, PointerCoords>) => {
-    x: number;
-    y: number;
-};
-export declare const getDistance: ([a, b]: readonly PointerCoords[]) => number;
+import type { 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/excalidraw/groups.d.ts

@@ -1,33 +1,33 @@
-import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./element/types";
-import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
-import type { 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: 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: ElementsMapOrArray, 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[];
-export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
-export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
-export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
-export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;
+import type { GroupId, ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ElementsMapOrArray, ElementsMap } from "./element/types";
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "./types";
+import type { 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: 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: ElementsMapOrArray, 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[];
+export declare const getMaximumGroups: (elements: ExcalidrawElement[], elementsMap: ElementsMap) => ExcalidrawElement[][];
+export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
+export declare const elementsAreInSameGroup: (elements: readonly ExcalidrawElement[]) => boolean;
+export declare const isInGroup: (element: NonDeletedExcalidrawElement) => boolean;

package/types/excalidraw/history.d.ts

@@ -1,40 +1,40 @@
-import type { AppStateChange, ElementsChange } from "./change";
-import type { SceneElementsMap } from "./element/types";
-import { Emitter } from "./emitter";
-import type { Snapshot } from "./store";
-import type { AppState } from "./types";
-export declare class HistoryChangedEvent {
-    readonly isUndoStackEmpty: boolean;
-    readonly isRedoStackEmpty: boolean;
-    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
-}
-export declare class History {
-    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
-    private readonly undoStack;
-    private readonly redoStack;
-    get isUndoStackEmpty(): boolean;
-    get isRedoStackEmpty(): boolean;
-    clear(): void;
-    /**
-     * Record a local change which will go into the history
-     */
-    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
-    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
-    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
-    private perform;
-    private static pop;
-    private static push;
-}
-export declare class HistoryEntry {
-    readonly appStateChange: AppStateChange;
-    readonly elementsChange: ElementsChange;
-    private constructor();
-    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
-    inverse(): HistoryEntry;
-    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
-    /**
-     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
-     */
-    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
-    isEmpty(): boolean;
-}
+import type { AppStateChange, ElementsChange } from "./change";
+import type { SceneElementsMap } from "./element/types";
+import { Emitter } from "./emitter";
+import type { Snapshot } from "./store";
+import type { AppState } from "./types";
+export declare class HistoryChangedEvent {
+    readonly isUndoStackEmpty: boolean;
+    readonly isRedoStackEmpty: boolean;
+    constructor(isUndoStackEmpty?: boolean, isRedoStackEmpty?: boolean);
+}
+export declare class History {
+    readonly onHistoryChangedEmitter: Emitter<[HistoryChangedEvent]>;
+    private readonly undoStack;
+    private readonly redoStack;
+    get isUndoStackEmpty(): boolean;
+    get isRedoStackEmpty(): boolean;
+    clear(): void;
+    /**
+     * Record a local change which will go into the history
+     */
+    record(elementsChange: ElementsChange, appStateChange: AppStateChange): void;
+    undo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    redo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): void | [SceneElementsMap, AppState];
+    private perform;
+    private static pop;
+    private static push;
+}
+export declare class HistoryEntry {
+    readonly appStateChange: AppStateChange;
+    readonly elementsChange: ElementsChange;
+    private constructor();
+    static create(appStateChange: AppStateChange, elementsChange: ElementsChange): HistoryEntry;
+    inverse(): HistoryEntry;
+    applyTo(elements: SceneElementsMap, appState: AppState, snapshot: Readonly<Snapshot>): [SceneElementsMap, AppState, boolean];
+    /**
+     * Apply latest (remote) changes to the history entry, creates new instance of `HistoryEntry`.
+     */
+    applyLatestChanges(elements: SceneElementsMap): HistoryEntry;
+    isEmpty(): boolean;
+}

package/types/excalidraw/hooks/useCallbackRefState.d.ts

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

package/types/excalidraw/hooks/useCopiedIndicator.d.ts

@@ -1,5 +1,5 @@
-export declare const useCopyStatus: () => {
-    copyStatus: "success" | null;
-    resetCopyStatus: () => void;
-    onCopy: () => void;
-};
+export declare const useCopyStatus: () => {
+    copyStatus: "success" | null;
+    resetCopyStatus: () => void;
+    onCopy: () => void;
+};

package/types/excalidraw/hooks/useCreatePortalContainer.d.ts

@@ -1,7 +1,7 @@
-export declare const useCreatePortalContainer: (opts?: {
-    className?: string | undefined;
-    parentSelector?: string | undefined;
-    style?: {
-        [x: string]: string;
-    } | undefined;
-} | undefined) => HTMLDivElement | null;
+export declare const useCreatePortalContainer: (opts?: {
+    className?: string | undefined;
+    parentSelector?: string | undefined;
+    style?: {
+        [x: string]: string;
+    } | undefined;
+} | undefined) => HTMLDivElement | null;

package/types/excalidraw/hooks/useEmitter.d.ts

@@ -1,2 +1,2 @@
-import type { Emitter } from "../emitter";
-export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;
+import type { Emitter } from "../emitter";
+export declare const useEmitter: <TEvent extends unknown>(emitter: Emitter<[TEvent]>, initialState: TEvent) => TEvent;

package/types/excalidraw/hooks/useLibraryItemSvg.d.ts

@@ -1,11 +1,11 @@
-import type { 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;
-};
+import type { 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/excalidraw/hooks/useOutsideClick.d.ts

@@ -1,19 +1,19 @@
-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;
+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;