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

package/types/actions/shortcuts.d.ts

@@ -1,3 +1,3 @@
 import { ActionName } from "./types";
-export declare type ShortcutName = SubtypeOf<ActionName, "toggleTheme" | "loadScene" | "cut" | "copy" | "paste" | "copyStyles" | "pasteStyles" | "selectAll" | "deleteSelectedElements" | "duplicateSelection" | "sendBackward" | "bringForward" | "sendToBack" | "bringToFront" | "copyAsPng" | "copyAsSvg" | "group" | "ungroup" | "gridMode" | "zenMode" | "stats" | "addToLibrary" | "viewMode" | "flipHorizontal" | "flipVertical" | "hyperlink" | "toggleLock"> | "saveScene" | "imageExport";
+export declare type ShortcutName = SubtypeOf<ActionName, "toggleTheme" | "loadScene" | "clearCanvas" | "cut" | "copy" | "paste" | "copyStyles" | "pasteStyles" | "selectAll" | "deleteSelectedElements" | "duplicateSelection" | "sendBackward" | "bringForward" | "sendToBack" | "bringToFront" | "copyAsPng" | "copyAsSvg" | "group" | "ungroup" | "gridMode" | "zenMode" | "stats" | "addToLibrary" | "viewMode" | "flipHorizontal" | "flipVertical" | "hyperlink" | "toggleLock"> | "saveScene" | "imageExport";
 export declare const getShortcutFromShortcutName: (name: ShortcutName) => string;

package/types/components/App.d.ts

@@ -3,7 +3,7 @@ import { RoughCanvas } from "roughjs/bin/canvas";
 import { ActionManager } from "../actions/manager";
 import { RestoredDataState } from "../data/restore";
 import { LinearElementEditor } from "../element/linearElementEditor";
-import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import { ExcalidrawElement, ExcalidrawLinearElement, NonDeletedExcalidrawElement } from "../element/types";
 import History from "../history";
 import Scene from "../scene/Scene";
 import { AppClassProperties, AppProps, AppState, ExcalidrawImperativeAPI, BinaryFiles, LibraryItems, SceneData, Device } from "../types";
