@yorab/react-paint 0.17.1 → 0.18.1

package/dist/src/canvas/utils/shapes/rectangle.d.ts

@@ -0,0 +1,22 @@
+import type { UtilsSettings } from './../../../../canvas/constants/app';
+import type { SelectionModeResize } from './../../../../common/types/Mode';
+import type { DrawableShape, Point, Rect, SelectionType, ShapeEntity } from './../../../../common/types/Shapes';
+import type { ToolsSettingsType } from './../../../../common/types/tools';
+import { type GroupResizeContext } from './group';
+type rectish = 'rect' | 'square';
+export declare const refreshRect: <T extends rectish>(rect: DrawableShape<rectish> & {
+    id: string;
+}, settings: UtilsSettings) => ShapeEntity<T>;
+export declare const createRectangle: <T extends rectish>(shape: {
+    id: string;
+    type: T;
+    settings: ToolsSettingsType<T>;
+}, cursorPosition: Point, settings: UtilsSettings, width?: number, height?: number) => ShapeEntity<T>;
+export declare const drawRect: (ctx: CanvasRenderingContext2D, shape: ShapeEntity<rectish>) => void;
+export declare const getRectBorder: (rect: Rect, settings: Pick<UtilsSettings, "selectionPadding">) => Rect;
+export declare const getRectOppositeAnchorAbsolutePosition: <T extends DrawableShape & Rect>(anchor: Point, center: Point, shape: T, [negW, negH]?: [boolean, boolean]) => Point;
+export declare const resizeRect: <T extends rectish>(cursorPosition: Point, originalShape: ShapeEntity<T>, selectionMode: SelectionModeResize, settings: UtilsSettings, keepRatio?: boolean, resizeFromCenter?: boolean) => ShapeEntity<T>;
+export declare const resizeRectInGroup: (shape: ShapeEntity<rectish>, group: SelectionType & {
+    type: "group";
+}, groupCtx: GroupResizeContext) => ShapeEntity<rectish>;
+export {};

package/dist/src/canvas/utils/shapes/text.d.ts

@@ -0,0 +1,27 @@
+import type { UtilsSettings } from './../../../../canvas/constants/app';
+import type { SelectionModeResize } from './../../../../common/types/Mode';
+import type { DrawableShape, Point, Rect, SelectionType, ShapeEntity, Text } from './../../../../common/types/Shapes';
+import type { ToolsSettingsType } from './../../../../common/types/tools';
+import { type GroupResizeContext } from './group';
+export declare const getComputedText: (text: DrawableShape<"text">, settings: UtilsSettings) => {
+    borders: Rect;
+    outerBorders: Rect;
+    center: Point;
+    boundingBox: Rect;
+};
+export declare const refreshText: <T extends DrawableShape<"text">>(shape: T & {
+    id: string;
+}, settings: UtilsSettings) => ShapeEntity<"text">;
+export declare const calculateTextFontSize: (ctx: CanvasRenderingContext2D, text: string[], maxWidth: number, fontBold: boolean, fontItalic: boolean, fontFamily?: string | undefined) => number;
+export declare const createText: (ctx: CanvasRenderingContext2D, shape: {
+    id: string;
+    type: "text";
+    settings: ToolsSettingsType<"text">;
+}, cursorPosition: Point, settings: UtilsSettings) => ShapeEntity<"text">;
+export declare const drawText: (ctx: CanvasRenderingContext2D, text: DrawableShape<"text">) => void;
+export declare const getTextBorder: (text: Text, settings: Pick<UtilsSettings, "selectionPadding">) => Rect;
+export declare const resizeText: (ctx: CanvasRenderingContext2D, cursorPosition: Point, originalShape: ShapeEntity<"text">, selectionMode: SelectionModeResize, settings: UtilsSettings, resizeFromCenter: boolean) => ShapeEntity<"text">;
+export declare const resizeTextInGroup: (canvasCtx: CanvasRenderingContext2D, shape: ShapeEntity<"text">, group: SelectionType & {
+    type: "group";
+}, groupCtx: GroupResizeContext) => ShapeEntity<"text">;
+export declare const resizeTextShapeWithNewContent: (ctx: CanvasRenderingContext2D, shape: ShapeEntity<"text">, newValue: string[], settings: UtilsSettings) => ShapeEntity<"text">;

