@dwelle/excalidraw 0.3.4

package/types/packages/excalidraw/dist/excalidraw.development.d.ts

@@ -0,0 +1,2 @@
+export = __WEBPACK_EXTERNAL_MODULE_react_dom__;
+export = __WEBPACK_EXTERNAL_MODULE_react_dom__;

package/types/packages/excalidraw/dist/excalidraw.production.min.d.ts

@@ -0,0 +1,3 @@
+declare const _exports: any;
+export = _exports;
+export var Excalidraw: any;

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

@@ -0,0 +1,3 @@
+export default Excalidraw;
+export * from "./index";
+import Excalidraw from "./index";

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

@@ -0,0 +1,16 @@
+import React from "react";
+import "./publicPath";
+import "../../css/app.scss";
+import "../../css/styles.scss";
+import { ExcalidrawAPIRefValue, ExcalidrawProps } from "../../types";
+declare type PublicExcalidrawProps = Omit<ExcalidrawProps, "forwardedRef">;
+declare const _default: React.MemoExoticComponent<React.ForwardRefExoticComponent<PublicExcalidrawProps & React.RefAttributes<ExcalidrawAPIRefValue>>>;
+export default _default;
+export { getSceneVersion, getElementMap, isInvisiblySmallElement, } from "../../element";
+export { defaultLang, languages } from "../../i18n";
+export { restore, restoreElements, restoreAppState } from "../../data/restore";
+export { exportToBlob, exportToCanvas, exportToSvg, serializeAsJSON, loadLibraryFromBlob, loadFromBlob, getFreeDrawSvgPath, } from "../../packages/utils";
+export { FONT_FAMILY } from "../../constants";
+export { exportToClipboard } from "../utils";
+export { getDefaultAppState } from "../../appState";
+export { cleanAppStateForExport, clearAppStateForLocalStorage, } from "../../appState";

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

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

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

@@ -0,0 +1 @@
+export {};

package/types/packages/excalidraw/webpack.dev.config.d.ts

@@ -0,0 +1,81 @@
+import autoprefixer = require("autoprefixer");
+import webpack = require("webpack");
+export const mode: string;
+export const devtool: boolean;
+export const entry: {
+    "excalidraw.development": string;
+};
+export namespace output {
+    const path: string;
+    const library: string;
+    const libraryTarget: string;
+    const filename: string;
+    const chunkFilename: string;
+    const publicPath: string;
+}
+export namespace resolve {
+    const extensions: string[];
+}
+export namespace module {
+    const rules: ({
+        test: RegExp;
+        exclude: RegExp;
+        use: (string | {
+            loader: string;
+            options?: undefined;
+        } | {
+            loader: string;
+            options: {
+                postcssOptions: {
+                    plugins: (import("postcss").Plugin & autoprefixer.ExportedAPI)[];
+                };
+            };
+        })[];
+    } | {
+        test: RegExp;
+        exclude: RegExp;
+        use: {
+            loader: string;
+            options: {
+                transpileOnly: boolean;
+                configFile: string;
+            };
+        }[];
+    } | {
+        test: RegExp;
+        use: {
+            loader: string;
+            options: {
+                name: string;
+                outputPath: string;
+            };
+        }[];
+        exclude?: undefined;
+    })[];
+}
+export namespace optimization {
+    namespace splitChunks {
+        const chunks: string;
+        namespace cacheGroups {
+            namespace vendors {
+                const test: RegExp;
+                const name: string;
+            }
+        }
+    }
+}
+export const plugins: webpack.EvalSourceMapDevToolPlugin[];
+export const externals: {
+    react: {
+        root: string;
+        commonjs2: string;
+        commonjs: string;
+        amd: string;
+    };
+    "react-dom": {
+        root: string;
+        commonjs2: string;
+        commonjs: string;
+        amd: string;
+    };
+};

package/types/packages/excalidraw/webpack.prod.config.d.ts

