@zsviczian/excalidraw 0.17.1-obsidian-43 → 0.17.1-obsidian-44

package/types/excalidraw/fonts/index.d.ts

@@ -1,83 +1,83 @@
-import type Scene from "../scene/Scene";
-import type { ValueOf } from "../utility-types";
-import type { ExcalidrawElement, ExcalidrawTextElement, FontFamilyValues } from "../element/types";
-import { FONT_FAMILY } from "../constants";
-import { type FontMetadata } from "./metadata";
-import { type Font } from "./ExcalidrawFont";
-export declare class Fonts {
-    static readonly loadedFontsCache: Set<string>;
-    private static _registered;
-    private static _initialized;
-    static get registered(): Map<number, {
-        metadata: FontMetadata;
-        fonts: Font[];
-    }>;
-    get registered(): Map<number, {
-        metadata: FontMetadata;
-        fonts: Font[];
-    }>;
-    private readonly scene;
-    constructor({ scene }: {
-        scene: Scene;
-    });
-    /**
-     * if we load a (new) font, it's likely that text elements using it have
-     * already been rendered using a fallback font. Thus, we want invalidate
-     * their shapes and rerender. See #637.
-     *
-     * Invalidates text elements and rerenders scene, provided that at least one
-     * of the supplied fontFaces has not already been processed.
-     */
-    onLoaded: (fontFaces: readonly FontFace[]) => false | undefined;
-    /**
-     * Load font faces for a given scene and trigger scene update.
-     */
-    loadSceneFonts: () => Promise<FontFace[]>;
-    /**
-     * Gets all the font families for the given scene.
-     */
-    getSceneFontFamilies: () => number[];
-    /**
-     * Load font faces for passed elements - use when the scene is unavailable (i.e. export).
-     */
-    static loadFontsForElements: (elements: readonly ExcalidrawElement[]) => Promise<FontFace[]>;
-    private static loadFontFaces;
-    /**
-     * WARN: should be called just once on init, even across multiple instances.
-     */
-    private static init;
-    private static getFontFamilies;
-}
-/**
- * Register a new font.
- *
- * @param family font family
- * @param metadata font metadata
- * @param params array of the rest of the FontFace parameters [uri: string, descriptors: FontFaceDescriptors?] ,
- */
-export declare function register(//zsviczian (changed from private to export)
-this: Fonts | {
-    registered: Map<ValueOf<typeof FONT_FAMILY>, {
-        metadata: FontMetadata;
-        fonts: Font[];
-    }>;
-}, family: string, metadata: FontMetadata, ...params: Array<{
-    uri: string;
-    descriptors?: FontFaceDescriptors;
-}>): Map<number, {
-    metadata: FontMetadata;
-    fonts: Font[];
-}> | Map<number, {
-    metadata: FontMetadata;
-    fonts: Font[];
-}>;
-/**
- * Calculates vertical offset for a text with alphabetic baseline.
- */
-export declare const getVerticalOffset: (fontFamily: ExcalidrawTextElement["fontFamily"], fontSize: ExcalidrawTextElement["fontSize"], lineHeightPx: number) => number;
-/**
- * Gets line height forr a selected family.
- */
-export declare const getLineHeight: (fontFamily: FontFamilyValues) => number & {
-    _brand: "unitlessLineHeight";
-};
+import type Scene from "../scene/Scene";
+import type { ValueOf } from "../utility-types";
+import type { ExcalidrawElement, ExcalidrawTextElement, FontFamilyValues } from "../element/types";
+import { FONT_FAMILY } from "../constants";
+import { type FontMetadata } from "./metadata";
+import { type Font } from "./ExcalidrawFont";
+export declare class Fonts {
+    static readonly loadedFontsCache: Set<string>;
+    private static _registered;
+    private static _initialized;
+    static get registered(): Map<number, {
+        metadata: FontMetadata;
+        fonts: Font[];
+    }>;
+    get registered(): Map<number, {
+        metadata: FontMetadata;
+        fonts: Font[];
+    }>;
+    private readonly scene;
+    constructor({ scene }: {
+        scene: Scene;
+    });
+    /**
+     * if we load a (new) font, it's likely that text elements using it have
+     * already been rendered using a fallback font. Thus, we want invalidate
+     * their shapes and rerender. See #637.
+     *
+     * Invalidates text elements and rerenders scene, provided that at least one
+     * of the supplied fontFaces has not already been processed.
+     */
+    onLoaded: (fontFaces: readonly FontFace[]) => false | undefined;
+    /**
+     * Load font faces for a given scene and trigger scene update.
+     */
+    loadSceneFonts: () => Promise<FontFace[]>;
+    /**
+     * Gets all the font families for the given scene.
+     */
+    getSceneFontFamilies: () => number[];
+    /**
+     * Load font faces for passed elements - use when the scene is unavailable (i.e. export).
+     */
+    static loadFontsForElements: (elements: readonly ExcalidrawElement[]) => Promise<FontFace[]>;
+    private static loadFontFaces;
+    /**
+     * WARN: should be called just once on init, even across multiple instances.
+     */
+    private static init;
+    private static getFontFamilies;
+}
+/**
+ * Register a new font.
+ *
+ * @param family font family
+ * @param metadata font metadata
+ * @param params array of the rest of the FontFace parameters [uri: string, descriptors: FontFaceDescriptors?] ,
+ */
+export declare function register(//zsviczian (changed from private to export)
+this: Fonts | {
+    registered: Map<ValueOf<typeof FONT_FAMILY>, {
+        metadata: FontMetadata;
+        fonts: Font[];
+    }>;
+}, family: string, metadata: FontMetadata, ...params: Array<{
+    uri: string;
+    descriptors?: FontFaceDescriptors;
+}>): Map<number, {
+    metadata: FontMetadata;
+    fonts: Font[];
+}> | Map<number, {
+    metadata: FontMetadata;
+    fonts: Font[];
+}>;
+/**
+ * Calculates vertical offset for a text with alphabetic baseline.
+ */
+export declare const getVerticalOffset: (fontFamily: ExcalidrawTextElement["fontFamily"], fontSize: ExcalidrawTextElement["fontSize"], lineHeightPx: number) => number;
+/**
+ * Gets line height forr a selected family.
+ */
+export declare const getLineHeight: (fontFamily: FontFamilyValues) => number & {
+    _brand: "unitlessLineHeight";
+};