package/dist/src/canvas/utils/shapes/triangle.d.ts

@@ -0,0 +1,4 @@
+import type { UtilsSettings } from './../../../../canvas/constants/app';
+import type { Triangle, TriangleEntity } from './../../../../common/types/Shapes';
+export declare const createTriangle: (triangle: Triangle, settings: UtilsSettings) => TriangleEntity;
+export declare const drawTriangle: (ctx: CanvasRenderingContext2D, triangle: TriangleEntity) => void;

package/dist/src/canvas/utils/transform.d.ts

@@ -0,0 +1,15 @@
+import type { UtilsSettings } from './../../../canvas/constants/app';
+import type { SelectionModeData } from './../../../common/types/Mode';
+import type { DrawableShape, Line, Point, SelectionType } from './../../../common/types/Shapes';
+export declare const roundValues: (prop: number, precision?: number) => number;
+export declare const scalePoint: (point: Point, minX: number, minY: number, scaleX?: number, scaleY?: number) => Point;
+export declare const roundForGrid: (value: number, settings: UtilsSettings, gridOffset?: number) => number;
+export declare const roundRotationForGrid: (rotation: number, settings: UtilsSettings, isShiftPressed: boolean) => number;
+export declare const boundVectorToSingleAxis: (vector: Point, isShiftPressed: boolean) => Point;
+export declare const transformShape: (ctx: CanvasRenderingContext2D, selectedShape: SelectionType, cursorPosition: Point, selectionMode: SelectionModeData<Point | number>, settings: UtilsSettings, isShiftPressed: boolean, isAltPressed: boolean) => SelectionType;
+export declare const fitContentInsideContainer: (contentWidth: number, contentHeight: number, containerWidth: number, containerHeight: number, shouldFillContainer?: boolean) => Point;
+export declare const shortenLine: ({ line, size, direction }: {
+    line: DrawableShape<"line">;
+    size: number;
+    direction: "start" | "end" | "both";
+}) => Line;

package/dist/src/canvas/utils/trigo.d.ts

@@ -0,0 +1,19 @@
+import type { Circle, Point, Rect } from './../../../common/types/Shapes';
+type Vector = [Point, Point];
+export declare const degreesToRadians: (degrees: number) => number;
+export declare const radiansToDegrees: (radians: number) => number;
+export declare const isPointInsideRect: (rect: Rect, point: Point) => boolean;
+export declare const isCircleIntersectRect: (rect: Rect, circle: Circle) => boolean;
+export declare const rotatePoint: ({ origin, point, rotation }: {
+    origin?: Point;
+    point: Point;
+    rotation?: number | undefined;
+}) => Point;
+export declare const getAngleFromVector: ({ targetVector: [point1, point2], radian, originVector }: {
+    targetVector: Vector;
+    radian?: boolean;
+    originVector?: Vector;
+}) => number;
+export declare const getDistanceBetweenPoints: (p1: Point, p2: Point) => number;
+export declare const getCenter: (e1: Point, e2: Point) => Point;
+export {};

package/dist/src/canvas/utils/zoom.d.ts

