@wildmio/excalidraw 0.18.0-custom.1 → 0.18.0-custom.3

package/dist/types/element/src/selection.d.ts

@@ -1,34 +0,0 @@
-import type { AppState, InteractiveCanvasAppState } from "@excalidraw/excalidraw/types";
-import { LinearElementEditor } from "./linearElementEditor";
-import type { ElementsMap, ElementsMapOrArray, ExcalidrawElement, NonDeletedExcalidrawElement } from "./types";
-/**
- * Frames and their containing elements are not to be selected at the same time.
- * Given an array of selected elements, if there are frames and their containing elements
- * we only keep the frames.
- * @param selectedElements
- */
-export declare const excludeElementsInFramesFromSelection: <T extends ExcalidrawElement>(selectedElements: readonly T[]) => T[];
-export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement, elementsMap: ElementsMap, excludeElementsInFrames?: boolean) => NonDeletedExcalidrawElement[];
-export declare const getVisibleAndNonSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], selectedElements: readonly NonDeletedExcalidrawElement[], appState: AppState, elementsMap: ElementsMap) => NonDeletedExcalidrawElement[];
-export declare const isSomeElementSelected: {
-    (elements: readonly NonDeletedExcalidrawElement[], appState: Pick<AppState, "selectedElementIds">): boolean;
-    clearCache(): void;
-};
-export declare const getSelectedElements: (elements: ElementsMapOrArray, appState: Pick<InteractiveCanvasAppState, "selectedElementIds">, opts?: {
-    includeBoundTextElement?: boolean;
-    includeElementsInFrames?: boolean;
-}) => ExcalidrawElement[];
-export declare const getTargetElements: (elements: ElementsMapOrArray, appState: Pick<AppState, "selectedElementIds" | "editingTextElement" | "newElement">) => ExcalidrawElement[];
-/**
- * returns prevState's selectedElementids if no change from previous, so as to
- * retain reference identity for memoization
- */
-export declare const makeNextSelectedElementIds: (nextSelectedElementIds: AppState["selectedElementIds"], prevState: Pick<AppState, "selectedElementIds">) => Readonly<{
-    [id: string]: true;
-}>;
-export declare const getSelectionStateForElements: (targetElements: readonly ExcalidrawElement[], allElements: readonly NonDeletedExcalidrawElement[], appState: AppState) => {
-    editingGroupId: AppState["editingGroupId"];
-    selectedElementIds: AppState["selectedElementIds"];
-    selectedGroupIds: AppState["selectedGroupIds"];
-    selectedLinearElement: LinearElementEditor | null;
-};

package/dist/types/element/src/shape.d.ts

@@ -1,42 +0,0 @@
-import { type GeometricShape } from "@excalidraw/utils/shape";
-import { type LocalPoint } from "@excalidraw/math";
-import type { GlobalPoint } from "@excalidraw/math";
-import type { AppState, EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
-import type { ElementShape, ElementShapes } from "@excalidraw/excalidraw/scene/types";
-import type { ExcalidrawElement, ExcalidrawSelectionElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap, ExcalidrawLineElement } from "./types";
-import type { Drawable, Options } from "roughjs/bin/core";
-export declare class ShapeCache {
-    private static rg;
-    private static cache;
-    /**
-     * Retrieves shape from cache if available. Use this only if shape
-     * is optional and you have a fallback in case it's not cached.
-     */
-    static get: <T extends ExcalidrawElement>(element: T) => T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined;
-    static set: <T extends ExcalidrawElement>(element: T, shape: T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable) => WeakMap<ExcalidrawElement, ElementShape>;
-    static delete: (element: ExcalidrawElement) => boolean;
-    static destroy: () => void;
-    /**
-     * Generates & caches shape for element if not already cached, otherwise
-     * returns cached shape.
-     */
-    static generateElementShape: <T extends Exclude<ExcalidrawElement, ExcalidrawSelectionElement>>(element: T, renderConfig: {
-        isExporting: boolean;
-        canvasBackgroundColor: AppState["viewBackgroundColor"];
-        embedsValidationStatus: EmbedsValidationStatus;
-    } | null) => ((T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] | undefined : ElementShape | undefined) & {}) | (T["type"] extends keyof ElementShapes ? ElementShapes[T["type"]] : Drawable | null);
-}
-export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement) => {
-    op: string;
-    data: number[];
-}[];
-/**
- * get the pure geometric shape of an excalidraw elementw
- * which is then used for hit detection
- */
-export declare const getElementShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point>;
-export declare const toggleLinePolygonState: (element: ExcalidrawLineElement, nextPolygonState: boolean) => {
-    polygon: ExcalidrawLineElement["polygon"];
-    points: ExcalidrawLineElement["points"];
-} | null;

