@zsviczian/excalidraw 0.18.0-20 → 0.18.0-22

package/types/utils/src/export.d.ts

@@ -1,35 +1,35 @@
-import { MIME_TYPES } from "@excalidraw/common";
-import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
-import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
-export { MIME_TYPES };
-type ExportOpts = {
-    elements: readonly NonDeleted<ExcalidrawElement>[];
-    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
-    files: BinaryFiles | null;
-    maxWidthOrHeight?: number;
-    exportingFrame?: ExcalidrawFrameLikeElement | null;
-    getDimensions?: (width: number, height: number) => {
-        width: number;
-        height: number;
-        scale?: number;
-    };
-};
-export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
-    exportPadding?: number | undefined;
-}) => Promise<HTMLCanvasElement>;
-export declare const exportToBlob: (opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    exportPadding?: number;
-}) => Promise<Blob>;
-export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, skipInliningFonts, reuseImages, }: Omit<ExportOpts, "getDimensions"> & {
-    exportPadding?: number | undefined;
-    renderEmbeddables?: boolean | undefined;
-    skipInliningFonts?: true | undefined;
-    reuseImages?: boolean | undefined;
-}) => Promise<SVGSVGElement>;
-export declare const exportToClipboard: (opts: ExportOpts & {
-    mimeType?: string;
-    quality?: number;
-    type: "png" | "svg" | "json";
-}) => Promise<void>;
+import { MIME_TYPES } from "@excalidraw/common";
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement, NonDeleted } from "@excalidraw/element/types";
+import type { AppState, BinaryFiles } from "@excalidraw/excalidraw/types";
+export { MIME_TYPES };
+type ExportOpts = {
+    elements: readonly NonDeleted<ExcalidrawElement>[];
+    appState?: Partial<Omit<AppState, "offsetTop" | "offsetLeft">>;
+    files: BinaryFiles | null;
+    maxWidthOrHeight?: number;
+    exportingFrame?: ExcalidrawFrameLikeElement | null;
+    getDimensions?: (width: number, height: number) => {
+        width: number;
+        height: number;
+        scale?: number;
+    };
+};
+export declare const exportToCanvas: ({ elements, appState, files, maxWidthOrHeight, getDimensions, exportPadding, exportingFrame, }: ExportOpts & {
+    exportPadding?: number | undefined;
+}) => Promise<HTMLCanvasElement>;
+export declare const exportToBlob: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    exportPadding?: number;
+}) => Promise<Blob>;
+export declare const exportToSvg: ({ elements, appState, files, exportPadding, renderEmbeddables, exportingFrame, skipInliningFonts, reuseImages, }: Omit<ExportOpts, "getDimensions"> & {
+    exportPadding?: number | undefined;
+    renderEmbeddables?: boolean | undefined;
+    skipInliningFonts?: true | undefined;
+    reuseImages?: boolean | undefined;
+}) => Promise<SVGSVGElement>;
+export declare const exportToClipboard: (opts: ExportOpts & {
+    mimeType?: string;
+    quality?: number;
+    type: "png" | "svg" | "json";
+}) => Promise<void>;

package/types/utils/src/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./export";
-export * from "./withinBounds";
-export * from "./bbox";
-export { getCommonBounds } from "@excalidraw/element";
+export * from "./export";
+export * from "./withinBounds";
+export * from "./bbox";
+export { getCommonBounds } from "@excalidraw/element";

package/types/utils/src/shape.d.ts

