vkedit 2.8.5

package/dist/components/ui/slider/Slider.vue.d.ts

@@ -0,0 +1,13 @@
+import { SliderRootProps } from 'reka-ui';
+import { HTMLAttributes } from 'vue';
+type __VLS_Props = SliderRootProps & {
+    class?: HTMLAttributes["class"];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: number[] | undefined) => any;
+    valueCommit: (payload: number[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: number[] | undefined) => any) | undefined;
+    onValueCommit?: ((payload: number[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/ui/slider/index.d.ts

@@ -0,0 +1 @@
+export { default as Slider } from './Slider.vue';

package/dist/components/ui/switch/Switch.vue.d.ts

@@ -0,0 +1,26 @@
+import { SwitchRootProps } from 'reka-ui';
+import { HTMLAttributes } from 'vue';
+type __VLS_Props = SwitchRootProps & {
+    class?: HTMLAttributes["class"];
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        thumb?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (payload: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/switch/index.d.ts

@@ -0,0 +1 @@
+export { default as Switch } from './Switch.vue';

package/dist/components/ui/textarea/Textarea.vue.d.ts

@@ -0,0 +1,12 @@
+import { HTMLAttributes } from 'vue';
+type __VLS_Props = {
+    class?: HTMLAttributes["class"];
+    defaultValue?: string | number;
+    modelValue?: string | number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (payload: string | number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: string | number) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLTextAreaElement>;
+export default _default;

package/dist/components/ui/textarea/index.d.ts

@@ -0,0 +1 @@
+export { default as Textarea } from './Textarea.vue';

package/dist/components/ui/toggle/Toggle.vue.d.ts

@@ -0,0 +1,33 @@
+import { ToggleProps } from 'reka-ui';
+import { HTMLAttributes } from 'vue';
+import { ToggleVariants } from '.';
+type __VLS_Props = ToggleProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleVariants["variant"];
+    size?: ToggleVariants["size"];
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: any): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    size: "default" | "sm" | "lg" | null;
+    variant: "default" | "outline" | null;
+    disabled: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/ui/toggle/index.d.ts

@@ -0,0 +1,7 @@
+import { VariantProps } from 'class-variance-authority';
+export { default as Toggle } from './Toggle.vue';
+export declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import('class-variance-authority/types').ClassProp) | undefined) => string;
+export type ToggleVariants = VariantProps<typeof toggleVariants>;

package/dist/core/BgLayer.vue.d.ts

@@ -0,0 +1,8 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    bgLayerRef: unknown;
+}, any>;
+export default _default;

package/dist/core/ContentLayer.vue.d.ts

@@ -0,0 +1,29 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        contentLayerRef: unknown;
+        groupRef: unknown;
+        transformerRef: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    contentLayerRef: unknown;
+    groupRef: unknown;
+    transformerRef: unknown;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/ContextMenu.vue.d.ts

@@ -0,0 +1,6 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/Editor.vue.d.ts

@@ -0,0 +1,38 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+    showToolbox?: boolean;
+    showPropertyPanel?: boolean;
+    showToolbar?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'toolbar-left'?(_: {
+            host: EditorHost;
+        }): any;
+        'toolbar-center'?(_: {
+            host: EditorHost;
+        }): any;
+        'toolbar-right'?(_: {
+            host: EditorHost;
+        }): any;
+        toolbox?(_: {
+            host: EditorHost;
+        }): any;
+        'property-panel'?(_: {
+            host: EditorHost;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/PropertyPanel.vue.d.ts

@@ -0,0 +1,23 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'property-panel'?(_: {
+            host: EditorHost;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/RulerLayer.vue.d.ts

@@ -0,0 +1,10 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rulerLayerRef: unknown;
+    upRulerShapeRef: unknown;
+    leftRulerShapeRef: unknown;
+}, any>;
+export default _default;

package/dist/core/ScrollbarLayer.vue.d.ts

@@ -0,0 +1,8 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    scrollbarLayerRef: unknown;
+}, any>;
+export default _default;

package/dist/core/SelectionLayer.vue.d.ts

@@ -0,0 +1,6 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/StageView.vue.d.ts

@@ -0,0 +1,9 @@
+import { EditorHost } from '.';
+interface Props {
+    host: EditorHost;
+}
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    stageWrapperRef: HTMLDivElement;
+    stageRef: unknown;
+}, HTMLDivElement>;
+export default _default;

package/dist/core/Toolbar.vue.d.ts

@@ -0,0 +1,29 @@
+import { EditorHost } from '.';
+interface Props {
+    host: EditorHost;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        left?(_: {
+            host: EditorHost;
+        }): any;
+        center?(_: {
+            host: EditorHost;
+        }): any;
+        right?(_: {
+            host: EditorHost;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/Toolbox.vue.d.ts

@@ -0,0 +1,23 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        toolbox?(_: {
+            host: EditorHost;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/core/Zoom.vue.d.ts

@@ -0,0 +1,6 @@
+import { EditorHost } from '.';
+type __VLS_Props = {
+    host: EditorHost;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/core/editor-host.d.ts

@@ -0,0 +1,34 @@
+import { IEditorPlugin, IEditorState, EventMap, PluginMap } from '../types';
+import { ICommand } from '../commands/i-command';
+import { RectPlugin } from '../plugins';
+export declare class EditorHost {
+    private plugins;
+    private events;
+    private commandStack;
+    private currentCommandIndex;
+    contentLayer: any;
+    contentGroup: any;
+    stage: any;
+    private _status;
+    emit<K extends keyof EventMap>(event: K, payload: Parameters<EventMap[K]>[0]): void;
+    on<K extends keyof EventMap>(event: K, handler: EventMap[K]): void;
+    off<K extends keyof EventMap>(event: K, handler: EventMap[K]): void;
+    installPlugin<K extends keyof PluginMap>(name: K, pluginClass: PluginMap[K] | (new (...args: any[]) => PluginMap[K])): EditorHost;
+    installPlugin(name: string, pluginClass: IEditorPlugin | (new (...args: any[]) => IEditorPlugin)): EditorHost;
+    uninstallPlugin<K extends keyof PluginMap>(pluginName: K): EditorHost;
+    uninstallPlugin(pluginName: string): EditorHost;
+    getPlugin<K extends keyof PluginMap>(pluginName: K): PluginMap[K];
+    getPlugin<T extends IEditorPlugin = IEditorPlugin>(pluginName: string): T;
+    executeCommand(command: ICommand): void;
+    undo(): void;
+    redo(): void;
+    get status(): IEditorState;
+    setStatus(newStatus: Partial<IEditorState>): void;
+    toJSON(): string;
+    loadJSON(jsonStr: string): void;
+}
+declare module '../types' {
+    interface PluginMap {
+        ttt: RectPlugin;
+    }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export { EditorHost } from './editor-host';
+export { default as Vkedit } from './Editor.vue';

package/dist/create-host.d.ts

@@ -0,0 +1,9 @@
+import { EditorHost } from './core/editor-host';
+export interface IOptions {
+    basePropertyPanel?: boolean;
+    baseCanvasPropertyPanel?: boolean;
+    exportPlugin?: boolean;
+    previewPlugin?: boolean;
+    importPlugin?: boolean;
+}
+export declare function createEditorHost({ basePropertyPanel, baseCanvasPropertyPanel, exportPlugin, previewPlugin, importPlugin, }: IOptions): EditorHost;

package/dist/hooks/index.d.ts

@@ -0,0 +1,10 @@
+export * from './use-bg-layer';
+export * from './use-content-layer';
+export * from './use-host-state';
+export * from './use-property-command';
+export * from './use-ruler-layer';
+export * from './use-scrollbar-layer';
+export * from './use-selection-layer';
+export * from './use-stage-event';
+export * from './use-stage';
+export * from './use-zoom';

package/dist/hooks/use-bg-layer.d.ts

@@ -0,0 +1,22 @@
+import { EditorHost } from '../core';
+export declare function useBgLayer(host: EditorHost): {
+    bgLayerConfig: import('vue').ComputedRef<{
+        listening: boolean;
+    }>;
+    bgConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        listening: boolean;
+    }>;
+    contentBgConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        listening: boolean;
+    }>;
+};

package/dist/hooks/use-content-layer.d.ts

@@ -0,0 +1,66 @@
+import { IGraphicElement } from '../types';
+import { EditorHost } from '../core';
+export declare function useContentLayer(host: EditorHost): {
+    contentLayerRef: import('vue').Ref<any, any>;
+    transformerRef: import('vue').Ref<any, any>;
+    contentLayerConfig: import('vue').ComputedRef<{}>;
+    contentGroupConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        scaleX: number;
+        scaleY: number;
+    }>;
+    elements: import('vue').Ref<{
+        id: string;
+        type: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        visible: boolean;
+        locked: boolean;
+        draggable: boolean;
+        transferable: boolean;
+        getBoundingBox: () => import('../types').BoundingBox;
+        clone: () => IGraphicElement;
+        serialize: () => any;
+        deserialize: (data: any) => void;
+        updateProperty: (host: EditorHost, property: string, oldValue: any, newValue: any) => void;
+        getTransformAttr?: ((event: any) => {
+            oldAttrs: any;
+            newAttrs: any;
+        }) | undefined;
+    }[], IGraphicElement[] | {
+        id: string;
+        type: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        visible: boolean;
+        locked: boolean;
+        draggable: boolean;
+        transferable: boolean;
+        getBoundingBox: () => import('../types').BoundingBox;
+        clone: () => IGraphicElement;
+        serialize: () => any;
+        deserialize: (data: any) => void;
+        updateProperty: (host: EditorHost, property: string, oldValue: any, newValue: any) => void;
+        getTransformAttr?: ((event: any) => {
+            oldAttrs: any;
+            newAttrs: any;
+        }) | undefined;
+    }[]>;
+    initElements: () => void;
+    handleDragEnd: (event: any, element: any) => void;
+    handleElementTransform: (event: any, element: IGraphicElement) => void;
+    handleElementTransformEnd: (event: any, element: any) => void;
+    updateTransformerNodes: (selection: IGraphicElement[]) => void;
+    updateCanvas: () => void;
+};

package/dist/hooks/use-host-state.d.ts

@@ -0,0 +1,14 @@
+import { EditorHost } from '../core';
+export declare function useHostState(host: EditorHost): {
+    hostState: {
+        zoom: number;
+        currentTool: string;
+        snapToGrid: boolean;
+        showGrid: boolean;
+        width: number;
+        height: number;
+        wmm: number;
+        hmm: number;
+        dpm: number;
+    };
+};

package/dist/hooks/use-property-command.d.ts

@@ -0,0 +1,6 @@
+import { IGraphicElement } from '../types';
+import { EditorHost } from '../core';
+export declare function usePropertyCommand(host: EditorHost): {
+    updateProperty: (element: IGraphicElement, propertyPath: string, newValue: any) => void;
+    batchUpdateProperty: (elements: IGraphicElement[], propertyPath: string, newValue: any) => void;
+};

package/dist/hooks/use-ruler-layer.d.ts

@@ -0,0 +1,24 @@
+export declare function useRulerLayer(): {
+    rulerLayerRef: import('vue').Ref<any, any>;
+    rulerLayerConfig: import('vue').ComputedRef<{
+        listening: boolean;
+    }>;
+    upRulerConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        listening: boolean;
+    }>;
+    leftRulerConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        listening: boolean;
+    }>;
+    upRulerShapeRef: import('vue').Ref<any, any>;
+    leftRulerShapeRef: import('vue').Ref<any, any>;
+};

package/dist/hooks/use-scrollbar-layer.d.ts

@@ -0,0 +1,47 @@
+import { EditorHost } from '../core';
+export declare function useScrollbarLayer(host: EditorHost): {
+    scrollbarLayerRef: import('vue').Ref<any, any>;
+    scrollbarLayerConfig: {};
+    showVerticalScroll: import('vue').ComputedRef<boolean>;
+    showHorizontalScroll: import('vue').ComputedRef<boolean>;
+    horizontalThumbConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        draggable: boolean;
+    }>;
+    verticalThumbConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        draggable: boolean;
+    }>;
+    horizontalTrackConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        listening: boolean;
+    }>;
+    verticalTrackConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        listening: boolean;
+    }>;
+    handleVerticalDragMove: (e: any) => void;
+    handleHorizontalDragMove: (e: any) => void;
+    contentScrollX: import('vue').ComputedRef<number>;
+    contentScrollY: import('vue').ComputedRef<number>;
+    handleWheel: (e: any) => void;
+    verticalThumbY: import('vue').Ref<number, number>;
+    horizontalThumbX: import('vue').Ref<number, number>;
+    resetScrollbarPosition: () => void;
+};

package/dist/hooks/use-selection-layer.d.ts

@@ -0,0 +1,35 @@
+import { Point2D } from '../types';
+import { EditorHost } from '../core';
+export declare function useSelectionLayer(host: EditorHost): {
+    isSelecting: import('vue').Ref<boolean, boolean>;
+    selectionStart: import('vue').Ref<{
+        x: number;
+        y: number;
+    }, Point2D | {
+        x: number;
+        y: number;
+    }>;
+    selectionEnd: import('vue').Ref<{
+        x: number;
+        y: number;
+    }, Point2D | {
+        x: number;
+        y: number;
+    }>;
+    handleMouseDown: (event: any) => void;
+    handleMouseMove: (event: any) => void;
+    handleMouseUp: (event: any) => void;
+    handlePMouseleave: (event: any) => void;
+    rectConfig: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        fill: string;
+        stroke: string;
+        strokeWidth: number;
+        dash: number[];
+        listening: boolean;
+    }>;
+    selectionLayerConfig: import('vue').Ref<{}, {}>;
+};

package/dist/hooks/use-stage-event.d.ts

@@ -0,0 +1,33 @@
+import { EditorHost } from '../core';
+export declare function useStageEvent(host: EditorHost): {
+    stageWrapperRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    transformOrigin: import('vue').Ref<{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+    }>;
+    hostState: {
+        zoom: number;
+        currentTool: string;
+        snapToGrid: boolean;
+        showGrid: boolean;
+        width: number;
+        height: number;
+        wmm: number;
+        hmm: number;
+        dpm: number;
+    };
+    handleClick: (event: any) => void;
+    handleMouseDown: (event: any) => void;
+    handleMouseMove: (event: any) => void;
+    handleMouseUp: (event: any) => void;
+    handleWheel: (e: any) => void;
+    handleKeyDown: (event: any) => void;
+    handleMouseleave: (event: any) => void;
+    handleContextmenu: (event: any) => void;
+};