package/dist/types/element/src/showSelectedShapeActions.d.ts

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

package/dist/types/element/src/sizeHelpers.d.ts

@@ -1,35 +0,0 @@
-import type { AppState, Offsets, Zoom } from "@excalidraw/excalidraw/types";
-import type { ElementsMap, ExcalidrawElement } from "./types";
-export declare const INVISIBLY_SMALL_ELEMENT_SIZE = 0.1;
-export declare const isInvisiblySmallElement: (element: ExcalidrawElement) => boolean;
-export declare const isElementInViewport: (element: ExcalidrawElement, width: number, height: number, viewTransformations: {
-    zoom: Zoom;
-    offsetLeft: number;
-    offsetTop: number;
-    scrollX: number;
-    scrollY: number;
-}, elementsMap: ElementsMap) => boolean;
-export declare const isElementCompletelyInViewport: (elements: ExcalidrawElement[], width: number, height: number, viewTransformations: {
-    zoom: Zoom;
-    offsetLeft: number;
-    offsetTop: number;
-    scrollX: number;
-    scrollY: number;
-}, elementsMap: ElementsMap, padding?: Offsets) => boolean;
-/**
- * Makes a perfect shape or diagonal/horizontal/vertical line
- */
-export declare const getPerfectElementSize: (elementType: AppState["activeTool"]["type"], width: number, height: number) => {
-    width: number;
-    height: number;
-};
-export declare const getLockedLinearCursorAlignSize: (originX: number, originY: number, x: number, y: number, customAngle?: number) => {
-    width: number;
-    height: number;
-};
-export declare const getNormalizedDimensions: (element: Pick<ExcalidrawElement, "width" | "height" | "x" | "y">) => {
-    width: ExcalidrawElement["width"];
-    height: ExcalidrawElement["height"];
-    x: ExcalidrawElement["x"];
-    y: ExcalidrawElement["y"];
-};

package/dist/types/element/src/sortElements.d.ts

@@ -1,2 +0,0 @@
-import type { ExcalidrawElement } from "./types";
-export declare const normalizeElementOrder: (elements: readonly ExcalidrawElement[]) => readonly ExcalidrawElement[];

package/dist/types/element/src/store.d.ts

