@zsviczian/excalidraw 0.14.0-obsidian → 0.14.2-1-obsidian

package/types/element/linearElementEditor.d.ts

@@ -140,16 +140,15 @@ export declare class LinearElementEditor {
             suggestedBindings: import("./binding").SuggestedBinding[];
             editingElement: import("./types").NonDeletedExcalidrawElement | null;
             activeTool: {
-                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser";
-                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
+                lastActiveTool: import("../types").LastActiveTool;
                 locked: boolean;
+            } & ({
+                type: "line" | "arrow" | "text" | "selection" | "rectangle" | "diamond" | "ellipse" | "image" | "freedraw" | "eraser" | "hand";
                 customType: null;
             } | {
                 type: "custom";
                 customType: string;
-                lastActiveToolBeforeEraser: import("../types").LastActiveToolBeforeEraser;
-                locked: boolean;
-            };
+            });
             penMode: boolean;
             penDetected: boolean;
             exportBackground: boolean;
@@ -192,6 +191,7 @@ export declare class LinearElementEditor {
             previousSelectedElementIds: {
                 [id: string]: boolean;
             };
+            /** @returns whether point was dragged */
             shouldCacheIgnoreZoom: boolean;
             toast: {
                 message: string;
@@ -201,6 +201,7 @@ export declare class LinearElementEditor {
             zenModeEnabled: boolean;
             theme: string;
             gridSize: number | null;
+            previousGridSize: number | null;
             viewModeEnabled: boolean;
             selectedGroupIds: {
                 [groupId: string]: boolean;
@@ -230,6 +231,12 @@ export declare class LinearElementEditor {
                 elementBackground?: string[] | undefined;
                 elementStroke?: string[] | undefined;
             };
+            allowWheelZoom?: boolean | undefined;
+            allowPinchZoom?: boolean | undefined;
+            pinnedScripts?: string[] | undefined;
+            customPens?: any[] | undefined;
+            currentStrokeOptions?: any;
+            resetCustomPen?: any;
             selectedLinearElement: LinearElementEditor | null;
         };
     };

package/types/element/newElement.d.ts

@@ -18,11 +18,8 @@ export declare const refreshTextDimensions: (textElement: ExcalidrawTextElement,
     y: number;
     width: number;
     height: number;
-    baseline: number;
     text: string;
 };
-export declare const getMaxContainerWidth: (container: ExcalidrawElement) => number;
-export declare const getMaxContainerHeight: (container: ExcalidrawElement) => number;
 export declare const updateTextElement: (textElement: ExcalidrawTextElement, { text, isDeleted, originalText, rawText, link, }: {
     text: string;
     isDeleted?: boolean | undefined;

package/types/element/sortElements.d.ts

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

package/types/element/textElement.d.ts

@@ -5,19 +5,13 @@ export declare const normalizeText: (text: string) => string;
 export declare const redrawTextBoundingBox: (textElement: ExcalidrawTextElement, container: ExcalidrawElement | null) => void;
 export declare const bindTextToShapeAfterDuplication: (sceneElements: ExcalidrawElement[], oldElements: ExcalidrawElement[], oldIdToDuplicatedId: Map<ExcalidrawElement["id"], ExcalidrawElement["id"]>) => void;
 export declare const handleBindTextResize: (container: NonDeletedExcalidrawElement, transformHandleType: MaybeTransformHandleType) => void;
-export declare const measureText: (text: string, font: FontString, maxWidth?: number | null) => {
+export declare const measureText: (text: string, font: FontString) => {
     width: number;
     height: number;
-    baseline: number;
-    container: HTMLDivElement;
-} | {
-    width: number;
-    height: number;
-    baseline: number;
-    container?: undefined;
 };
 export declare const getApproxLineHeight: (font: FontString) => number;
 export declare const getTextWidth: (text: string, font: FontString) => number;
+export declare const getTextHeight: (text: string, font: FontString) => number;
 export declare const wrapText: (text: string, font: FontString, maxWidth: number) => string;
 export declare const charWidth: {
     calculate: (char: string, font: FontString) => number;
@@ -41,6 +35,10 @@ export declare const getContainerCenter: (container: ExcalidrawElement, appState
     x: number;
     y: number;
 };
+export declare const getContainerCoords: (container: NonDeletedExcalidrawElement) => {
+    x: number;
+    y: number;
+};
 export declare const getTextElementAngle: (textElement: ExcalidrawTextElement) => number;
 export declare const getBoundTextElementOffset: (boundTextElement: ExcalidrawTextElement | null) => number;
 export declare const getBoundTextElementPosition: (container: ExcalidrawElement, boundTextElement: ExcalidrawTextElementWithContainer) => {
@@ -50,3 +48,6 @@ export declare const getBoundTextElementPosition: (container: ExcalidrawElement,
 export declare const shouldAllowVerticalAlign: (selectedElements: NonDeletedExcalidrawElement[]) => boolean;
 export declare const getTextBindableContainerAtPosition: (elements: readonly ExcalidrawElement[], appState: AppState, x: number, y: number) => ExcalidrawTextContainer | null;
 export declare const isValidTextContainer: (element: ExcalidrawElement) => boolean;
+export declare const computeContainerHeightForBoundText: (container: NonDeletedExcalidrawElement, boundTextElementHeight: number) => number;
+export declare const getMaxContainerWidth: (container: ExcalidrawElement) => number;
+export declare const getMaxContainerHeight: (container: ExcalidrawElement) => number;

package/types/element/typeChecks.d.ts

@@ -14,7 +14,7 @@ export declare const isBindingElementType: (elementType: AppState["activeTool"][
 export declare const isBindableElement: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawBindableElement;
 export declare const isTextBindableContainer: (element: ExcalidrawElement | null, includeLocked?: boolean) => element is ExcalidrawTextContainer;
 export declare const isExcalidrawElement: (element: any) => boolean;
-export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is ExcalidrawBindableElement;
+export declare const hasBoundTextElement: (element: ExcalidrawElement | null) => element is MarkNonNullable<ExcalidrawBindableElement, "boundElements">;
 export declare const isBoundToContainer: (element: ExcalidrawElement | null) => element is ExcalidrawTextElementWithContainer;
 export declare const isUsingAdaptiveRadius: (type: string) => boolean;
 export declare const isUsingProportionalRadius: (type: string) => boolean;

package/types/element/types.d.ts

@@ -100,7 +100,6 @@ export declare type ExcalidrawTextElement = _ExcalidrawElementBase & Readonly<{
     fontFamily: FontFamilyValues;
     text: string;
     rawText: string;
-    baseline: number;
     textAlign: TextAlign;
     verticalAlign: VerticalAlign;
     containerId: ExcalidrawGenericElement["id"] | null;

package/types/i18n.d.ts

@@ -13,3 +13,9 @@ export declare const getLanguage: () => Language;
 export declare const t: (path: string, replacement?: {
     [key: string]: string | number;
 } | undefined) => string;
+export declare const useI18n: () => {
+    t: (path: string, replacement?: {
+        [key: string]: string | number;
+    } | undefined) => string;
+    langCode: string;
+};

package/types/jotai.d.ts

@@ -1,9 +1,9 @@
-import { WritableAtom } from "jotai";
+import { PrimitiveAtom } from "jotai";
 export declare const jotaiScope: unique symbol;
 export declare const jotaiStore: {
     get: <Value>(atom: import("jotai").Atom<Value>) => (Value extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value) | undefined;
     asyncGet: <Value_1>(atom: import("jotai").Atom<Value_1>) => Promise<Value_1 extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : Value_1>;
-    set: <Value_2, Update, Result extends void | Promise<void>>(atom: WritableAtom<Value_2, Update, Result>, update: Update) => Result;
+    set: <Value_2, Update, Result extends void | Promise<void>>(atom: import("jotai").WritableAtom<Value_2, Update, Result>, update: Update) => Result;
     sub: (atom: {
         toString: () => string;
         debugLabel?: string | undefined;
@@ -15,7 +15,7 @@ export declare const jotaiStore: {
     }, callback: () => void) => () => void;
     SECRET_INTERNAL_store: {
         r: <Value_6>(readingAtom: import("jotai").Atom<Value_6>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_6>;
-        w: <Value_1_1, Update_1, Result_1 extends void | Promise<void>>(writingAtom: WritableAtom<Value_1_1, Update_1, Result_1>, update: Update_1, version?: import("jotai/core/store").VersionObject | undefined) => Result_1;
+        w: <Value_1_1, Update_1, Result_1 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_1, Update_1, Result_1>, update: Update_1, version?: import("jotai/core/store").VersionObject | undefined) => Result_1;
         c: (_atom: {
             toString: () => string;
             debugLabel?: string | undefined;
@@ -85,7 +85,7 @@ export declare const jotaiStore: {
         } | undefined;
     } | {
         r: <Value_7>(readingAtom: import("jotai").Atom<Value_7>, version?: import("jotai/core/store").VersionObject | undefined) => import("jotai/core/store").AtomState<Value_7>;
-        w: <Value_1_2, Update_2, Result_2 extends void | Promise<void>>(writingAtom: WritableAtom<Value_1_2, Update_2, Result_2>, update: Update_2, version?: import("jotai/core/store").VersionObject | undefined) => Result_2;
+        w: <Value_1_2, Update_2, Result_2 extends void | Promise<void>>(writingAtom: import("jotai").WritableAtom<Value_1_2, Update_2, Result_2>, update: Update_2, version?: import("jotai/core/store").VersionObject | undefined) => Result_2;
         c: (_atom: {
             toString: () => string;
             debugLabel?: string | undefined;
@@ -119,4 +119,4 @@ export declare const jotaiStore: {
         m?: undefined;
     };
 };
-export declare const useAtomWithInitialValue: <T extends unknown, A extends WritableAtom<T, T, void>>(atom: A, initialValue: T | (() => T)) => readonly [T extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : T, import("jotai/core/atom").SetAtom<T, void>];
+export declare const useAtomWithInitialValue: <T extends unknown, A extends PrimitiveAtom<T>>(atom: A, initialValue: T | (() => T)) => readonly [T extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? V extends Promise<infer V> ? any : V : V : V : V : V : V : V : V : V : V : T, import("jotai/core/atom").SetAtom<T | ((prev: T) => T), void>];

package/types/keys.d.ts

@@ -1,6 +1,3 @@
-export declare const isDarwin: boolean;
-export declare const isWindows: boolean;
-export declare const isAndroid: boolean;
 export declare const CODES: {
     readonly EQUAL: "Equal";
     readonly MINUS: "Minus";

package/types/math.d.ts

@@ -26,3 +26,4 @@ export declare const getBezierCurveArcLengths: (element: NonDeleted<ExcalidrawLi
 export declare const getBezierCurveLength: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number]) => number;
 export declare const mapIntervalToBezierT: (element: NonDeleted<ExcalidrawLinearElement>, endPoint: readonly [number, number], interval: number) => number;
 export declare const arePointsEqual: (p1: readonly [number, number], p2: readonly [number, number]) => boolean;
+export declare const isRightAngle: (angle: number) => boolean;

package/types/packages/excalidraw/example/App.d.ts

@@ -1,8 +1,14 @@
 import type * as TExcalidraw from "../index";
 import "./App.scss";
+import { ExcalidrawImperativeAPI } from "../../../types";
 declare global {
     interface Window {
         ExcalidrawLib: typeof TExcalidraw;
     }
 }
-export default function App(): JSX.Element;
+export interface AppProps {
+    appTitle: string;
+    useCustom: (api: ExcalidrawImperativeAPI | null, customArgs?: any[]) => void;
+    customArgs?: any[];
+}
+export default function App({ appTitle, useCustom, customArgs }: AppProps): JSX.Element;

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

@@ -9,7 +9,7 @@ import LiveCollaborationTrigger from "../../components/live-collaboration/LiveCo
 declare type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
 export declare const Excalidraw: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
 export { getSceneVersion, isInvisiblySmallElement, getNonDeletedElements, } from "../../element";
-export { defaultLang, languages } from "../../i18n";
+export { defaultLang, useI18n, languages } from "../../i18n";
 export { restore, restoreAppState, restoreElements, restoreLibraryItems, } from "../../data/restore";
 export { exportToCanvas, exportToBlob, exportToSvg, serializeAsJSON, serializeLibraryAsJSON, loadLibraryFromBlob, loadFromBlob, loadSceneOrLibraryFromBlob, getFreeDrawSvgPath, getCommonBoundingBox, //zsviczian
 getMaximumGroups, //zsviczian

package/types/packages/utils.d.ts

@@ -38,5 +38,5 @@ export { intersectElementWithLine } from "../element/collision";
 export { determineFocusDistance } from "../element/collision";
 export { measureText, wrapText } from "../element/textElement";
 export { getFontString } from "../utils";
-export { getMaxContainerWidth } from "../element/newElement";
+export { getMaxContainerWidth } from "../element/textElement";
 export { mergeLibraryItems } from "../data/library";

package/types/types.d.ts

@@ -55,8 +55,8 @@ export declare type BinaryFileData = {
 };
 export declare type BinaryFileMetadata = Omit<BinaryFileData, "dataURL">;
 export declare type BinaryFiles = Record<ExcalidrawElement["id"], BinaryFileData>;
-export declare type LastActiveToolBeforeEraser = {
-    type: typeof SHAPES[number]["value"] | "eraser";
+export declare type LastActiveTool = {
+    type: typeof SHAPES[number]["value"] | "eraser" | "hand";
     customType: null;
 } | {
     type: "custom";
@@ -81,16 +81,19 @@ export declare type AppState = {
     editingElement: NonDeletedExcalidrawElement | null;
     editingLinearElement: LinearElementEditor | null;
     activeTool: {
-        type: typeof SHAPES[number]["value"] | "eraser";
-        lastActiveToolBeforeEraser: LastActiveToolBeforeEraser;
+        /**
+         * indicates a previous tool we should revert back to if we deselect the
+         * currently active tool. At the moment applies to `eraser` and `hand` tool.
+         */
+        lastActiveTool: LastActiveTool;
         locked: boolean;
+    } & ({
+        type: typeof SHAPES[number]["value"] | "eraser" | "hand";
         customType: null;
     } | {
         type: "custom";
         customType: string;
-        lastActiveToolBeforeEraser: LastActiveToolBeforeEraser;
-        locked: boolean;
-    };
+    });
     penMode: boolean;
     penDetected: boolean;
     exportBackground: boolean;
@@ -140,6 +143,7 @@ export declare type AppState = {
     zenModeEnabled: boolean;
     theme: Theme;
     gridSize: number | null;
+    previousGridSize: number | null;
     viewModeEnabled: boolean;
     /** top-most selected groups (i.e. does not include nested groups) */
     selectedGroupIds: {
@@ -173,6 +177,12 @@ export declare type AppState = {
         elementBackground?: string[];
         elementStroke?: string[];
     };
+    allowWheelZoom?: boolean;
+    allowPinchZoom?: boolean;
+    pinnedScripts?: string[];
+    customPens?: any[];
+    currentStrokeOptions?: any;
+    resetCustomPen?: any;
     selectedLinearElement: LinearElementEditor | null;
 };
 export declare type NormalizedZoomValue = number & {
@@ -296,11 +306,12 @@ declare type CanvasActions = Partial<{
 }>;
 declare type UIOptions = Partial<{
     dockedSidebarBreakpoint: number;
-    welcomeScreen: boolean;
     canvasActions: CanvasActions;
+    /** @deprecated does nothing. Will be removed in 0.15 */
+    welcomeScreen?: boolean;
 }>;
 export declare type AppProps = Merge<ExcalidrawProps, {
-    UIOptions: Merge<MarkRequired<UIOptions, "welcomeScreen">, {
+    UIOptions: Merge<UIOptions, {
         canvasActions: Required<CanvasActions> & {
             export: ExportOpts;
         };
@@ -395,6 +406,7 @@ export declare type ExcalidrawImperativeAPI = {
     };
     scrollToContent: InstanceType<typeof App>["scrollToContent"];
     zoomToFit: InstanceType<typeof App>["zoomToFit"];
+    startLineEditor: InstanceType<typeof App>["startLineEditor"];
     getSceneElements: InstanceType<typeof App>["getSceneElements"];
     getAppState: () => InstanceType<typeof App>["state"];
     getFiles: () => InstanceType<typeof App>["files"];
@@ -424,19 +436,4 @@ export declare type Device = Readonly<{
     isTouchScreen: boolean;
     canDeviceFitSidebar: boolean;
 }>;
-export declare type UIChildrenComponents = {
-    [k in "FooterCenter" | "Menu" | "WelcomeScreen"]?: React.ReactElement<{
-        children?: React.ReactNode;
-    }, React.JSXElementConstructor<any>>;
-};
-export declare type UIWelcomeScreenComponents = {
-    [k in "Center" | "MenuHint" | "ToolbarHint" | "HelpHint"]?: React.ReactElement<{
-        children?: React.ReactNode;
-    }, React.JSXElementConstructor<any>>;
-};
-export declare type UIWelcomeScreenCenterComponents = {
-    [k in "Logo" | "Heading" | "Menu" | "MenuItemLoadScene" | "MenuItemHelp"]?: React.ReactElement<{
-        children?: React.ReactNode;
-    }, React.JSXElementConstructor<any>>;
-};
 export {};

package/types/utils.d.ts

@@ -1,8 +1,7 @@
 import { EVENT } from "./constants";
 import { FontFamilyValues, FontString } from "./element/types";
-import { AppState, LastActiveToolBeforeEraser, Zoom } from "./types";
+import { AppState, LastActiveTool, Zoom } from "./types";
 import { SHAPES } from "./shapes";
-import React from "react";
 export declare const setDateTimeForTests: (dateTime: string) => void;
 export declare const getDateTime: () => string;
 export declare const capitalizeString: (str: string) => string;
@@ -34,12 +33,12 @@ export declare const selectNode: (node: Element) => void;
 export declare const removeSelection: () => void;
 export declare const distance: (x: number, y: number) => number;
 export declare const updateActiveTool: (appState: Pick<AppState, "activeTool">, data: ({
-    type: (typeof SHAPES)[number]["value"] | "eraser";
+    type: (typeof SHAPES)[number]["value"] | "eraser" | "hand";
 } | {
     type: "custom";
     customType: string;
 }) & {
-    lastActiveToolBeforeEraser?: LastActiveToolBeforeEraser;
+    lastActiveToolBeforeEraser?: LastActiveTool;
 }) => AppState["activeTool"];
 export declare const resetCursor: (canvas: HTMLCanvasElement | null) => void;
 export declare const setCursor: (canvas: HTMLCanvasElement | null, cursor: string) => void;
@@ -125,6 +124,9 @@ export declare const getUpdatedTimestamp: () => number;
 export declare const arrayToMap: <T extends string | {
     id: string;
 }>(items: readonly T[]) => Map<string, T>;
+export declare const arrayToMapWithIndex: <T extends {
+    id: string;
+}>(elements: readonly T[]) => Map<string, [element: T, index: number]>;
 export declare const isTestEnv: () => boolean;
 export declare const isProdEnv: () => boolean;
 export declare const wrapEvent: <T extends Event>(name: EVENT, nativeEvent: T) => CustomEvent<{
@@ -135,19 +137,7 @@ export declare const isPrimitive: (val: any) => boolean;
 export declare const getFrame: () => "top" | "iframe";
 export declare const isPromiseLike: (value: any) => value is Promise<any>;
 export declare const queryFocusableElements: (container: HTMLElement | null) => HTMLElement[];
-/**
- * Partitions React children into named components and the rest of children.
- *
- * Returns known children as a dictionary of react children keyed by their
- * displayName, and the rest children as an array.
- *
- * NOTE all named react components are included in the dictionary, irrespective
- * of the supplied type parameter. This means you may be throwing away
- * children that you aren't expecting, but should nonetheless be rendered.
- * To guard against this (provided you care about the rest children at all),
- * supply a second parameter with an object with keys of the expected children.
- */
-export declare const getReactChildren: <KnownChildren extends {
-    [x: string]: React.ReactNode;
-}>(children: React.ReactNode, expectedComponents?: Record<keyof KnownChildren, any> | undefined) => readonly [Partial<KnownChildren>, React.ReactNode[]];
 export declare const isShallowEqual: <T extends Record<string, any>>(objA: T, objB: T) => boolean;
+export declare const composeEventHandlers: <E>(originalEventHandler?: ((event: E) => void) | undefined, ourEventHandler?: ((event: E) => void) | undefined, { checkForDefaultPrevented }?: {
+    checkForDefaultPrevented?: boolean | undefined;
+}) => (event: E) => void;