@@ -0,0 +1,91 @@
+import autoprefixer = require("autoprefixer");
+export const mode: string;
+export const entry: {
+    "excalidraw.production.min": string;
+};
+export namespace output {
+    const path: string;
+    const library: string;
+    const libraryTarget: string;
+    const filename: string;
+    const chunkFilename: string;
+    const publicPath: string;
+}
+export namespace resolve {
+    const extensions: string[];
+}
+export namespace module {
+    const rules: ({
+        test: RegExp;
+        exclude: RegExp;
+        use: (string | {
+            loader: string;
+            options?: undefined;
+        } | {
+            loader: string;
+            options: {
+                postcssOptions: {
+                    plugins: (import("postcss").Plugin & autoprefixer.ExportedAPI)[];
+                };
+            };
+        })[];
+    } | {
+        test: RegExp;
+        exclude: RegExp;
+        use: ({
+            loader: string;
+            options: {
+                transpileOnly: boolean;
+                configFile: string;
+                presets?: undefined;
+                plugins?: undefined;
+            };
+        } | {
+            loader: string;
+            options: {
+                presets: string[];
+                plugins: string[];
+                transpileOnly?: undefined;
+                configFile?: undefined;
+            };
+        })[];
+    } | {
+        test: RegExp;
+        use: {
+            loader: string;
+            options: {
+                name: string;
+                outputPath: string;
+            };
+        }[];
+        exclude?: undefined;
+    })[];
+}
+export namespace optimization {
+    const minimize: boolean;
+    const minimizer: any[];
+    namespace splitChunks {
+        const chunks: string;
+        namespace cacheGroups {
+            namespace vendors {
+                const test: RegExp;
+                const name: string;
+            }
+        }
+    }
+}
+export const plugins: any[];
+export const externals: {
+    react: {
+        root: string;
+        commonjs2: string;
+        commonjs: string;
+        amd: string;
+    };
+    "react-dom": {
+        root: string;
+        commonjs2: string;
+        commonjs: string;
+        amd: string;
+    };
+};

package/types/packages/utils.d.ts

@@ -0,0 +1,26 @@
+import { AppState } from "../types";
+import { ExcalidrawElement } from "../element/types";
+declare type ExportOpts = {
+    elements: readonly ExcalidrawElement[];
+    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
+    getDimensions?: (width: number, height: number) => {
+        width: number;
+        height: number;
+        scale: number;
+    };
+};
+export declare const exportToCanvas: ({ elements, appState, getDimensions, }: ExportOpts) => HTMLCanvasElement;
+export declare const exportToBlob: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+}) => Promise<Blob | null>;
+export declare const exportToSvg: ({ elements, appState, exportPadding, }: Omit<ExportOpts, "getDimensions"> & {
+    exportPadding?: number | undefined;
+}) => Promise<SVGSVGElement>;
+export declare const exportToClipboard: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+}) => Promise<void>;
+export { serializeAsJSON } from "../data/json";
+export { loadFromBlob, loadLibraryFromBlob } from "../data/blob";
+export { getFreeDrawSvgPath } from "../renderer/renderElement";

package/types/points.d.ts

@@ -0,0 +1,6 @@
+import { Point } from "./types";
+export declare const getSizeFromPoints: (points: readonly Point[]) => {
+    width: number;
+    height: number;
+};
+export declare const rescalePoints: (dimension: 0 | 1, nextDimensionSize: number, prevPoints: readonly Point[]) => Point[];

package/types/random.d.ts

@@ -0,0 +1,3 @@
+export declare const randomInteger: () => number;
+export declare const reseed: (seed: number) => void;
+export declare const randomId: () => string;

package/types/renderer/index.d.ts

@@ -0,0 +1 @@
+export { renderScene } from "./renderScene";

package/types/renderer/renderElement.d.ts