@@ -0,0 +1,58 @@
+import type { UtilsSettings } from './../../../canvas/constants/app';
+import type { CanvasSize, Size } from './../../../common/types/Canvas';
+import type { Point, Rect } from './../../../common/types/Shapes';
+export declare const getNewOffset: ({ size, zoom, newOffset: [x, y], canvasSize }: {
+    zoom: number;
+    size: Size;
+    newOffset: Point;
+    canvasSize: CanvasSize;
+}) => {
+    zoom: number;
+    offset: Point;
+};
+export declare const calculateNewZoomAndOffset: ({ size, canvasSize, currentOffset, currentZoom, zoom, centerPoint: iCenterPoint }: {
+    size: Size;
+    canvasSize: CanvasSize;
+    currentOffset: Point;
+    currentZoom: number;
+    zoom: number;
+    centerPoint: Point;
+}) => {
+    offset: Point;
+    zoom: number;
+};
+export declare const getNewZoomAndOffset: ({ size, canvasSize, currentOffset, currentZoom, action }: {
+    size: Size;
+    canvasSize: CanvasSize;
+    currentOffset: Point;
+    currentZoom: number;
+    action: "unzoom" | "zoom" | "default";
+}) => {
+    offset: Point;
+    zoom: number;
+};
+export declare const getNewZoomAndOffsetFromDelta: ({ size, canvasSize, currentOffset, currentZoom, delta, centerPoint }: {
+    size: Size;
+    canvasSize: CanvasSize;
+    currentOffset: Point;
+    currentZoom: number;
+    delta: number;
+    centerPoint: Point;
+}) => {
+    offset: Point;
+    zoom: number;
+};
+export declare const getCurrentView: (settings: UtilsSettings) => Rect;
+export declare const getMaskRect: (settings: UtilsSettings) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export declare const clipMask: (ctx: CanvasRenderingContext2D, settings: UtilsSettings) => void;
+export declare const drawMask: (ctx: CanvasRenderingContext2D, settings: UtilsSettings) => void;
+export declare const isCursorInsideMask: (cursorPosition: Point, settings: UtilsSettings) => boolean;
+export declare const normalizeWheel: (event: WheelEvent, lastTimeEvent: number) => {
+    deltaX: number;
+    deltaY: number;
+};

package/dist/src/common/hooks/useDebounce.d.ts

@@ -0,0 +1,2 @@
+declare const useDebounce: <T extends (...args: any[]) => void>(callback: T, delay?: number) => (...args: Parameters<T>) => void;
+export default useDebounce;

package/dist/src/common/types/Canvas.d.ts

@@ -0,0 +1,8 @@
+export type CanvasSize = {
+    realWidth: number;
+    realHeight: number;
+    width: number;
+    height: number;
+    scaleRatio: number;
+};
+export type Size = 'infinite' | 'fixed';

package/dist/src/common/types/Mode.d.ts

@@ -0,0 +1,64 @@
+import type { Point, SelectionType } from './Shapes';
+export type SelectionModeDefault = {
+    mode: 'default';
+};
+export type SelectionModeSelectionFrame = {
+    mode: 'selectionFrame';
+};
+export type SelectionModeBrush = {
+    mode: 'brush';
+};
+export type SelectionModePreview = {
+    mode: 'preview';
+};
+export type SelectionModeEditText = {
+    mode: 'textedition';
+    defaultValue: string[];
+};
+export type SelectionModeResize<AnchorType extends Point | number = Point> = {
+    mode: 'resize';
+    cursorStartPosition: Point;
+    originalShape: SelectionType;
+    selectedShapesLengthAtMouseDown: number;
+    anchor: AnchorType;
+};
+export type SelectionModeRotate = {
+    mode: 'rotate';
+    cursorStartPosition: Point;
+    originalShape: SelectionType;
+    selectedShapesLengthAtMouseDown: number;
+    center: Point;
+};
+export type SelectionModeTranslate = {
+    mode: 'translate';
+    cursorStartPosition: Point;
+    originalShape: SelectionType;
+    selectedShapesLengthAtMouseDown: number;
+    hasBeenDuplicated: boolean;
+    dateStart: number;
+};
+export type SelectionModeContextMenu<AnchorType extends Point | number = Point> = {
+    mode: 'contextMenu';
+    cursorStartPosition: Point;
+    originalShape: SelectionType | undefined;
+    anchor: AnchorType | undefined;
+};
+export type SelectionModeData<AnchorType extends Point | number> = SelectionModeDefault | SelectionModeSelectionFrame | SelectionModeBrush | SelectionModeResize<AnchorType> | SelectionModeRotate | SelectionModeTranslate | SelectionModeEditText | SelectionModePreview | SelectionModeContextMenu<AnchorType>;
+export type HoverModeData = {
+    outOfView?: boolean;
+} & ({
+    mode: 'default';
+} | {
+    mode: 'selectionFrame';
+} | {
+    mode: 'resize';
+    anchor: Point | number;
+} | {
+    mode: 'brush';
+} | {
+    mode: 'rotate';
+} | {
+    mode: 'translate';
+} | {
+    mode: 'textedition';
+});