package/types/excalidraw/fonts/metadata.d.ts

@@ -1,35 +1,35 @@
-/**
- * Encapsulates font metrics with additional font metadata.
- * */
-export interface FontMetadata {
-    /** for head & hhea metrics read the woff2 with https://fontdrop.info/ */
-    metrics: {
-        /** head.unitsPerEm metric */
-        unitsPerEm: 1000 | 1024 | 2048;
-        /** hhea.ascender metric */
-        ascender: number;
-        /** hhea.descender metric */
-        descender: number;
-        /** harcoded unitless line-height, https://github.com/excalidraw/excalidraw/pull/6360#issuecomment-1477635971 */
-        lineHeight: number;
-    };
-    /** element to be displayed as an icon  */
-    icon: JSX.Element;
-    /** flag to indicate a deprecated font */
-    deprecated?: true;
-    /** flag to indicate a server-side only font */
-    serverSide?: true;
-    /** flag to indiccate a local-only font */
-    local?: true;
-}
-export declare const FONT_METADATA: Record<number, FontMetadata>;
-/** Unicode ranges */
-export declare const RANGES: {
-    LATIN: string;
-    LATIN_EXT: string;
-    CYRILIC_EXT: string;
-    CYRILIC: string;
-    VIETNAMESE: string;
-};
-/** local protocol to skip the local font from registering or inlining */
-export declare const LOCAL_FONT_PROTOCOL = "local:";
+/**
+ * Encapsulates font metrics with additional font metadata.
+ * */
+export interface FontMetadata {
+    /** for head & hhea metrics read the woff2 with https://fontdrop.info/ */
+    metrics: {
+        /** head.unitsPerEm metric */
+        unitsPerEm: 1000 | 1024 | 2048;
+        /** hhea.ascender metric */
+        ascender: number;
+        /** hhea.descender metric */
+        descender: number;
+        /** harcoded unitless line-height, https://github.com/excalidraw/excalidraw/pull/6360#issuecomment-1477635971 */
+        lineHeight: number;
+    };
+    /** element to be displayed as an icon  */
+    icon: JSX.Element;
+    /** flag to indicate a deprecated font */
+    deprecated?: true;
+    /** flag to indicate a server-side only font */
+    serverSide?: true;
+    /** flag to indiccate a local-only font */
+    local?: true;
+}
+export declare const FONT_METADATA: Record<number, FontMetadata>;
+/** Unicode ranges */
+export declare const RANGES: {
+    LATIN: string;
+    LATIN_EXT: string;
+    CYRILIC_EXT: string;
+    CYRILIC: string;
+    VIETNAMESE: string;
+};
+/** local protocol to skip the local font from registering or inlining */
+export declare const LOCAL_FONT_PROTOCOL = "local:";

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

@@ -1,63 +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 {};
+/**
+ * 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

@@ -1,8 +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];
+/**
+ * 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];