@@ -0,0 +1,23 @@
+import { ExcalidrawElement, ExcalidrawTextElement, NonDeletedExcalidrawElement, ExcalidrawFreeDrawElement } from "../element/types";
+import { RoughCanvas } from "roughjs/bin/canvas";
+import { Drawable, Options } from "roughjs/bin/core";
+import { RoughSVG } from "roughjs/bin/svg";
+import { SceneState } from "../scene/types";
+import { Zoom } from "../types";
+export interface ExcalidrawElementWithCanvas {
+    element: ExcalidrawElement | ExcalidrawTextElement;
+    canvas: HTMLCanvasElement;
+    canvasZoom: Zoom["value"];
+    canvasOffsetX: number;
+    canvasOffsetY: number;
+}
+export declare const getShapeForElement: (element: ExcalidrawElement) => Drawable | Drawable[] | null | undefined;
+export declare const invalidateShapeForElement: (element: ExcalidrawElement) => boolean;
+export declare const clearRenderCache: () => void;
+export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
+export declare const renderElement: (element: NonDeletedExcalidrawElement, rc: RoughCanvas, context: CanvasRenderingContext2D, renderOptimizations: boolean, sceneState: SceneState) => void;
+export declare const renderElementToSvg: (element: NonDeletedExcalidrawElement, rsvg: RoughSVG, svgRoot: SVGElement, offsetX?: number | undefined, offsetY?: number | undefined) => void;
+export declare let pathsCache: WeakMap<ExcalidrawFreeDrawElement, Path2D>;
+export declare function generateFreeDrawShape(element: ExcalidrawFreeDrawElement): Path2D;
+export declare function getFreeDrawPath2D(element: ExcalidrawFreeDrawElement): Path2D | undefined;
+export declare function getFreeDrawSvgPath(element: ExcalidrawFreeDrawElement): string;

package/types/renderer/renderScene.d.ts

@@ -0,0 +1,21 @@
+import { RoughCanvas } from "roughjs/bin/canvas";
+import { RoughSVG } from "roughjs/bin/svg";
+import { AppState } from "../types";
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { SceneState } from "../scene/types";
+export declare const renderScene: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, selectionElement: NonDeletedExcalidrawElement | null, scale: number, rc: RoughCanvas, canvas: HTMLCanvasElement, sceneState: SceneState, { renderScrollbars, renderSelection, renderOptimizations, renderGrid, }?: {
+    renderScrollbars?: boolean | undefined;
+    renderSelection?: boolean | undefined;
+    renderOptimizations?: boolean | undefined;
+    renderGrid?: boolean | undefined;
+}) => {
+    atLeastOneVisibleElement: boolean;
+    scrollBars?: undefined;
+} | {
+    atLeastOneVisibleElement: boolean;
+    scrollBars: import("../scene/types").ScrollBars | undefined;
+};
+export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], rsvg: RoughSVG, svgRoot: SVGElement, { offsetX, offsetY, }?: {
+    offsetX?: number | undefined;
+    offsetY?: number | undefined;
+}) => void;

package/types/renderer/roundRect.d.ts

@@ -0,0 +1,11 @@
+/**
+ * https://stackoverflow.com/a/3368118
+ * Draws a rounded rectangle using the current state of the canvas.
+ * @param {CanvasRenderingContext2D} context
+ * @param {Number} x The top left x coordinate
+ * @param {Number} y The top left y coordinate
+ * @param {Number} width The width of the rectangle
+ * @param {Number} height The height of the rectangle
+ * @param {Number} radius The corner radius
+ */
+export declare const roundRect: (context: CanvasRenderingContext2D, x: number, y: number, width: number, height: number, radius: number) => void;

package/types/scene/Scene.d.ts