package/dist/src/common/types/Settings.d.ts

@@ -0,0 +1,24 @@
+import type { Point } from './../../../common/types/Shapes';
+export type BrushAlgo = 'simple' | 'quadratic';
+export type UtilsSettings = {
+    brushAlgo: BrushAlgo;
+    isBrushShapeDoneOnMouseUp: boolean;
+    gridGap: number;
+    canvasOffset: Point;
+    canvasZoom: number;
+    canvasSize: {
+        realWidth: number;
+        realHeight: number;
+        width: number;
+        height: number;
+        scaleRatio: number;
+        scaleRatioWithNoZoom: number;
+    };
+    selectionPadding: number;
+    size: 'infinite' | 'fixed';
+    features: {
+        zoom: boolean;
+        edition: boolean;
+    };
+    debug: boolean;
+};

package/dist/src/common/types/Shapes.d.ts

@@ -0,0 +1,153 @@
+import type { ShapeTypeArray } from '../../canvas/constants/shapes';
+export type ShapeType = (typeof ShapeTypeArray)[number];
+export type Point = [number, number];
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+export type Picture = Rect & {
+    src: string;
+};
+export type Text = Rect & {
+    value: string[];
+    fontSize: number;
+};
+export type Line = {
+    points: readonly [Point, Point];
+};
+export type Triangle = {
+    points: [Point, Point, Point];
+};
+export type Polygon = {
+    points: Point[];
+    tempPoint?: Point | undefined;
+};
+export type Curve = {
+    points: Point[];
+    tempPoint?: Point | undefined;
+};
+export type Brush = {
+    points: Point[][];
+};
+export type Circle = {
+    x: number;
+    y: number;
+    radius: number;
+};
+export type Ellipse = {
+    x: number;
+    y: number;
+    radiusX: number;
+    radiusY: number;
+};
+export type StyleShape = {
+    fillColor?: string;
+    opacity?: number;
+    strokeColor?: string;
+    lineWidth?: number;
+    lineDash?: number;
+    lineArrow?: number;
+    lineCap?: CanvasLineCap;
+    closedPoints?: number;
+    fontFamily?: string;
+    fontItalic?: boolean;
+    fontBold?: boolean;
+};
+export type SelectionDefaultType = {
+    type: 'rect';
+    border: Path2D;
+    line: Path2D | undefined;
+    shapePath: Path2D | undefined;
+    anchors: Path2D[];
+};
+export type SelectionLinesType = {
+    type: 'line';
+    border: Path2D;
+    shapePath: Path2D | undefined;
+    anchors: Path2D[];
+};
+type GenericDrawableShape = {
+    rotation?: number;
+    toolId?: string;
+    visible?: boolean;
+    locked?: boolean;
+    style?: StyleShape | undefined;
+} & ((Line & {
+    type: 'line';
+}) | (Picture & {
+    type: 'picture';
+    img: HTMLImageElement;
+    flipX?: boolean;
+    flipY?: boolean;
+    ratio?: number;
+}) | (Text & {
+    type: 'text';
+    flipX?: boolean;
+    flipY?: boolean;
+    ratio?: number;
+}) | (Rect & {
+    type: 'rect';
+}) | (Rect & {
+    type: 'square';
+}) | (Circle & {
+    type: 'circle';
+}) | (Ellipse & {
+    type: 'ellipse';
+}) | (Triangle & {
+    type: 'triangle';
+}) | (Polygon & {
+    type: 'polygon';
+}) | (Curve & {
+    type: 'curve';
+}) | (Brush & {
+    type: 'brush';
+    scaleX?: number;
+    scaleY?: number;
+}) | (Rect & {
+    type: 'group';
+    shapes: ShapeEntity[];
+}));
+export type DrawableShape<T extends ShapeType = ShapeType> = GenericDrawableShape & {
+    type: T;
+};
+export type ExportedDrawableShape<T extends ShapeType = ShapeType> = T extends 'picture' ? Omit<DrawableShape<'picture'>, 'img'> : DrawableShape<T>;
+export type TriangleEntity = DrawableShape<'triangle'> & {
+    path: Path2D;
+    computed: {
+        borders: Rect;
+        outerBorders: Rect;
+        center: Point;
+        boundingBox: Rect;
+    };
+};
+export type ShapeEntity<T extends Exclude<ShapeType, 'triangle'> = Exclude<ShapeType, 'triangle'>> = {
+    id: string;
+    computed: {
+        borders: Rect;
+        outerBorders: Rect;
+        center: Point;
+        boundingBox: Rect;
+    };
+    path: Path2D;
+} & DrawableShape<T> & ({
+    type: 'line';
+    selection?: SelectionLinesType | undefined;
+    arrows?: TriangleEntity[];
+} | {
+    type: 'polygon' | 'curve';
+    selection?: SelectionLinesType | undefined;
+} | {
+    type: 'text' | 'picture' | 'rect' | 'square' | 'circle' | 'ellipse' | 'group' | 'brush';
+    selection?: SelectionDefaultType | undefined;
+});
+export type StateData = {
+    shapes?: DrawableShape[];
+    config?: {
+        width: number;
+        height: number;
+    };
+};
+export type SelectionType = ShapeEntity;
+export {};