@@ -1,237 +0,0 @@
-import { Emitter } from "@excalidraw/common";
-import type App from "@excalidraw/excalidraw/components/App";
-import type { DTO, ValueOf } from "@excalidraw/common/utility-types";
-import type { AppState, ObservedAppState } from "@excalidraw/excalidraw/types";
-import { ElementsDelta, AppStateDelta } from "./delta";
-import type { ApplyToOptions } from "./delta";
-import type { ExcalidrawElement, OrderedExcalidrawElement, SceneElementsMap } from "./types";
-export declare const CaptureUpdateAction: {
-    /**
-     * Immediately undoable.
-     *
-     * Use for updates which should be captured.
-     * Should be used for most of the local updates, except ephemerals such as dragging or resizing.
-     *
-     * These updates will _immediately_ make it to the local undo / redo stacks.
-     */
-    readonly IMMEDIATELY: "IMMEDIATELY";
-    /**
-     * Never undoable.
-     *
-     * Use for updates which should never be recorded, such as remote updates
-     * or scene initialization.
-     *
-     * These updates will _never_ make it to the local undo / redo stacks.
-     */
-    readonly NEVER: "NEVER";
-    /**
-     * Eventually undoable.
-     *
-     * Use for updates which should not be captured immediately - likely
-     * exceptions which are part of some async multi-step process. Otherwise, all
-     * such updates would end up being captured with the next
-     * `CaptureUpdateAction.IMMEDIATELY` - triggered either by the next `updateScene`
-     * or internally by the editor.
-     *
-     * These updates will _eventually_ make it to the local undo / redo stacks.
-     */
-    readonly EVENTUALLY: "EVENTUALLY";
-};
-export type CaptureUpdateActionType = ValueOf<typeof CaptureUpdateAction>;
-/**
- * Store which captures the observed changes and emits them as `StoreIncrement` events.
- */
-export declare class Store {
-    private readonly app;
-    readonly onDurableIncrementEmitter: Emitter<[DurableIncrement]>;
-    readonly onStoreIncrementEmitter: Emitter<[DurableIncrement | EphemeralIncrement]>;
-    private scheduledMacroActions;
-    private scheduledMicroActions;
-    private _snapshot;
-    get snapshot(): StoreSnapshot;
-    set snapshot(snapshot: StoreSnapshot);
-    constructor(app: App);
-    scheduleAction(action: CaptureUpdateActionType): void;
-    /**
-     * Use to schedule a delta calculation, which will consquentially be emitted as `DurableStoreIncrement` and pushed in the undo stack.
-     */
-    scheduleCapture(): void;
-    /**
-     * Schedule special "micro" actions, to-be executed before the next commit, before it executes a scheduled "macro" action.
-     */
-    scheduleMicroAction(params: {
-        action: CaptureUpdateActionType;
-        elements: readonly ExcalidrawElement[] | undefined;
-        appState: AppState | ObservedAppState | undefined;
-    } | {
-        action: typeof CaptureUpdateAction.IMMEDIATELY;
-        change: StoreChange;
-        delta: StoreDelta;
-    } | {
-        action: typeof CaptureUpdateAction.NEVER | typeof CaptureUpdateAction.EVENTUALLY;
-        change: StoreChange;
-    }): void;
-    /**
-     * Performs the incoming `CaptureUpdateAction` and emits the corresponding `StoreIncrement`.
-     * Emits `DurableStoreIncrement` when action is "capture", emits `EphemeralStoreIncrement` otherwise.
-     *
-     * @emits StoreIncrement
-     */
-    commit(elements: SceneElementsMap | undefined, appState: AppState | ObservedAppState | undefined): void;
-    /**
-     * Clears the store instance.
-     */
-    clear(): void;
-    /**
-     * Performs delta & change calculation and emits a durable increment.
-     *
-     * @emits StoreIncrement.
-     */
-    private emitDurableIncrement;
-    /**
-     * Performs change calculation and emits an ephemeral increment.
-     *
-     * @emits EphemeralStoreIncrement
-     */
-    private emitEphemeralIncrement;
-    private applyChangeToSnapshot;
-    /**
-     * Clones the snapshot if there are changes detected.
-     */
-    private maybeCloneSnapshot;
-    private flushMicroActions;
-    private processAction;
-    /**
-     * Returns the scheduled macro action.
-     */
-    private getScheduledMacroAction;
-    /**
-     * Ensures that the scheduled actions invariant is satisfied.
-     */
-    private satisfiesScheduledActionsInvariant;
-}
-/**
- * Repsents a change to the store containing changed elements and appState.
- */
-export declare class StoreChange {
-    readonly elements: Record<string, OrderedExcalidrawElement>;
-    readonly appState: Partial<ObservedAppState>;
-    private constructor();
-    static create(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): StoreChange;
-}
-/**
- * Encpasulates any change to the store (durable or ephemeral).
- */
-export declare abstract class StoreIncrement {
-    readonly type: "durable" | "ephemeral";
-    readonly change: StoreChange;
-    protected constructor(type: "durable" | "ephemeral", change: StoreChange);
-    static isDurable(increment: StoreIncrement): increment is DurableIncrement;
-    static isEphemeral(increment: StoreIncrement): increment is EphemeralIncrement;
-}
-/**
- * Represents a durable change to the store.
- */
-export declare class DurableIncrement extends StoreIncrement {
-    readonly change: StoreChange;
-    readonly delta: StoreDelta;
-    constructor(change: StoreChange, delta: StoreDelta);
-}
-/**
- * Represents an ephemeral change to the store.
- */
-export declare class EphemeralIncrement extends StoreIncrement {
-    readonly change: StoreChange;
-    constructor(change: StoreChange);
-}
-/**
- * Represents a captured delta by the Store.
- */
-export declare class StoreDelta {
-    readonly id: string;
-    readonly elements: ElementsDelta;
-    readonly appState: AppStateDelta;
-    protected constructor(id: string, elements: ElementsDelta, appState: AppStateDelta);
-    /**
-     * Create a new instance of `StoreDelta`.
-     */
-    static create(elements: ElementsDelta, appState: AppStateDelta, opts?: {
-        id: string;
-    }): StoreDelta;
-    /**
-     * Calculate the delta between the previous and next snapshot.
-     */
-    static calculate(prevSnapshot: StoreSnapshot, nextSnapshot: StoreSnapshot): StoreDelta;
-    /**
-     * Restore a store delta instance from a DTO.
-     */
-    static restore(storeDeltaDTO: DTO<StoreDelta>): StoreDelta;
-    /**
-     * Parse and load the delta from the remote payload.
-     */
-    static load({ id, elements: { added, removed, updated }, appState: { delta: appStateDelta }, }: DTO<StoreDelta>): StoreDelta;
-    /**
-     * Squash the passed deltas into the aggregated delta instance.
-     */
-    static squash(...deltas: StoreDelta[]): StoreDelta;
-    /**
-     * Inverse store delta, creates new instance of `StoreDelta`.
-     */
-    static inverse(delta: StoreDelta): StoreDelta;
-    /**
-     * Apply the delta to the passed elements and appState, does not modify the snapshot.
-     */
-    static applyTo(delta: StoreDelta, elements: SceneElementsMap, appState: AppState, options?: ApplyToOptions): [SceneElementsMap, AppState, boolean];
-    /**
-     * Apply latest (remote) changes to the delta, creates new instance of `StoreDelta`.
-     */
-    static applyLatestChanges(delta: StoreDelta, prevElements: SceneElementsMap, nextElements: SceneElementsMap, modifierOptions?: "deleted" | "inserted"): StoreDelta;
-    static empty(): StoreDelta;
-    isEmpty(): boolean;
-}
-/**
- * Represents a snapshot of the captured or updated changes in the store,
- * used for producing deltas and emitting `DurableStoreIncrement`s.
- */
-export declare class StoreSnapshot {
-    readonly elements: SceneElementsMap;
-    readonly appState: ObservedAppState;
-    readonly metadata: {
-        didElementsChange: boolean;
-        didAppStateChange: boolean;
-        isEmpty?: boolean;
-    };
-    private _lastChangedElementsHash;
-    private _lastChangedAppStateHash;
-    private constructor();
-    static create(elements: SceneElementsMap, appState: AppState | ObservedAppState, metadata?: {
-        didElementsChange: boolean;
-        didAppStateChange: boolean;
-    }): StoreSnapshot;
-    static empty(): StoreSnapshot;
-    getChangedElements(prevSnapshot: StoreSnapshot): Record<string, OrderedExcalidrawElement>;
-    getChangedAppState(prevSnapshot: StoreSnapshot): Partial<ObservedAppState>;
-    isEmpty(): boolean | undefined;
-    /**
-     * Apply the change and return a new snapshot instance.
-     */
-    applyChange(change: StoreChange): StoreSnapshot;
-    /**
-     * Efficiently clone the existing snapshot, only if we detected changes.
-     *
-     * @returns same instance if there are no changes detected, new instance otherwise.
-     */
-    maybeClone(action: CaptureUpdateActionType, elements: SceneElementsMap | undefined, appState: AppState | ObservedAppState | undefined): StoreSnapshot;
-    private maybeCreateAppStateSnapshot;
-    private maybeCreateElementsSnapshot;
-    private detectChangedAppState;
-    /**
-     * Detect if there are any changed elements.
-     */
-    private detectChangedElements;
-    /**
-     * Perform structural clone, deep cloning only elements that changed.
-     */
-    private createElementsSnapshot;
-}
-export declare const getObservedAppState: (appState: AppState | ObservedAppState) => ObservedAppState;