@@ -0,0 +1,26 @@
+import { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted } from "../element/types";
+import { LinearElementEditor } from "../element/linearElementEditor";
+declare type ElementIdKey = InstanceType<typeof LinearElementEditor>["elementId"];
+declare type ElementKey = ExcalidrawElement | ElementIdKey;
+declare type SceneStateCallback = () => void;
+declare type SceneStateCallbackRemover = () => void;
+declare class Scene {
+    private static sceneMapByElement;
+    private static sceneMapById;
+    static mapElementToScene(elementKey: ElementKey, scene: Scene): void;
+    static getScene(elementKey: ElementKey): Scene | null;
+    private callbacks;
+    private nonDeletedElements;
+    private elements;
+    private elementsMap;
+    getElementsIncludingDeleted(): readonly ExcalidrawElement[];
+    getElements(): readonly NonDeletedExcalidrawElement[];
+    getElement(id: ExcalidrawElement["id"]): ExcalidrawElement | null;
+    getNonDeletedElement(id: ExcalidrawElement["id"]): NonDeleted<ExcalidrawElement> | null;
+    getNonDeletedElements(ids: readonly ExcalidrawElement["id"][]): NonDeleted<ExcalidrawElement>[];
+    replaceAllElements(nextElements: readonly ExcalidrawElement[]): void;
+    informMutation(): void;
+    addCallback(cb: SceneStateCallback): SceneStateCallbackRemover;
+    destroy(): void;
+}
+export default Scene;

package/types/scene/comparisons.d.ts

@@ -0,0 +1,10 @@
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+export declare const hasBackground: (type: string) => boolean;
+export declare const hasStrokeWidth: (type: string) => boolean;
+export declare const hasStrokeStyle: (type: string) => boolean;
+export declare const canChangeSharpness: (type: string) => boolean;
+export declare const hasText: (type: string) => boolean;
+export declare const canHaveArrowheads: (type: string) => boolean;
+export declare const getElementAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement | null;
+export declare const getElementsAtPosition: (elements: readonly NonDeletedExcalidrawElement[], isAtPositionFn: (element: NonDeletedExcalidrawElement) => boolean) => NonDeletedExcalidrawElement[];
+export declare const getElementContainingPosition: (elements: readonly ExcalidrawElement[], x: number, y: number) => ExcalidrawElement | null;

package/types/scene/export.d.ts

@@ -0,0 +1,20 @@
+import { NonDeletedExcalidrawElement } from "../element/types";
+import { AppState } from "../types";
+export declare const SVG_EXPORT_TAG = "<!-- svg-source:excalidraw -->";
+export declare const exportToCanvas: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState, { exportBackground, exportPadding, viewBackgroundColor, }: {
+    exportBackground: boolean;
+    exportPadding?: number | undefined;
+    viewBackgroundColor: string;
+}, createCanvas?: (width: number, height: number) => {
+    canvas: HTMLCanvasElement;
+    scale: number;
+}) => HTMLCanvasElement;
+export declare const exportToSvg: (elements: readonly NonDeletedExcalidrawElement[], appState: {
+    exportBackground: boolean;
+    exportPadding?: number;
+    exportScale?: number;
+    viewBackgroundColor: string;
+    exportWithDarkMode?: boolean;
+    exportEmbedScene?: boolean;
+}) => Promise<SVGSVGElement>;
+export declare const getExportSize: (elements: readonly NonDeletedExcalidrawElement[], exportPadding: number, scale: number) => [number, number];

package/types/scene/index.d.ts

@@ -0,0 +1,5 @@
+export { isOverScrollBars } from "./scrollbars";
+export { isSomeElementSelected, getElementsWithinSelection, getCommonAttributeOfSelectedElements, getSelectedElements, getTargetElements, } from "./selection";
+export { calculateScrollCenter } from "./scroll";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeSharpness, getElementAtPosition, getElementContainingPosition, hasText, getElementsAtPosition, } from "./comparisons";
+export { getNormalizedZoom, getNewZoom } from "./zoom";

package/types/scene/scroll.d.ts

@@ -0,0 +1,17 @@
+import { AppState, PointerCoords, Zoom } from "../types";
+import { ExcalidrawElement } from "../element/types";
+export declare const centerScrollOn: ({ scenePoint, viewportDimensions, zoom, }: {
+    scenePoint: PointerCoords;
+    viewportDimensions: {
+        height: number;
+        width: number;
+    };
+    zoom: Zoom;
+}) => {
+    scrollX: number;
+    scrollY: number;
+};
+export declare const calculateScrollCenter: (elements: readonly ExcalidrawElement[], appState: AppState, canvas: HTMLCanvasElement | null) => {
+    scrollX: number;
+    scrollY: number;
+};

