orio-ui 1.20.0 → 1.23.2

package/dist/runtime/components/Canvas/components/Toolbar.vue

@@ -0,0 +1,48 @@
+<script setup>
+import { computed, provide, watchEffect } from "vue";
+import { useI18n } from "vue-i18n";
+import { CANVAS_CONTEXT } from "../context";
+import { canvasRegistry } from "../registry";
+import ToolButton from "./ToolButton.vue";
+const props = defineProps({
+  canvas: { type: String, required: true }
+});
+const { t } = useI18n();
+const ctx = computed(() => canvasRegistry.get(props.canvas));
+watchEffect(() => {
+  if (import.meta.env.DEV && !ctx.value) {
+    console.warn(
+      `[orio-canvas-toolbar] no canvas registered with name "${props.canvas}". Make sure <orio-canvas name="${props.canvas}" /> is mounted.`
+    );
+  }
+});
+const proxy = new Proxy({}, {
+  get(_, key) {
+    const real = ctx.value;
+    if (!real) return void 0;
+    return real[key];
+  }
+});
+provide(CANVAS_CONTEXT, proxy);
+</script>
+
+<template>
+  <div
+    v-if="ctx"
+    class="canvas-toolbar"
+    role="toolbar"
+    :aria-label="t('canvas.toolbarLabel')"
+  >
+    <slot
+      :tools="ctx.tools.value"
+      :active-tool-id="ctx.activeToolId.value"
+      :set-active-tool="ctx.setActiveTool"
+    >
+      <ToolButton v-for="tool in ctx.tools.value" :key="tool.id" :tool />
+    </slot>
+  </div>
+</template>
+
+<style scoped>
+.canvas-toolbar{display:flex;gap:.25rem;padding:.25rem}
+</style>

package/dist/runtime/components/Canvas/components/Toolbar.vue.d.ts