@@ -1,58 +1,58 @@
-import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "@excalidraw/element/types";
-import type { Curve, LineSegment, Polygon, Radians } from "@excalidraw/math";
-import type { Drawable, Op } from "roughjs/bin/core";
-export type Polyline<Point extends GlobalPoint | LocalPoint> = LineSegment<Point>[];
-export type Polycurve<Point extends GlobalPoint | LocalPoint> = Curve<Point>[];
-export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
-    center: Point;
-    angle: Radians;
-    halfWidth: number;
-    halfHeight: number;
-};
-export type GeometricShape<Point extends GlobalPoint | LocalPoint> = {
-    type: "line";
-    data: LineSegment<Point>;
-} | {
-    type: "polygon";
-    data: Polygon<Point>;
-} | {
-    type: "curve";
-    data: Curve<Point>;
-} | {
-    type: "ellipse";
-    data: Ellipse<Point>;
-} | {
-    type: "polyline";
-    data: Polyline<Point>;
-} | {
-    type: "polycurve";
-    data: Polycurve<Point>;
-};
-type RectangularElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement | ExcalidrawImageElement | ExcalidrawIframeElement | ExcalidrawTextElement | ExcalidrawSelectionElement;
-export declare const getPolygonShape: <Point extends GlobalPoint | LocalPoint>(element: RectangularElement) => GeometricShape<Point>;
-export declare const getSelectionBoxShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape<Point>;
-export declare const getEllipseShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawEllipseElement) => GeometricShape<Point>;
-export declare const getCurvePathOps: (shape: Drawable) => Op[];
-export declare const getCurveShape: <Point extends GlobalPoint | LocalPoint>(roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
-export declare const getFreedrawShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape<Point>;
-export declare const getClosedCurveShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
-/**
- * Determine intersection of a rectangular shaped element and a
- * line segment.
- *
- * @param element The rectangular element to test against
- * @param segment The segment intersecting the element
- * @param gap Optional value to inflate the shape before testing
- * @returns An array of intersections
- */
-export declare const segmentIntersectRectangleElement: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
-export declare const pointOnEllipse: <Point extends GlobalPoint | LocalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
-export declare const pointInEllipse: <Point extends GlobalPoint | LocalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
-export declare const ellipseAxes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => {
-    majorAxis: number;
-    minorAxis: number;
-};
-export declare const ellipseFocusToCenter: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => number;
-export declare const ellipseExtremes: <Point extends GlobalPoint | LocalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
-export {};
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import type { ElementsMap, ExcalidrawBindableElement, ExcalidrawDiamondElement, ExcalidrawElement, ExcalidrawEllipseElement, ExcalidrawEmbeddableElement, ExcalidrawFrameLikeElement, ExcalidrawFreeDrawElement, ExcalidrawIframeElement, ExcalidrawImageElement, ExcalidrawLinearElement, ExcalidrawRectangleElement, ExcalidrawSelectionElement, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { Curve, LineSegment, Polygon, Radians } from "@excalidraw/math";
+import type { Drawable, Op } from "roughjs/bin/core";
+export type Polyline<Point extends GlobalPoint | LocalPoint> = LineSegment<Point>[];
+export type Polycurve<Point extends GlobalPoint | LocalPoint> = Curve<Point>[];
+export type Ellipse<Point extends GlobalPoint | LocalPoint> = {
+    center: Point;
+    angle: Radians;
+    halfWidth: number;
+    halfHeight: number;
+};
+export type GeometricShape<Point extends GlobalPoint | LocalPoint> = {
+    type: "line";
+    data: LineSegment<Point>;
+} | {
+    type: "polygon";
+    data: Polygon<Point>;
+} | {
+    type: "curve";
+    data: Curve<Point>;
+} | {
+    type: "ellipse";
+    data: Ellipse<Point>;
+} | {
+    type: "polyline";
+    data: Polyline<Point>;
+} | {
+    type: "polycurve";
+    data: Polycurve<Point>;
+};
+type RectangularElement = ExcalidrawRectangleElement | ExcalidrawDiamondElement | ExcalidrawFrameLikeElement | ExcalidrawEmbeddableElement | ExcalidrawImageElement | ExcalidrawIframeElement | ExcalidrawTextElement | ExcalidrawSelectionElement;
+export declare const getPolygonShape: <Point extends LocalPoint | GlobalPoint>(element: RectangularElement) => GeometricShape<Point>;
+export declare const getSelectionBoxShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap, padding?: number) => GeometricShape<Point>;
+export declare const getEllipseShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawEllipseElement) => GeometricShape<Point>;
+export declare const getCurvePathOps: (shape: Drawable) => Op[];
+export declare const getCurveShape: <Point extends LocalPoint | GlobalPoint>(roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
+export declare const getFreedrawShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawFreeDrawElement, center: Point, isClosed?: boolean) => GeometricShape<Point>;
+export declare const getClosedCurveShape: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawLinearElement, roughShape: Drawable, startingPoint: Point | undefined, angleInRadian: Radians, center: Point) => GeometricShape<Point>;
+/**
+ * Determine intersection of a rectangular shaped element and a
+ * line segment.
+ *
+ * @param element The rectangular element to test against
+ * @param segment The segment intersecting the element
+ * @param gap Optional value to inflate the shape before testing
+ * @returns An array of intersections
+ */
+export declare const segmentIntersectRectangleElement: <Point extends LocalPoint | GlobalPoint>(element: ExcalidrawBindableElement, segment: LineSegment<Point>, gap?: number) => Point[];
+export declare const pointOnEllipse: <Point extends LocalPoint | GlobalPoint>(point: Point, ellipse: Ellipse<Point>, threshold?: number) => boolean;
+export declare const pointInEllipse: <Point extends LocalPoint | GlobalPoint>(p: Point, ellipse: Ellipse<Point>) => boolean;
+export declare const ellipseAxes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => {
+    majorAxis: number;
+    minorAxis: number;
+};
+export declare const ellipseFocusToCenter: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => number;
+export declare const ellipseExtremes: <Point extends LocalPoint | GlobalPoint>(ellipse: Ellipse<Point>) => import("@excalidraw/math").Vector[];
+export {};

package/types/utils/src/withinBounds.d.ts