package/dist/src/common/types/react.d.ts

@@ -0,0 +1,6 @@
+import 'react';
+declare module 'react' {
+    interface CSSProperties {
+        [key: `--${string}`]: string | number;
+    }
+}

package/dist/src/common/types/tools.d.ts

@@ -0,0 +1,164 @@
+import type { ShapeType } from './Shapes';
+export type CustomToolInput = {
+    id: string;
+    icon?: string;
+    label?: string;
+} & ({
+    type: 'brush';
+    settings: ToolsSettingsType<'brush'>;
+} | {
+    type: 'circle';
+    settings: ToolsSettingsType<'circle'>;
+} | {
+    type: 'ellipse';
+    settings: ToolsSettingsType<'ellipse'>;
+} | {
+    type: 'rect';
+    settings: ToolsSettingsType<'rect'>;
+} | {
+    type: 'square';
+    settings: ToolsSettingsType<'square'>;
+} | {
+    type: 'line';
+    settings: ToolsSettingsType<'line'>;
+} | {
+    type: 'polygon';
+    settings: ToolsSettingsType<'polygon'>;
+} | {
+    type: 'curve';
+    settings: ToolsSettingsType<'curve'>;
+} | {
+    type: 'text';
+    settings: ToolsSettingsType<'text'>;
+} | {
+    type: 'picture';
+    settings: ToolsSettingsType<'picture'>;
+});
+export type CustomTool = {
+    id: string;
+    icon: string;
+    label: string;
+} & ({
+    type: 'brush';
+    settings: ToolsSettingsType<'brush'>;
+} | {
+    type: 'circle';
+    settings: ToolsSettingsType<'circle'>;
+} | {
+    type: 'ellipse';
+    settings: ToolsSettingsType<'ellipse'>;
+} | {
+    type: 'rect';
+    settings: ToolsSettingsType<'rect'>;
+} | {
+    type: 'square';
+    settings: ToolsSettingsType<'square'>;
+} | {
+    type: 'line';
+    settings: ToolsSettingsType<'line'>;
+} | {
+    type: 'polygon';
+    settings: ToolsSettingsType<'polygon'>;
+} | {
+    type: 'curve';
+    settings: ToolsSettingsType<'curve'>;
+} | {
+    type: 'text';
+    settings: ToolsSettingsType<'text'>;
+} | {
+    type: 'picture';
+    settings: ToolsSettingsType<'picture'>;
+} | {
+    type: 'group';
+    settings: ToolsSettingsType<'group'>;
+});
+export type SettingsOpacity = {
+    opacity: {
+        min: number;
+        max: number;
+        step: number;
+        default: number;
+        hidden?: boolean;
+    };
+};
+export type SettingsStrokeColor = {
+    strokeColor: {
+        values: string[];
+        default: string;
+        hidden?: boolean;
+    };
+};
+export type SettingsFillColor = {
+    fillColor: {
+        values: string[];
+        default: string;
+        hidden?: boolean;
+    };
+};
+export type SettingsLineWidth = {
+    lineWidth: {
+        min: number;
+        max: number;
+        step: number;
+        default: number;
+        hidden?: boolean;
+    };
+};
+export type SettingsLineDash = {
+    lineDash: {
+        values: number[];
+        default: number;
+        hidden?: boolean;
+    };
+};
+export type SettingsLineArrow = {
+    lineArrow: {
+        values: number[];
+        default: number;
+        hidden?: boolean;
+    };
+};
+export type SettingsFont = {
+    fontFamily: {
+        values: string[];
+        default: string;
+        hidden?: boolean;
+    };
+    fontBold: {
+        values: boolean[];
+        default: boolean;
+        hidden?: boolean;
+    };
+    fontItalic: {
+        values: boolean[];
+        default: boolean;
+        hidden?: boolean;
+    };
+};
+export type SettingsClosedPoints = {
+    closedPoints: {
+        default: number;
+        hidden?: boolean;
+    };
+};
+export type ToolsRectSettings = SettingsStrokeColor & SettingsFillColor & SettingsOpacity & SettingsLineWidth & SettingsLineDash;
+export type ToolsSquareSettings = SettingsStrokeColor & SettingsFillColor & SettingsOpacity & SettingsLineWidth & SettingsLineDash;
+export type ToolsCircleSettings = SettingsStrokeColor & SettingsFillColor & SettingsOpacity & SettingsLineWidth & SettingsLineDash;
+export type ToolsEllipseSettings = SettingsStrokeColor & SettingsFillColor & SettingsOpacity & SettingsLineWidth & SettingsLineDash;
+export type ToolsTextSettings = SettingsOpacity & SettingsStrokeColor & SettingsFont;
+export type ToolsLineSettings = SettingsOpacity & SettingsStrokeColor & SettingsLineWidth & SettingsLineDash & SettingsLineArrow;
+export type ToolsBrushSettings = SettingsOpacity & SettingsStrokeColor & SettingsLineWidth & SettingsLineDash;
+export type ToolsPolygonSettings = SettingsOpacity & SettingsStrokeColor & SettingsFillColor & SettingsLineWidth & SettingsLineDash & SettingsClosedPoints;
+export type ToolsCurveSettings = SettingsOpacity & SettingsStrokeColor & SettingsFillColor & SettingsLineWidth & SettingsLineDash & SettingsClosedPoints;
+export type ToolsTriangleSettings = SettingsStrokeColor & SettingsFillColor & SettingsOpacity & SettingsLineWidth & SettingsLineDash;
+export type ToolsPictureSettings = SettingsOpacity;
+export type ToolsGroupSettings = Partial<SettingsOpacity & SettingsStrokeColor & SettingsFillColor & SettingsLineWidth & SettingsLineDash & SettingsLineArrow>;
+export type ToolsSettingsType<T extends ShapeType> = T extends 'rect' ? ToolsRectSettings : T extends 'square' ? ToolsSquareSettings : T extends 'circle' ? ToolsCircleSettings : T extends 'ellipse' ? ToolsEllipseSettings : T extends 'text' ? ToolsTextSettings : T extends 'line' ? ToolsLineSettings : T extends 'brush' ? ToolsBrushSettings : T extends 'polygon' ? ToolsPolygonSettings : T extends 'curve' ? ToolsCurveSettings : T extends 'triangle' ? ToolsTriangleSettings : T extends 'picture' ? ToolsPictureSettings : T extends 'group' ? ToolsGroupSettings : never;
+export type ActionsType = 'selection' | 'undo' | 'redo' | 'clear' | 'export' | 'loadfile' | 'savefile' | 'move' | 'uploadpicture' | 'addurlpicture';
+export type ActionsTool = {
+    id: string;
+    type: ActionsType;
+    icon: string;
+    label: string;
+};
+export type ToolsType = CustomTool | ActionsTool;