@@ -0,0 +1,24 @@
+interface Props {
+    /**
+     * Name of the `<orio-canvas>` instance to bind to. Lets the toolbar live
+     * anywhere in the app — header, sidebar, modal — not just inside the canvas.
+     */
+    canvas: string;
+}
+declare var __VLS_1: {
+    tools: any;
+    activeToolId: any;
+    setActiveTool: any;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Canvas/composables/useCanvasHistory.d.ts

@@ -0,0 +1,17 @@
+import { type Ref } from "vue";
+import type { CanvasNode } from "../types.js";
+export declare function useCanvasHistory(nodes: Ref<CanvasNode[]>, opts: {
+    maxHistory: () => number;
+    requestRender: () => void;
+}): {
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    undo: () => void;
+    redo: () => void;
+    commit: () => void;
+    autoCommit: () => void;
+    beginAction: () => void;
+    endAction: () => void;
+    resetBaseline: () => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+};

package/dist/runtime/components/Canvas/composables/useCanvasHistory.js

@@ -0,0 +1,76 @@
+import { computed, shallowRef } from "vue";
+function deepClone(arr) {
+  return JSON.parse(JSON.stringify(arr));
+}
+export function useCanvasHistory(nodes, opts) {
+  const undoStack = shallowRef([]);
+  const redoStack = shallowRef([]);
+  const canUndo = computed(() => undoStack.value.length > 0);
+  const canRedo = computed(() => redoStack.value.length > 0);
+  let committed = deepClone(nodes.value);
+  let pointerDown = false;
+  function commit() {
+    const current = deepClone(nodes.value);
+    if (JSON.stringify(committed) === JSON.stringify(current)) return;
+    const next = [...undoStack.value, committed];
+    if (next.length > opts.maxHistory()) next.shift();
+    undoStack.value = next;
+    if (redoStack.value.length > 0) redoStack.value = [];
+    committed = current;
+  }
+  function beginAction() {
+    pointerDown = true;
+  }
+  function endAction() {
+    pointerDown = false;
+    commit();
+  }
+  function undo() {
+    if (!canUndo.value) return;
+    const stack = [...undoStack.value];
+    const prev = stack.pop();
+    undoStack.value = stack;
+    redoStack.value = [...redoStack.value, committed];
+    committed = prev;
+    nodes.value = deepClone(prev);
+    opts.requestRender();
+  }
+  function redo() {
+    if (!canRedo.value) return;
+    const stack = [...redoStack.value];
+    const next = stack.pop();
+    redoStack.value = stack;
+    undoStack.value = [...undoStack.value, committed];
+    committed = next;
+    nodes.value = deepClone(next);
+    opts.requestRender();
+  }
+  function autoCommit() {
+    if (!pointerDown) commit();
+  }
+  function resetBaseline() {
+    committed = deepClone(nodes.value);
+  }
+  function onKeyDown(e) {
+    const mod = e.metaKey || e.ctrlKey;
+    if (!mod || e.key.toLowerCase() !== "z") return;
+    e.preventDefault();
+    if (e.shiftKey) {
+      redo();
+    } else {
+      undo();
+    }
+  }
+  return {
+    canUndo,
+    canRedo,
+    undo,
+    redo,
+    commit,
+    autoCommit,
+    beginAction,
+    endAction,
+    resetBaseline,
+    onKeyDown
+  };
+}

package/dist/runtime/components/Canvas/composables/useCanvasNodes.d.ts

@@ -0,0 +1,13 @@
+import type { Ref } from "vue";
+import type { CanvasNode } from "../types.js";
+export declare function useCanvasNodes(nodes: Ref<CanvasNode[]>, opts: {
+    onMutate: () => void;
+}): {
+    addNode: (node: Omit<CanvasNode, "id"> & {
+        id?: string;
+    }) => CanvasNode;
+    updateNode: (id: string, patch: Partial<Omit<CanvasNode, "id">>) => void;
+    getNode: (id: string) => any;
+    removeNode: (id: string) => void;
+    clear: () => void;
+};

package/dist/runtime/components/Canvas/composables/useCanvasNodes.js

@@ -0,0 +1,60 @@
+export function useCanvasNodes(nodes, opts) {
+  let pending = null;
+  function read() {
+    return pending ?? nodes.value;
+  }
+  function write(value) {
+    pending = value;
+    nodes.value = value;
+    queueMicrotask(() => {
+      pending = null;
+    });
+  }
+  function _addNode(node) {
+    const current = read();
+    const maxZ = current.reduce((m, n) => Math.max(m, n.zIndex ?? 0), -1);
+    const created = {
+      zIndex: maxZ + 1,
+      ...node,
+      id: node.id ?? crypto.randomUUID()
+    };
+    write([...current, created]);
+    return created;
+  }
+  function _updateNode(id, patch) {
+    const current = read();
+    const idx = current.findIndex((n) => n.id === id);
+    if (idx === -1) return;
+    const { id: _ignored, ...safePatch } = patch;
+    const next = current.slice();
+    next[idx] = { ...next[idx], ...safePatch };
+    write(next);
+  }
+  function getNode(id) {
+    return read().find((n) => n.id === id);
+  }
+  function _removeNode(id) {
+    write(read().filter((n) => n.id !== id));
+  }
+  function _clear() {
+    write(read().filter((n) => n.frozen));
+  }
+  function addNode(node) {
+    const created = _addNode(node);
+    opts.onMutate();
+    return created;
+  }
+  function updateNode(id, patch) {
+    _updateNode(id, patch);
+    opts.onMutate();
+  }
+  function removeNode(id) {
+    _removeNode(id);
+    opts.onMutate();
+  }
+  function clear() {
+    _clear();
+    opts.onMutate();
+  }
+  return { addNode, updateNode, getNode, removeNode, clear };
+}

package/dist/runtime/components/Canvas/composables/useCanvasSetup.d.ts

@@ -0,0 +1,5 @@
+import type { CanvasToolApi } from "../types.js";
+export declare function useCanvasSetup(setupFn: ((api: CanvasToolApi) => void | Promise<void>) | undefined, opts: {
+    getToolApi: () => CanvasToolApi;
+    resetBaseline: () => void;
+}): void;

package/dist/runtime/components/Canvas/composables/useCanvasSetup.js

@@ -0,0 +1,19 @@
+import { onMounted } from "vue";
+export function useCanvasSetup(setupFn, opts) {
+  onMounted(() => {
+    if (!setupFn) return;
+    const api = opts.getToolApi();
+    const done = () => {
+      opts.resetBaseline();
+      requestAnimationFrame(() => api.requestRender());
+    };
+    const result = setupFn(api);
+    if (result && typeof result.then === "function") {
+      result.then(done, (err) => {
+        console.error("[Canvas] setup() rejected:", err);
+      });
+    } else {
+      done();
+    }
+  });
+}

package/dist/runtime/components/Canvas/context.d.ts

@@ -0,0 +1,38 @@
+import { type ComputedRef, type InjectionKey, type Ref } from "vue";
+import type { CanvasNode, CanvasTool, CanvasToolApi } from "./types.js";
+export interface CanvasContext {
+    tools: Ref<CanvasTool[]>;
+    activeToolId: Ref<string | null>;
+    setActiveTool: (id: string | null) => void;
+    nodes: Ref<CanvasNode[]>;
+    addNode: CanvasToolApi["addNode"];
+    updateNode: CanvasToolApi["updateNode"];
+    removeNode: CanvasToolApi["removeNode"];
+    getNode: CanvasToolApi["getNode"];
+    clear: CanvasToolApi["clear"];
+    requestRender: () => void;
+    /** Stage installs its render function through this. */
+    installRenderer: (fn: () => void) => void;
+    getToolOptions: <T extends Record<string, unknown>>(id: string) => T;
+    getToolApi: <T extends Record<string, unknown>>(id: string) => CanvasToolApi<T>;
+    stageEl: Ref<HTMLElement | null>;
+    size: Ref<{
+        width: number;
+        height: number;
+    }>;
+    /** Reactive cursor override. `null` falls back to the active tool's cursor. */
+    cursorOverride: Ref<string | null>;
+    setCursor: (cursor: string | null) => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    /** Mark the start of a user interaction (pointer down). */
+    beginAction: () => void;
+    /** Mark the end of a user interaction (pointer up) — records one undo step. */
+    endAction: () => void;
+    /** Keyboard handler for undo/redo shortcuts. Attach to the stage element. */
+    onKeyDown: (e: KeyboardEvent) => void;
+}
+export declare const CANVAS_CONTEXT: InjectionKey<CanvasContext>;
+export declare function useCanvasContext(): CanvasContext;

package/dist/runtime/components/Canvas/context.js

@@ -0,0 +1,11 @@
+import { inject } from "vue";
+export const CANVAS_CONTEXT = Symbol("OrioCanvas");
+export function useCanvasContext() {
+  const ctx = inject(CANVAS_CONTEXT);
+  if (!ctx) {
+    throw new Error(
+      "useCanvasContext() must be used inside <orio-canvas>. Did you forget to wrap the component?"
+    );
+  }
+  return ctx;
+}

package/dist/runtime/components/Canvas/index.d.vue.ts

@@ -0,0 +1,77 @@
+import type { CanvasNode, CanvasTool, CanvasToolApi } from "./types.js";
+export interface CanvasProps {
+    /**
+     * Unique name for this canvas instance. Required so detached toolbars and
+     * other UI can bind to this canvas via the `canvas` prop, e.g.
+     * `<orio-canvas-toolbar canvas="editor" />` rendered anywhere in the app.
+     */
+    name: string;
+    /** Tools available to the canvas. Empty by default — specify all tools explicitly. */
+    tools?: CanvasTool[];
+    /** Drawing surface width in CSS pixels. */
+    width?: number;
+    /** Drawing surface height in CSS pixels. */
+    height?: number;
+    /** Initial active tool id. Defaults to the first tool. */
+    defaultTool?: string;
+    /** CSS background applied to the stage wrapper. */
+    background?: string;
+    /** Maximum undo history depth. */
+    maxHistory?: number;
+    /**
+     * Called once on mount with the full tool API. Use it to seed the canvas
+     * with initial nodes (images, text, shapes). Nodes added here can be
+     * `frozen: true` to lock them from user interaction.
+     *
+     * The toolbar controls what the *user* can do — setup can add any node
+     * type regardless of which tools are registered.
+     */
+    setup?: (api: CanvasToolApi) => void | Promise<void>;
+}
+type __VLS_Props = CanvasProps;
+declare function getToolOptions<T extends Record<string, unknown>>(id: string): T;
+declare function setActiveTool(id: string | null): void;
+type __VLS_ModelProps = {
+    "nodes"?: CanvasNode[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    activeTool: import("vue").ComputedRef<any>;
+    setActiveTool: typeof setActiveTool;
+    addNode: (node: Omit<CanvasNode, "id"> & {
+        id?: string;
+    }) => CanvasNode;
+    updateNode: (id: string, patch: Partial<Omit<CanvasNode, "id">>) => void;
+    removeNode: (id: string) => void;
+    clear: () => void;
+    nodes: import("vue").ModelRef<CanvasNode<unknown>[], string, CanvasNode<unknown>[], CanvasNode<unknown>[]>;
+    getToolOptions: typeof getToolOptions;
+    undo: () => void;
+    redo: () => void;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:nodes": (value: CanvasNode<unknown>[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:nodes"?: ((value: CanvasNode<unknown>[]) => any) | undefined;
+}>, {
+    setup: (api: CanvasToolApi) => void | Promise<void>;
+    width: number;
+    height: number;
+    tools: CanvasTool[];
+    defaultTool: string;
+    background: string;
+    maxHistory: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Canvas/index.vue

@@ -0,0 +1,208 @@
+<script setup>
+import {
+  computed,
+  onBeforeUnmount,
+  provide,
+  reactive,
+  ref,
+  shallowRef,
+  watch
+} from "vue";
+import { CANVAS_CONTEXT } from "./context";
+import { canvasRegistry } from "./registry";
+import { useCanvasHistory } from "./composables/useCanvasHistory";
+import { useCanvasNodes } from "./composables/useCanvasNodes";
+import { useCanvasSetup } from "./composables/useCanvasSetup";
+import Stage from "./components/Stage.vue";
+import Toolbar from "./components/Toolbar.vue";
+const props = defineProps({
+  name: { type: String, required: true },
+  tools: { type: Array, required: false, default: () => [] },
+  width: { type: Number, required: false, default: 800 },
+  height: { type: Number, required: false, default: 500 },
+  defaultTool: { type: String, required: false, default: void 0 },
+  background: { type: String, required: false, default: "transparent" },
+  maxHistory: { type: Number, required: false, default: 50 },
+  setup: { type: Function, required: false, default: void 0 }
+});
+const nodes = defineModel("nodes", { type: Array, ...{ default: () => [] } });
+const toolsRef = computed(() => props.tools);
+const size = computed(() => ({ width: props.width, height: props.height }));
+const stageEl = ref(null);
+const cursorOverride = ref(null);
+function setCursor(cursor) {
+  cursorOverride.value = cursor;
+}
+const activeToolId = ref(
+  props.defaultTool ?? props.tools.find((t) => !t.kind || t.kind === "interaction")?.id ?? null
+);
+const toolOptionsMap = reactive({});
+watch(
+  toolsRef,
+  (list) => {
+    for (const t of list) {
+      if (!toolOptionsMap[t.id]) {
+        toolOptionsMap[t.id] = reactive({ ...t.defaultOptions ?? {} });
+      }
+    }
+  },
+  { immediate: true }
+);
+function getToolOptions(id) {
+  if (!toolOptionsMap[id]) toolOptionsMap[id] = reactive({});
+  return toolOptionsMap[id];
+}
+const rendererFn = shallowRef(() => {
+});
+function requestRender() {
+  rendererFn.value();
+}
+function installRenderer(fn) {
+  rendererFn.value = fn;
+}
+const {
+  undo,
+  redo,
+  canUndo,
+  canRedo,
+  autoCommit,
+  beginAction,
+  endAction,
+  resetBaseline,
+  onKeyDown
+} = useCanvasHistory(nodes, {
+  maxHistory: () => props.maxHistory,
+  requestRender
+});
+const { addNode, updateNode, getNode, removeNode, clear } = useCanvasNodes(
+  nodes,
+  { onMutate: autoCommit }
+);
+const toolApiCache = /* @__PURE__ */ new Map();
+function getToolApi(id) {
+  let api = toolApiCache.get(id);
+  if (!api) {
+    api = {
+      options: getToolOptions(id),
+      nodes,
+      addNode,
+      updateNode,
+      removeNode,
+      getNode,
+      clear,
+      requestRender,
+      stageEl: () => stageEl.value,
+      size: () => ({ width: props.width, height: props.height }),
+      undo,
+      redo,
+      canUndo,
+      canRedo,
+      getToolOptions,
+      getTools: () => props.tools,
+      setCursor
+    };
+    toolApiCache.set(id, api);
+  }
+  return api;
+}
+function setActiveTool(id) {
+  if (id === activeToolId.value) return;
+  const prev = props.tools.find((t) => t.id === activeToolId.value);
+  prev?.onDeactivate?.(getToolApi(prev.id));
+  cursorOverride.value = null;
+  activeToolId.value = id;
+  const next = id ? props.tools.find((t) => t.id === id) : null;
+  next?.onActivate?.(getToolApi(next.id));
+}
+function handleKeyDown(e) {
+  const tool = props.tools.find((t) => t.id === activeToolId.value);
+  if (tool?.onKeyDown) {
+    tool.onKeyDown(e, getToolApi(tool.id));
+    if (e.defaultPrevented) return;
+  }
+  onKeyDown(e);
+}
+const context = {
+  tools: toolsRef,
+  activeToolId,
+  setActiveTool,
+  nodes,
+  addNode,
+  updateNode,
+  removeNode,
+  getNode,
+  clear,
+  requestRender,
+  installRenderer,
+  getToolOptions,
+  getToolApi,
+  stageEl,
+  size,
+  undo,
+  redo,
+  canUndo,
+  canRedo,
+  beginAction,
+  endAction,
+  onKeyDown: handleKeyDown,
+  cursorOverride,
+  setCursor
+};
+provide(CANVAS_CONTEXT, context);
+let registeredName = null;
+watch(
+  () => props.name,
+  (newName, oldName) => {
+    if (oldName && canvasRegistry.get(oldName) === context) {
+      canvasRegistry.delete(oldName);
+    }
+    if (import.meta.env.DEV && canvasRegistry.has(newName)) {
+      console.warn(
+        `[orio-canvas] duplicate canvas name "${newName}" \u2014 detached toolbars bound to this name will resolve to the most recently mounted canvas.`
+      );
+    }
+    canvasRegistry.set(newName, context);
+    registeredName = newName;
+  },
+  { immediate: true }
+);
+onBeforeUnmount(() => {
+  if (registeredName && canvasRegistry.get(registeredName) === context) {
+    canvasRegistry.delete(registeredName);
+  }
+});
+useCanvasSetup(props.setup, {
+  getToolApi: () => getToolApi("__setup__"),
+  resetBaseline
+});
+const activeTool = computed(
+  () => props.tools.find((t) => t.id === activeToolId.value) ?? null
+);
+defineExpose({
+  activeTool,
+  setActiveTool,
+  addNode,
+  updateNode,
+  removeNode,
+  clear,
+  nodes,
+  getToolOptions,
+  undo,
+  redo,
+  canUndo,
+  canRedo
+});
+</script>
+
+<template>
+  <div class="canvas-root" :style="{ background }">
+    <slot>
+      <Toolbar :canvas="name" />
+      <Stage />
+    </slot>
+  </div>
+</template>
+
+<style scoped>
+.canvas-root{display:flex;flex-direction:column;gap:.5rem;width:-moz-fit-content;width:fit-content}
+</style>

package/dist/runtime/components/Canvas/index.vue.d.ts

@@ -0,0 +1,77 @@
+import type { CanvasNode, CanvasTool, CanvasToolApi } from "./types.js";
+export interface CanvasProps {
+    /**
+     * Unique name for this canvas instance. Required so detached toolbars and
+     * other UI can bind to this canvas via the `canvas` prop, e.g.
+     * `<orio-canvas-toolbar canvas="editor" />` rendered anywhere in the app.
+     */
+    name: string;
+    /** Tools available to the canvas. Empty by default — specify all tools explicitly. */
+    tools?: CanvasTool[];
+    /** Drawing surface width in CSS pixels. */
+    width?: number;
+    /** Drawing surface height in CSS pixels. */
+    height?: number;
+    /** Initial active tool id. Defaults to the first tool. */
+    defaultTool?: string;
+    /** CSS background applied to the stage wrapper. */
+    background?: string;
+    /** Maximum undo history depth. */
+    maxHistory?: number;
+    /**
+     * Called once on mount with the full tool API. Use it to seed the canvas
+     * with initial nodes (images, text, shapes). Nodes added here can be
+     * `frozen: true` to lock them from user interaction.
+     *
+     * The toolbar controls what the *user* can do — setup can add any node
+     * type regardless of which tools are registered.
+     */
+    setup?: (api: CanvasToolApi) => void | Promise<void>;
+}
+type __VLS_Props = CanvasProps;
+declare function getToolOptions<T extends Record<string, unknown>>(id: string): T;
+declare function setActiveTool(id: string | null): void;
+type __VLS_ModelProps = {
+    "nodes"?: CanvasNode[];
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    activeTool: import("vue").ComputedRef<any>;
+    setActiveTool: typeof setActiveTool;
+    addNode: (node: Omit<CanvasNode, "id"> & {
+        id?: string;
+    }) => CanvasNode;
+    updateNode: (id: string, patch: Partial<Omit<CanvasNode, "id">>) => void;
+    removeNode: (id: string) => void;
+    clear: () => void;
+    nodes: import("vue").ModelRef<CanvasNode<unknown>[], string, CanvasNode<unknown>[], CanvasNode<unknown>[]>;
+    getToolOptions: typeof getToolOptions;
+    undo: () => void;
+    redo: () => void;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:nodes": (value: CanvasNode<unknown>[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:nodes"?: ((value: CanvasNode<unknown>[]) => any) | undefined;
+}>, {
+    setup: (api: CanvasToolApi) => void | Promise<void>;
+    width: number;
+    height: number;
+    tools: CanvasTool[];
+    defaultTool: string;
+    background: string;
+    maxHistory: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/Canvas/registry.d.ts

@@ -0,0 +1 @@
+export declare const canvasRegistry: any;

package/dist/runtime/components/Canvas/registry.js

@@ -0,0 +1,2 @@
+import { shallowReactive } from "vue";
+export const canvasRegistry = shallowReactive(/* @__PURE__ */ new Map());