@@ -99,6 +99,7 @@ declare class App extends React.Component<AppProps, AppState> {
     onHandToolToggle: () => void;
     scrollToContent: (target?: ExcalidrawElement | readonly ExcalidrawElement[]) => void;
     zoomToFit: (target?: readonly ExcalidrawElement[], maxZoom?: number, margin?: number) => void;
+    startLineEditor: (el: ExcalidrawLinearElement, selectedPointsIndices?: number[] | null) => void;
     updateContainerSize: (containers: NonDeletedExcalidrawElement[]) => void;
     restore: (data: ImportedDataState) => RestoredDataState;
     setToast: (toast: {

package/types/components/LayerUI.d.ts

@@ -19,7 +19,6 @@ interface LayerUIProps {
     onInsertElements: (elements: readonly NonDeletedExcalidrawElement[]) => void;
     showExitZenModeBtn: boolean;
     langCode: Language["code"];
-    isCollaborating: boolean;
     renderTopRightUI?: ExcalidrawProps["renderTopRightUI"];
     renderCustomStats?: ExcalidrawProps["renderCustomStats"];
     renderCustomSidebar?: ExcalidrawProps["renderSidebar"];
@@ -34,5 +33,5 @@ interface LayerUIProps {
     renderWelcomeScreen: boolean;
     children?: React.ReactNode;
 }
-declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onHandToolToggle, onPenModeToggle, onInsertElements, showExitZenModeBtn, isCollaborating, renderTopRightUI, renderCustomStats, renderCustomSidebar, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, renderWelcomeScreen, children, }: LayerUIProps) => JSX.Element>;
+declare const _default: React.MemoExoticComponent<({ actionManager, appState, files, setAppState, elements, canvas, onLockToggle, onHandToolToggle, onPenModeToggle, onInsertElements, showExitZenModeBtn, renderTopRightUI, renderCustomStats, renderCustomSidebar, libraryReturnUrl, UIOptions, focusContainer, library, id, onImageAction, renderWelcomeScreen, children, }: LayerUIProps) => JSX.Element>;
 export default _default;

package/types/components/MobileMenu.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-import { AppState, Device, ExcalidrawProps, UIWelcomeScreenComponents } from "../types";
+import { AppState, Device, ExcalidrawProps } from "../types";
 import { ActionManager } from "../actions/manager";
 import { NonDeletedExcalidrawElement } from "../element/types";
 declare type MobileMenuProps = {
@@ -20,8 +20,7 @@ declare type MobileMenuProps = {
     renderCustomStats?: ExcalidrawProps["renderCustomStats"];
     renderSidebars: () => JSX.Element | null;
     device: Device;
-    renderMenu: () => React.ReactNode;
-    welcomeScreenCenter: UIWelcomeScreenComponents["Center"];
+    renderWelcomeScreen: boolean;
 };
-export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, canvas, onImageAction, renderTopRightUI, renderCustomStats, renderSidebars, device, renderMenu, welcomeScreenCenter, }: MobileMenuProps) => JSX.Element;
+export declare const MobileMenu: ({ appState, elements, actionManager, setAppState, onLockToggle, onHandToolToggle, onPenModeToggle, canvas, onImageAction, renderTopRightUI, renderCustomStats, renderSidebars, device, renderWelcomeScreen, }: MobileMenuProps) => JSX.Element;
 export {};

package/types/components/context/tunnels.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import tunnel from "@dwelle/tunnel-rat";
+declare type Tunnel = ReturnType<typeof tunnel>;
+declare type TunnelsContextValue = {
+    mainMenuTunnel: Tunnel;
+    welcomeScreenMenuHintTunnel: Tunnel;
+    welcomeScreenToolbarHintTunnel: Tunnel;
+    welcomeScreenHelpHintTunnel: Tunnel;
+    welcomeScreenCenterTunnel: Tunnel;
+    footerCenterTunnel: Tunnel;
+    jotaiScope: symbol;
+};
+export declare const TunnelsContext: React.Context<TunnelsContextValue>;
+export declare const useTunnels: () => TunnelsContextValue;
+export declare const useInitializeTunnels: () => TunnelsContextValue;
+export {};

package/types/components/dropdownMenu/common.d.ts

@@ -2,5 +2,5 @@ import React from "react";
 export declare const DropdownMenuContentPropsContext: React.Context<{
     onSelect?: ((event: Event) => void) | undefined;
 }>;
-export declare const getDrodownMenuItemClassName: (className?: string) => string;
+export declare const getDropdownMenuItemClassName: (className?: string) => string;
 export declare const useHandleDropdownMenuItemClick: (origOnClick: React.MouseEventHandler<HTMLAnchorElement | HTMLButtonElement> | undefined, onSelect: ((event: Event) => void) | undefined) => (event: React.MouseEvent<HTMLButtonElement | HTMLAnchorElement, MouseEvent>) => void;

package/types/components/footer/Footer.d.ts

@@ -1,12 +1,11 @@
 import { ActionManager } from "../../actions/manager";
-import { AppState, UIChildrenComponents, UIWelcomeScreenComponents } from "../../types";
+import { AppState } from "../../types";
 declare const Footer: {
-    ({ appState, actionManager, showExitZenModeBtn, footerCenter, welcomeScreenHelp, }: {
+    ({ appState, actionManager, showExitZenModeBtn, renderWelcomeScreen, }: {
         appState: AppState;
         actionManager: ActionManager;
         showExitZenModeBtn: boolean;
-        footerCenter: UIChildrenComponents["FooterCenter"];
-        welcomeScreenHelp: UIWelcomeScreenComponents["HelpHint"];
+        renderWelcomeScreen: boolean;
     }): JSX.Element;
     displayName: string;
 };

package/types/components/hoc/withInternalFallback.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+export declare const withInternalFallback: <P>(componentName: string, Component: React.FC<P>) => React.FC<P & {
+    __fallback?: boolean | undefined;
+}>;

package/types/components/main-menu/MainMenu.d.ts

@@ -1,13 +1,14 @@
 import React from "react";
 import * as DefaultItems from "./DefaultItems";
-declare const MainMenu: {
-    ({ children, onSelect, }: {
-        children?: React.ReactNode;
-        /**
-         * Called when any menu item is selected (clicked on).
-         */
-        onSelect?: ((event: Event) => void) | undefined;
-    }): JSX.Element;
+declare const MainMenu: React.FC<{
+    children?: React.ReactNode;
+    /**
+     * Called when any menu item is selected (clicked on).
+     */
+    onSelect?: ((event: Event) => void) | undefined;
+} & {
+    __fallback?: boolean | undefined;
+}> & {
     Trigger: {
         ({ className, children, onToggle, }: {
             className?: string | undefined;
@@ -55,6 +56,5 @@ declare const MainMenu: {
         displayName: string;
     };
     DefaultItems: typeof DefaultItems;
-    displayName: string;
 };
 export default MainMenu;

package/types/components/welcome-screen/WelcomeScreen.d.ts

@@ -2,8 +2,8 @@
 import "./WelcomeScreen.scss";
 declare const WelcomeScreen: {
     (props: {
-        children: React.ReactNode;
-    }): null;
+        children?: React.ReactNode;
+    }): JSX.Element;
     displayName: string;
     Center: {
         ({ children }: {

package/types/constants.d.ts

@@ -4,6 +4,8 @@ export declare const isDarwin: boolean;
 export declare const isWindows: boolean;
 export declare const isAndroid: boolean;
 export declare const isFirefox: boolean;
+export declare const isChrome: boolean;
+export declare const isSafari: boolean;
 export declare const APP_NAME = "Excalidraw";
 export declare const DRAGGING_THRESHOLD = 10;
 export declare const LINE_CONFIRM_THRESHOLD = 8;
@@ -162,3 +164,6 @@ export declare const ROUNDNESS: {
 /** key containt id of precedeing elemnt id we use in reconciliation during
  * collaboration */
 export declare const PRECEDING_ELEMENT_KEY = "__precedingElement__";
+export declare const COLOR_NAMES: {
+    [key: string]: string;
+};

package/types/data/restore.d.ts

@@ -8,8 +8,14 @@ export declare type RestoredDataState = {
     appState: RestoredAppState;
     files: BinaryFiles;
 };
-export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, refreshDimensions?: boolean) => ExcalidrawElement[];
+export declare const restoreElements: (elements: ImportedDataState["elements"], localElements: readonly ExcalidrawElement[] | null | undefined, opts?: {
+    refreshDimensions?: boolean;
+    repairBindings?: boolean;
+} | undefined) => ExcalidrawElement[];
 export declare const restoreAppState: (appState: ImportedDataState["appState"], localAppState: Partial<AppState> | null | undefined) => RestoredAppState;
-export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined) => RestoredDataState;
+export declare const restore: (data: Pick<ImportedDataState, "appState" | "elements" | "files"> | null, localAppState: Partial<AppState> | null | undefined, localElements: readonly ExcalidrawElement[] | null | undefined, elementsConfig?: {
+    refreshDimensions?: boolean;
+    repairBindings?: boolean;
+}) => RestoredDataState;
 export declare const restoreLibraryItems: (libraryItems: ImportedDataState["libraryItems"], defaultStatus: LibraryItem["status"]) => LibraryItem[];
 export {};

package/types/element/Hyperlink.d.ts

@@ -126,6 +126,10 @@ export declare const actionLink: {
             };
             allowWheelZoom?: boolean | undefined;
             allowPinchZoom?: boolean | undefined;
+            pinnedScripts?: string[] | undefined;
+            customPens?: any[] | undefined;
+            currentStrokeOptions?: any;
+            resetCustomPen?: any;
             selectedLinearElement: import("./linearElementEditor").LinearElementEditor | null;
         };
         commitToHistory: true;

package/types/element/linearElementEditor.d.ts

@@ -233,6 +233,10 @@ export declare class LinearElementEditor {
             };
             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/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

@@ -179,6 +179,10 @@ export declare type AppState = {
     };
     allowWheelZoom?: boolean;
     allowPinchZoom?: boolean;
+    pinnedScripts?: string[];
+    customPens?: any[];
+    currentStrokeOptions?: any;
+    resetCustomPen?: any;
     selectedLinearElement: LinearElementEditor | null;
 };
 export declare type NormalizedZoomValue = number & {
@@ -302,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;
         };
@@ -401,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"];
@@ -430,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

@@ -2,7 +2,6 @@ import { EVENT } from "./constants";
 import { FontFamilyValues, FontString } from "./element/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;
@@ -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,21 +137,6 @@ 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;