package/dist/src/common/types/utils.d.ts

@@ -0,0 +1,4 @@
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends (infer U)[] ? RecursivePartial<U>[] : T[P] extends object ? RecursivePartial<T[P]> : T[P] | undefined;
+};
+export type ValueOf<T> = T[keyof T];

package/dist/src/common/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare const compact: <T>(array: (T | undefined | null)[]) => T[];
+export declare const moveItemPosition: <T>(array: T[], positionToMove: number, positionToEnd: number) => T[];

package/dist/src/common/utils/dom.d.ts

@@ -0,0 +1 @@
+export declare const isEventInsideNode: (event: MouseEvent | TouchEvent, node: HTMLElement | null) => boolean;

package/dist/src/common/utils/object.d.ts

@@ -0,0 +1,4 @@
+export declare const omit: <T extends Record<string, unknown>>(keys: (string | [string, unknown[]])[], obj: T) => T;
+export declare const set: <T extends Record<string, any> | unknown[]>(path: string | number | (string | number)[], value: unknown, obj: T) => T;
+export declare const mergeWith: (customMergeFn: (objValue: unknown, srcValue: unknown, key: string) => unknown, target: unknown, source: unknown) => unknown;
+export declare const isEqual: (a: unknown, b: unknown) => boolean;

package/dist/src/common/utils/selection.d.ts