package/dist/types/element/src/textElement.d.ts

@@ -1,40 +0,0 @@
-import { type Radians } from "@excalidraw/math";
-import type { AppState } from "@excalidraw/excalidraw/types";
-import type { ExtractSetType } from "@excalidraw/common/utility-types";
-import type { Scene } from "./Scene";
-import type { MaybeTransformHandleType } from "./transformHandles";
-import type { ElementsMap, ExcalidrawElement, ExcalidrawElementType, ExcalidrawTextContainer, ExcalidrawTextElement, ExcalidrawTextElementWithContainer, NonDeletedExcalidrawElement } from "./types";
-export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null, scene: Scene) => void;
-export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, scene: Scene, transformHandleType: MaybeTransformHandleType, shouldMaintainAspectRatio?: boolean) => void;
-export declare const computeBoundTextPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
-    x: number;
-    y: number;
-};
-export declare const getBoundTextElementId: (container: ExcalidrawElement | null) => string | null;
-export declare const getBoundTextElement: (element: ExcalidrawElement | null, elementsMap: ElementsMap) => ExcalidrawTextElementWithContainer | null;
-export declare const getContainerElement: (element: ExcalidrawTextElement | null, elementsMap: ElementsMap) => ExcalidrawTextContainer | null;
-export declare const getContainerCenter: (container: ExcalidrawElement, appState: AppState, elementsMap: ElementsMap) => {
-    x: number;
-    y: number;
-};
-export declare const getContainerCoords: (container: NonDeletedExcalidrawElement) => {
-    x: number;
-    y: number;
-};
-export declare const getTextElementAngle: (textElement: ExcalidrawTextElement, container: ExcalidrawTextContainer | null) => 0 | Radians;
-export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer, elementsMap: ElementsMap) => {
-    x: number;
-    y: number;
-} | undefined;
-export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
-export declare const suppportsHorizontalAlign: (selectedElements: NonDeletedExcalidrawElement[], elementsMap: ElementsMap) => boolean;
-declare const VALID_CONTAINER_TYPES: Set<string>;
-export declare const isValidTextContainer: (element: {
-    type: ExcalidrawElementType;
-}) => boolean;
-export declare const computeContainerDimensionForBoundText: (dimension: number, containerType: ExtractSetType<typeof VALID_CONTAINER_TYPES>) => number;
-export declare const getBoundTextMaxWidth: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElement | null) => number;
-export declare const getBoundTextMaxHeight: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => number;
-/** retrieves text from text elements and concatenates to a single string */
-export declare const getTextFromElements: (elements: readonly ExcalidrawElement[], separator?: string) => string;
-export {};