@@ -1,19 +1,19 @@
-import type { Bounds } from "@excalidraw/element";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
-type Element = NonDeletedExcalidrawElement;
-type Elements = readonly NonDeletedExcalidrawElement[];
-export declare const isElementInsideBBox: (element: Element, bbox: Bounds, eitherDirection?: boolean) => boolean;
-export declare const elementPartiallyOverlapsWithOrContainsBBox: (element: Element, bbox: Bounds) => boolean;
-export declare const elementsOverlappingBBox: ({ elements, bounds, type, errorMargin, }: {
-    elements: Elements;
-    bounds: Bounds | ExcalidrawElement;
-    /** safety offset. Defaults to 0. */
-    errorMargin?: number | undefined;
-    /**
-     * - overlap: elements overlapping or inside bounds
-     * - contain: elements inside bounds or bounds inside elements
-     * - inside: elements inside bounds
-     **/
-    type: "overlap" | "contain" | "inside";
-}) => NonDeletedExcalidrawElement[];
-export {};
+import type { Bounds } from "@excalidraw/element";
+import type { ExcalidrawElement, NonDeletedExcalidrawElement } from "@excalidraw/element/types";
+type Element = NonDeletedExcalidrawElement;
+type Elements = readonly NonDeletedExcalidrawElement[];
+export declare const isElementInsideBBox: (element: Element, bbox: Bounds, eitherDirection?: boolean) => boolean;
+export declare const elementPartiallyOverlapsWithOrContainsBBox: (element: Element, bbox: Bounds) => boolean;
+export declare const elementsOverlappingBBox: ({ elements, bounds, type, errorMargin, }: {
+    elements: Elements;
+    bounds: Bounds | ExcalidrawElement;
+    /** safety offset. Defaults to 0. */
+    errorMargin?: number | undefined;
+    /**
+     * - overlap: elements overlapping or inside bounds
+     * - contain: elements inside bounds or bounds inside elements
+     * - inside: elements inside bounds
+     **/
+    type: "overlap" | "contain" | "inside";
+}) => NonDeletedExcalidrawElement[];
+export {};

package/types/element/src/Shape.d.ts

@@ -1,21 +0,0 @@
-import { RoughGenerator } from "roughjs/bin/generator";
-import type { EmbedsValidationStatus } from "@excalidraw/excalidraw/types";
-import type { ExcalidrawElement, NonDeletedExcalidrawElement, ExcalidrawSelectionElement, ExcalidrawLinearElement, ExcalidrawFreeDrawElement, ElementsMap } from "./types";
-import type { Drawable, Options } from "roughjs/bin/core";
-export declare const generateRoughOptions: (element: ExcalidrawElement, continuousPath?: boolean) => Options;
-export declare const generateLinearCollisionShape: (element: ExcalidrawLinearElement | ExcalidrawFreeDrawElement, elementsMap: ElementsMap) => {
-    op: string;
-    data: number[];
-}[];
-/**
- * Generates the roughjs shape for given element.
- *
- * Low-level. Use `ShapeCache.generateElementShape` instead.
- *
- * @private
- */
-export declare const _generateElementShape: (element: Exclude<NonDeletedExcalidrawElement, ExcalidrawSelectionElement>, generator: RoughGenerator, { isExporting, canvasBackgroundColor, embedsValidationStatus, }: {
-    isExporting: boolean;
-    canvasBackgroundColor: string;
-    embedsValidationStatus: EmbedsValidationStatus | null;
-}) => Drawable | Drawable[] | null;

package/types/element/src/shapes.d.ts

@@ -1,27 +0,0 @@
-import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
-import { type GeometricShape } from "@excalidraw/utils/shape";
-import type { Zoom } from "@excalidraw/excalidraw/types";
-import { type Bounds } from "./bounds";
-import type { ElementsMap, ExcalidrawElement, ExcalidrawLinearElement, ExcalidrawLineElement, NonDeleted } from "./types";
-/**
- * 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 getBoundTextShape: <Point extends GlobalPoint | LocalPoint>(element: ExcalidrawElement, elementsMap: ElementsMap) => GeometricShape<Point> | null;
-export declare const getControlPointsForBezierCurve: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => P[] | null;
-export declare const getBezierXY: <P extends GlobalPoint | LocalPoint>(p0: P, p1: P, p2: P, p3: P, t: number) => P;
-export declare const getBezierCurveLength: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P) => number;
-export declare const mapIntervalToBezierT: <P extends GlobalPoint | LocalPoint>(element: NonDeleted<ExcalidrawLinearElement>, endPoint: P, interval: number) => number;
-/**
- * Get the axis-aligned bounding box for a given element
- */
-export declare const aabbForElement: (element: Readonly<ExcalidrawElement>, elementsMap: ElementsMap, offset?: [number, number, number, number]) => Bounds;
-export declare const pointInsideBounds: <P extends GlobalPoint | LocalPoint>(p: P, bounds: Bounds) => boolean;
-export declare const aabbsOverlapping: (a: Bounds, b: Bounds) => boolean;
-export declare const getCornerRadius: (x: number, element: ExcalidrawElement) => number;
-export declare const isPathALoop: (points: ExcalidrawLinearElement["points"], zoomValue?: Zoom["value"]) => boolean;
-export declare const toggleLinePolygonState: (element: ExcalidrawLineElement, nextPolygonState: boolean) => {
-    polygon: ExcalidrawLineElement["polygon"];
-    points: ExcalidrawLineElement["points"];
-} | null;