@@ -0,0 +1,4 @@
+import type { SelectionType, ShapeEntity } from './../../../common/types/Shapes';
+import type { CustomTool } from './../../../common/types/tools';
+export declare const getSelectedShapes: (selection: SelectionType | undefined) => ShapeEntity[];
+export declare const getSelectedShapesTools: (selection: SelectionType | undefined, availableTools: CustomTool[]) => CustomTool | undefined;

package/dist/src/common/utils/util.d.ts

@@ -0,0 +1,3 @@
+export declare const uniqueId: (prefix?: string) => string;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const isMacOs: () => boolean;

package/dist/src/editor/components/common/Button.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import './Button.css';
+type CommonType = {
+    hidden?: boolean | undefined;
+    disabled?: boolean | undefined;
+    selected?: boolean | undefined;
+    icon?: string | undefined;
+};
+type ButtonType = CommonType & React.ButtonHTMLAttributes<HTMLButtonElement>;
+export type FileInputType = CommonType & {
+    type: 'file' | 'color';
+    accept?: string;
+    onClick?: React.MouseEventHandler<HTMLElement>;
+} & React.InputHTMLAttributes<HTMLInputElement | HTMLButtonElement>;
+declare const Button: React.ForwardRefExoticComponent<(FileInputType | ButtonType) & React.RefAttributes<HTMLButtonElement | HTMLInputElement>>;
+export default Button;

package/dist/src/editor/components/common/FileInput.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import './Button.css';
+declare const FileInput: React.ForwardRefExoticComponent<{
+    hidden?: boolean | undefined;
+    disabled?: boolean | undefined;
+    selected?: boolean | undefined;
+    icon?: string | undefined;
+} & {
+    type: "file" | "color";
+    accept?: string;
+    onClick?: React.MouseEventHandler<HTMLElement>;
+} & React.InputHTMLAttributes<HTMLButtonElement | HTMLInputElement> & React.RefAttributes<HTMLButtonElement | HTMLInputElement>>;
+export default FileInput;

package/dist/src/editor/components/common/Loading.d.ts

@@ -0,0 +1,6 @@
+import './Loading.css';
+export type LoadingType = {
+    isLoading: boolean;
+};
+declare const Loading: ({ isLoading }: LoadingType) => import("react/jsx-runtime").JSX.Element | null;
+export default Loading;

package/dist/src/editor/components/common/Menu.d.ts

@@ -0,0 +1,10 @@
+import './Menu.css';
+type MenuType = {
+    alignment?: 'left' | 'center' | 'right' | undefined;
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+    position?: 'top' | 'bottom' | 'left' | 'right' | undefined;
+};
+declare const Menu: ({ alignment, children, className, style, position }: MenuType) => import("react/jsx-runtime").JSX.Element;
+export default Menu;