package/types/scene/scrollbars.d.ts

@@ -0,0 +1,16 @@
+import { ExcalidrawElement } from "../element/types";
+import { Zoom } from "../types";
+import { ScrollBars } from "./types";
+export declare const SCROLLBAR_MARGIN = 4;
+export declare const SCROLLBAR_WIDTH = 6;
+export declare const SCROLLBAR_COLOR = "rgba(0,0,0,0.3)";
+export declare const getScrollBars: (elements: readonly ExcalidrawElement[], viewportWidth: number, viewportHeight: number, { scrollX, scrollY, zoom, }: {
+    scrollX: number;
+    scrollY: number;
+    zoom: Zoom;
+}) => ScrollBars;
+export declare const isOverScrollBars: (scrollBars: ScrollBars, x: number, y: number) => {
+    isOverEither: boolean;
+    isOverHorizontal: boolean;
+    isOverVertical: boolean;
+};

package/types/scene/selection.d.ts

@@ -0,0 +1,11 @@
+import { ExcalidrawElement, NonDeletedExcalidrawElement } from "../element/types";
+import { AppState } from "../types";
+export declare const getElementsWithinSelection: (elements: readonly NonDeletedExcalidrawElement[], selection: NonDeletedExcalidrawElement) => NonDeletedExcalidrawElement[];
+export declare const isSomeElementSelected: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => boolean;
+/**
+ * Returns common attribute (picked by `getAttribute` callback) of selected
+ *  elements. If elements don't share the same value, returns `null`.
+ */
+export declare const getCommonAttributeOfSelectedElements: <T>(elements: readonly NonDeletedExcalidrawElement[], appState: AppState, getAttribute: (element: ExcalidrawElement) => T) => T | null;
+export declare const getSelectedElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];
+export declare const getTargetElements: (elements: readonly NonDeletedExcalidrawElement[], appState: AppState) => NonDeletedExcalidrawElement[];

package/types/scene/types.d.ts

@@ -0,0 +1,50 @@
+import { ExcalidrawTextElement } from "../element/types";
+import { Zoom } from "../types";
+export declare type SceneState = {
+    scrollX: number;
+    scrollY: number;
+    viewBackgroundColor: string | null;
+    exportWithDarkMode?: boolean;
+    zoom: Zoom;
+    shouldCacheIgnoreZoom: boolean;
+    remotePointerViewportCoords: {
+        [id: string]: {
+            x: number;
+            y: number;
+        };
+    };
+    remotePointerButton?: {
+        [id: string]: string | undefined;
+    };
+    remoteSelectedElementIds: {
+        [elementId: string]: string[];
+    };
+    remotePointerUsernames: {
+        [id: string]: string;
+    };
+    remotePointerUserStates: {
+        [id: string]: string;
+    };
+};
+export declare type SceneScroll = {
+    scrollX: number;
+    scrollY: number;
+};
+export interface Scene {
+    elements: ExcalidrawTextElement[];
+}
+export declare type ExportType = "png" | "clipboard" | "clipboard-svg" | "backend" | "svg";
+export declare type ScrollBars = {
+    horizontal: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    vertical: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+};

package/types/scene/zoom.d.ts

@@ -0,0 +1,6 @@
+import { NormalizedZoomValue, PointerCoords, Zoom } from "../types";
+export declare const getNewZoom: (newZoomValue: NormalizedZoomValue, prevZoom: Zoom, canvasOffset: {
+    left: number;
+    top: number;
+}, zoomOnViewportPoint?: PointerCoords) => Zoom;
+export declare const getNormalizedZoom: (zoom: number) => NormalizedZoomValue;