package/dist/types/element/src/textMeasurements.d.ts

@@ -1,39 +0,0 @@
-import type { FontString, ExcalidrawTextElement } from "./types";
-export declare const measureText: (text: string, font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => {
-    width: number;
-    height: number;
-};
-export declare const getApproxMinLineWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const getMinTextElementWidth: (font: FontString, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const isMeasureTextSupported: () => boolean;
-export declare const normalizeText: (text: string) => string;
-/**
- * To get unitless line-height (if unknown) we can calculate it by dividing
- * height-per-line by fontSize.
- */
-export declare const detectLineHeight: (textElement: ExcalidrawTextElement) => ExcalidrawTextElement["lineHeight"];
-/**
- * We calculate the line height from the font size and the unitless line height,
- * aligning with the W3C spec.
- */
-export declare const getLineHeightInPx: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const getApproxMinLineHeight: (fontSize: ExcalidrawTextElement["fontSize"], lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-/**
- * Set a custom text metrics provider.
- *
- * Useful for overriding the width calculation algorithm where canvas API is not available / desired.
- */
-export declare const setCustomTextMetricsProvider: (provider: TextMetricsProvider) => void;
-export interface TextMetricsProvider {
-    getLineWidth(text: string, fontString: FontString): number;
-}
-export declare const getLineWidth: (text: string, font: FontString) => number;
-export declare const getTextWidth: (text: string, font: FontString) => number;
-export declare const getTextHeight: (text: string, fontSize: number, lineHeight: ExcalidrawTextElement["lineHeight"]) => number;
-export declare const charWidth: {
-    calculate: (char: string, font: FontString) => number;
-    getCache: (font: FontString) => number[];
-    clearCache: (font: FontString) => void;
-};
-export declare const getMinCharWidth: (font: FontString) => number;
-export declare const getMaxCharWidth: (font: FontString) => number;

package/dist/types/element/src/textWrapping.d.ts

@@ -1,13 +0,0 @@
-import type { FontString } from "./types";
-/**
- * Test if a given text contains any CJK characters (including symbols, punctuation, etc,).
- */
-export declare const containsCJK: (text: string) => boolean;
-/**
- * Breaks the line into the tokens based on the found line break opporutnities.
- */
-export declare const parseTokens: (line: string) => string[];
-/**
- * Wraps the original text into the lines based on the given width.
- */
-export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;

package/dist/types/element/src/transform.d.ts

@@ -1,81 +0,0 @@
-import type { MarkOptional } from "@excalidraw/common/utility-types";
-import { type ElementConstructorOpts } from "./newElement";
-import type { ExcalidrawBindableElement, ExcalidrawElement, ExcalidrawFrameElement, ExcalidrawFreeDrawElement, ExcalidrawGenericElement, ExcalidrawIframeLikeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawMagicFrameElement, ExcalidrawSelectionElement, ExcalidrawTextElement, FileId, FontFamilyValues, TextAlign, VerticalAlign } from "./types";
-export type ValidLinearElement = {
-    type: "arrow" | "line";
-    x: number;
-    y: number;
-    label?: {
-        text: string;
-        fontSize?: number;
-        fontFamily?: FontFamilyValues;
-        textAlign?: TextAlign;
-        verticalAlign?: VerticalAlign;
-    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
-    end?: (({
-        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-        id?: ExcalidrawGenericElement["id"];
-    } | {
-        id: ExcalidrawGenericElement["id"];
-        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-    }) | (({
-        type: "text";
-        text: string;
-    } | {
-        type?: "text";
-        id: ExcalidrawTextElement["id"];
-        text: string;
-    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
-    start?: (({
-        type: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-        id?: ExcalidrawGenericElement["id"];
-    } | {
-        id: ExcalidrawGenericElement["id"];
-        type?: Exclude<ExcalidrawBindableElement["type"], "image" | "text" | "frame" | "magicframe" | "embeddable" | "iframe">;
-    }) | (({
-        type: "text";
-        text: string;
-    } | {
-        type?: "text";
-        id: ExcalidrawTextElement["id"];
-        text: string;
-    }) & Partial<ExcalidrawTextElement>)) & MarkOptional<ElementConstructorOpts, "x" | "y">;
-} & Partial<ExcalidrawLinearElement>;
-export type ValidContainer = {
-    type: Exclude<ExcalidrawGenericElement["type"], "selection">;
-    id?: ExcalidrawGenericElement["id"];
-    label?: {
-        text: string;
-        fontSize?: number;
-        fontFamily?: FontFamilyValues;
-        textAlign?: TextAlign;
-        verticalAlign?: VerticalAlign;
-    } & MarkOptional<ElementConstructorOpts, "x" | "y">;
-} & ElementConstructorOpts;
-export type ExcalidrawElementSkeleton = Extract<Exclude<ExcalidrawElement, ExcalidrawSelectionElement>, ExcalidrawIframeLikeElement | ExcalidrawFreeDrawElement> | ({
-    type: Extract<ExcalidrawLinearElement["type"], "line">;
-    x: number;
-    y: number;
-} & Partial<ExcalidrawLinearElement>) | ValidContainer | ValidLinearElement | ({
-    type: "text";
-    text: string;
-    x: number;
-    y: number;
-    id?: ExcalidrawTextElement["id"];
-} & Partial<ExcalidrawTextElement>) | ({
-    type: Extract<ExcalidrawImageElement["type"], "image">;
-    x: number;
-    y: number;
-    fileId: FileId;
-} & Partial<ExcalidrawImageElement>) | ({
-    type: "frame";
-    children: readonly ExcalidrawElement["id"][];
-    name?: string;
-} & Partial<ExcalidrawFrameElement>) | ({
-    type: "magicframe";
-    children: readonly ExcalidrawElement["id"][];
-    name?: string;
-} & Partial<ExcalidrawMagicFrameElement>);
-export declare const convertToExcalidrawElements: (elementsSkeleton: ExcalidrawElementSkeleton[] | null, opts?: {
-    regenerateIds: boolean;
-}) => import("./types").OrderedExcalidrawElement[];

package/dist/types/element/src/transformHandles.d.ts

@@ -1,36 +0,0 @@
-import { type EditorInterface } from "@excalidraw/common";
-import type { Radians } from "@excalidraw/math";
-import type { InteractiveCanvasAppState, Zoom } from "@excalidraw/excalidraw/types";
-import type { Bounds } from "@excalidraw/common";
-import type { ElementsMap, ExcalidrawElement, NonDeletedExcalidrawElement, PointerType } from "./types";
-export type TransformHandleDirection = "n" | "s" | "w" | "e" | "nw" | "ne" | "sw" | "se";
-export type TransformHandleType = TransformHandleDirection | "rotation";
-export type TransformHandle = Bounds;
-export type TransformHandles = Partial<{
-    [T in TransformHandleType]: TransformHandle;
-}>;
-export type MaybeTransformHandleType = TransformHandleType | false;
-export declare const DEFAULT_OMIT_SIDES: {
-    e: boolean;
-    s: boolean;
-    n: boolean;
-    w: boolean;
-};
-export declare const OMIT_SIDES_FOR_MULTIPLE_ELEMENTS: {
-    e: boolean;
-    s: boolean;
-    n: boolean;
-    w: boolean;
-};
-export declare const OMIT_SIDES_FOR_FRAME: {
-    e: boolean;
-    s: boolean;
-    n: boolean;
-    w: boolean;
-    rotation: boolean;
-};
-export declare const canResizeFromSides: (editorInterface: EditorInterface) => boolean;
-export declare const getOmitSidesForEditorInterface: (editorInterface: EditorInterface) => {};
-export declare const getTransformHandlesFromCoords: ([x1, y1, x2, y2, cx, cy]: [number, number, number, number, number, number], angle: Radians, zoom: Zoom, pointerType: PointerType, omitSides?: { [T in TransformHandleType]?: boolean; }, margin?: number, spacing?: number) => TransformHandles;
-export declare const getTransformHandles: (element: ExcalidrawElement, zoom: Zoom, elementsMap: ElementsMap, pointerType?: PointerType, omitSides?: { [T in TransformHandleType]?: boolean; }) => TransformHandles;
-export declare const hasBoundingBox: (elements: readonly NonDeletedExcalidrawElement[], appState: InteractiveCanvasAppState, editorInterface: EditorInterface) => boolean;

package/dist/types/element/src/typeChecks.d.ts

@@ -1,54 +0,0 @@
-import type { ElementOrToolType } from "@excalidraw/excalidraw/types";
-import type { MarkNonNullable } from "@excalidraw/common/utility-types";
-import type { ExcalidrawElement, ExcalidrawTextElement, ExcalidrawEmbeddableElement, ExcalidrawLinearElement, ExcalidrawBindableElement, ExcalidrawFreeDrawElement, InitializedExcalidrawImageElement, ExcalidrawImageElement, ExcalidrawTextElementWithContainer, ExcalidrawTextContainer, ExcalidrawFrameElement, RoundnessType, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeElement, ExcalidrawIframeLikeElement, ExcalidrawMagicFrameElement, ExcalidrawArrowElement, ExcalidrawElbowArrowElement, ExcalidrawLineElement, ExcalidrawFlowchartNodeElement, ExcalidrawLinearElementSubType } from "./types";
-export declare const isInitializedImageElement: (element: ExcalidrawElement | null) => element is InitializedExcalidrawImageElement;
-export declare const isImageElement: (element: ExcalidrawElement | null) => element is ExcalidrawImageElement;
-export declare const isEmbeddableElement: (element: ExcalidrawElement | null | undefined) => element is ExcalidrawEmbeddableElement;
-export declare const isIframeElement: (element: ExcalidrawElement | null) => element is ExcalidrawIframeElement;
-export declare const isIframeLikeElement: (element: ExcalidrawElement | null) => element is ExcalidrawIframeLikeElement;
-export declare const isTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawTextElement;
-export declare const isFrameElement: (element: ExcalidrawElement | null) => element is ExcalidrawFrameElement;
-export declare const isMagicFrameElement: (element: ExcalidrawElement | null) => element is ExcalidrawMagicFrameElement;
-export declare const isFrameLikeElement: (element: ExcalidrawElement | null) => element is ExcalidrawFrameLikeElement;
-export declare const isFreeDrawElement: (element?: ExcalidrawElement | null) => element is ExcalidrawFreeDrawElement;
-export declare const isFreeDrawElementType: (elementType: ExcalidrawElementType) => boolean;
-export declare const isLinearElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLinearElement;
-export declare const isLineElement: (element?: ExcalidrawElement | null) => element is ExcalidrawLineElement;
-export declare const isArrowElement: (element?: ExcalidrawElement | null) => element is ExcalidrawArrowElement;
-export declare const isElbowArrow: (element?: ExcalidrawElement) => element is ExcalidrawElbowArrowElement;
-/**
- * sharp or curved arrow, but not elbow
- */
-export declare const isSimpleArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
-export declare const isSharpArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
-export declare const isCurvedArrow: (element?: ExcalidrawElement) => element is ExcalidrawArrowElement;
-export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
-export declare const isBindingElement: (element?: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawArrowElement;
-export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
-export declare const isBindableElement: (element: ExcalidrawElement | null | undefined, includeLocked?: boolean) => element is ExcalidrawBindableElement;
-export declare const isRectanguloidElement: (element?: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
-export declare const isRectangularElement: (element?: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
-export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
-export declare const isExcalidrawElement: (element: any) => element is ExcalidrawElement;
-export declare const isFlowchartNodeElement: (element: ExcalidrawElement) => element is ExcalidrawFlowchartNodeElement;
-export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
-export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
-export declare const isArrowBoundToElement: (element: ExcalidrawArrowElement) => boolean;
-export declare const isUsingAdaptiveRadius: (type: string) => type is "rectangle" | "embeddable" | "iframe" | "image";
-export declare const isUsingProportionalRadius: (type: string) => type is "line" | "arrow" | "diamond";
-export declare const canApplyRoundnessTypeToElement: (roundnessType: RoundnessType, element: ExcalidrawElement) => boolean;
-export declare const getDefaultRoundnessTypeForElement: (element: ExcalidrawElement) => {
-    type: 2;
-} | {
-    type: 3;
-} | null;
-export declare const getLinearElementSubType: (element: ExcalidrawLinearElement) => ExcalidrawLinearElementSubType;
-/**
- * Checks if current element points meet all the conditions for polygon=true
- * (this isn't a element type check, for that use isLineElement).
- *
- * If you want to check if points *can* be turned into a polygon, use
- *  canBecomePolygon(points).
- */
-export declare const isValidPolygon: (points: ExcalidrawLineElement["points"]) => boolean;
-export declare const canBecomePolygon: (points: ExcalidrawLineElement["points"]) => boolean;