@revenexx/editor 0.1.0

package/dist/runtime/editor/components/AddListItem/index.d.vue.ts

@@ -0,0 +1,31 @@
+import type { BlokkliIcon } from '#blokkli-build/icons';
+export type AddListItemProps = {
+    id: string;
+    context: string;
+    label: string;
+    description?: string;
+    color?: 'rose' | 'lime' | 'default' | 'yellow' | 'accent' | 'orange';
+    bundle?: string;
+    icon?: BlokkliIcon;
+    disabled?: boolean;
+    isAutoAdd?: boolean;
+    noContextMenu?: boolean;
+    useHelp?: boolean;
+    helpActive?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<AddListItemProps, {
+    getElement: () => HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    help: (d: HTMLElement) => void;
+    startHelp: (d: HTMLElement) => void;
+}, string, import("vue").PublicProps, Readonly<AddListItemProps> & Readonly<{
+    onHelp?: ((d: HTMLElement) => any) | undefined;
+    onStartHelp?: ((d: HTMLElement) => any) | undefined;
+}>, {
+    bundle: string;
+    description: string;
+    icon: BlokkliIcon;
+    color: "rose" | "lime" | "default" | "yellow" | "accent" | "orange";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/components/AddListItem/index.vue

@@ -0,0 +1,103 @@
+<template>
+  <PluginContextMenu
+    :id="'add_list_item_' + context + id"
+    ref="pluginContextMenu"
+    tag="button"
+    type="button"
+    class="bk-add-item"
+    :menu="menu"
+    :data-sortli-id="id"
+    :class="[
+  {
+    'bk-is-disabled': disabled
+  },
+  'bk-is-' + color
+]"
+    @mouseenter="onMouseEnter"
+    @mouseleave="onMouseLeave"
+  >
+    <div class="bk-add-item-icon">
+      <ItemIconBox :color :bundle :icon />
+    </div>
+    <div class="bk-add-item-label">
+      <span>{{ label }}{{ isAutoAdd ? "" : "..." }}</span>
+    </div>
+  </PluginContextMenu>
+</template>
+
+<script setup>
+import { useBlokkli, computed, useTemplateRef } from "#imports";
+import { ItemIconBox } from "#blokkli/editor/components";
+import { PluginContextMenu } from "#blokkli/editor/plugins";
+const { storage, $t } = useBlokkli();
+const emit = defineEmits(["help", "startHelp"]);
+const props = defineProps({
+  id: { type: String, required: true },
+  context: { type: String, required: true },
+  label: { type: String, required: true },
+  description: { type: String, required: false, default: "" },
+  color: { type: String, required: false, default: "default" },
+  bundle: { type: String, required: false, default: "" },
+  icon: { type: null, required: false, default: void 0 },
+  disabled: { type: Boolean, required: false },
+  isAutoAdd: { type: Boolean, required: false },
+  noContextMenu: { type: Boolean, required: false },
+  useHelp: { type: Boolean, required: false },
+  helpActive: { type: Boolean, required: false }
+});
+const el = useTemplateRef("pluginContextMenu");
+const favorites = storage.use("blockFavorites", []);
+const isFavorite = computed(() => favorites.value.includes(props.id));
+const toggleFavorite = () => {
+  if (favorites.value.includes(props.id)) {
+    favorites.value = favorites.value.filter((v) => v !== props.id);
+  } else {
+    favorites.value = [...favorites.value, props.id];
+  }
+};
+const menu = computed(() => {
+  if (props.noContextMenu) {
+    return [];
+  }
+  return [
+    {
+      type: "button",
+      label: isFavorite.value ? $t("addListItemFavoriteRemove", "Remove from favorites") : $t("addListItemFavoriteAdd", "Add to favorites"),
+      icon: isFavorite.value ? "unstar" : "star",
+      callback: toggleFavorite
+    }
+  ];
+});
+const getElement = () => el.value?.$el;
+let helpTimeout = null;
+function onMouseEnter() {
+  if (!props.useHelp) {
+    return;
+  }
+  if (helpTimeout) {
+    window.clearTimeout(helpTimeout);
+    helpTimeout = null;
+  }
+  if (props.helpActive) {
+    const element = getElement();
+    if (!element) {
+      return;
+    }
+    emit("help", element);
+  }
+  helpTimeout = window.setTimeout(() => {
+    const element = getElement();
+    if (!element) {
+      return;
+    }
+    emit("startHelp", element);
+  }, 800);
+}
+function onMouseLeave() {
+  if (helpTimeout) {
+    window.clearTimeout(helpTimeout);
+    helpTimeout = null;
+  }
+}
+defineExpose({ getElement });
+</script>

package/dist/runtime/editor/components/AddListItem/index.vue.d.ts

@@ -0,0 +1,31 @@
+import type { BlokkliIcon } from '#blokkli-build/icons';
+export type AddListItemProps = {
+    id: string;
+    context: string;
+    label: string;
+    description?: string;
+    color?: 'rose' | 'lime' | 'default' | 'yellow' | 'accent' | 'orange';
+    bundle?: string;
+    icon?: BlokkliIcon;
+    disabled?: boolean;
+    isAutoAdd?: boolean;
+    noContextMenu?: boolean;
+    useHelp?: boolean;
+    helpActive?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<AddListItemProps, {
+    getElement: () => HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    help: (d: HTMLElement) => void;
+    startHelp: (d: HTMLElement) => void;
+}, string, import("vue").PublicProps, Readonly<AddListItemProps> & Readonly<{
+    onHelp?: ((d: HTMLElement) => any) | undefined;
+    onStartHelp?: ((d: HTMLElement) => any) | undefined;
+}>, {
+    bundle: string;
+    description: string;
+    icon: BlokkliIcon;
+    color: "rose" | "lime" | "default" | "yellow" | "accent" | "orange";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/components/AnimationCanvas/index.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/components/AnimationCanvas/index.vue

@@ -0,0 +1,534 @@
+<template>
+  <Teleport to="#bk-canvas-overlay">
+    <canvas
+      id="bk-animation-canvas-webgl"
+      :key="animation.canvasKey.value"
+      ref="canvasEl"
+      class="_bk_fixed _bk_top-0 _bk_left-0 _bk_size-full _bk_z-animation-canvas _bk_contain-strict"
+      tabindex="0"
+      :style
+      @click.capture="onClick"
+      @pointerdown.capture="onPointerDown"
+      @pointerup.capture="onPointerUp"
+      @pointermove="onPointerMove"
+      @focus="onCanvasFocus"
+      @blur="onCanvasBlur"
+    />
+  </Teleport>
+</template>
+
+<script setup>
+import { falsy } from "#blokkli/helpers";
+import { getDistance, isInsideRect } from "#blokkli/editor/helpers/geometry";
+import {
+  MOUSE_BUTTON,
+  MOUSE_BUTTONS,
+  getInteractionCoordinates
+} from "#blokkli/editor/helpers/dom";
+import {
+  ref,
+  computed,
+  useBlokkli,
+  watch,
+  useTemplateRef,
+  onBeforeUnmount
+} from "#imports";
+import { itemEntityType } from "#blokkli-build/config";
+import { onBlokkliEvent } from "#blokkli/editor/composables";
+import { toDraggableExisting } from "#blokkli/editor/helpers/draggable";
+const {
+  dom,
+  eventBus,
+  selection,
+  keyboard,
+  ui,
+  animation,
+  state,
+  directive,
+  blocks,
+  fields,
+  permissions,
+  types
+} = useBlokkli();
+function onCanvasFocus() {
+  ui.setCanvasFocused(true);
+}
+function onCanvasBlur() {
+  ui.setCanvasFocused(false);
+}
+let handlePointerMove = false;
+const cursor = computed(
+  () => state.isLoading.value ? "wait" : animation.cursor.value
+);
+const style = computed(() => {
+  return {
+    imageRendering: "pixelated",
+    cursor: cursor.value,
+    pointerEvents: ui.isApproving.value ? "none" : "auto"
+  };
+});
+const rects = ref([]);
+function buildRects() {
+  const visible = dom.getVisibleBlocks();
+  rects.value = visible.map((uuid) => {
+    const rect = dom.getBlockRect(uuid);
+    if (!rect) {
+      return;
+    }
+    return { uuid, rect };
+  }).filter(falsy);
+}
+watch(dom.isReady, buildRects);
+let lastInteractedElement = null;
+let pointerDownElement = null;
+let mouseStartCoordinates = null;
+let pointerDownTimestamp = 0;
+let pointerUpTimestamp = 0;
+let pointerDownOnCanvas = false;
+function getInteractedElement(e) {
+  const { x, y } = getInteractionCoordinates(e);
+  const visibleUuids = dom.getVisibleBlocks();
+  let deepestUuid = "";
+  let deepestLevel = -1;
+  for (let i = 0; i < visibleUuids.length; i++) {
+    const uuid = visibleUuids[i];
+    if (!uuid) {
+      continue;
+    }
+    const rect = dom.getBlockRect(uuid);
+    if (!rect) {
+      continue;
+    }
+    const level = state.getNestingLevel(uuid);
+    if (level < deepestLevel) {
+      continue;
+    }
+    const relativeRect = ui.getViewportRelativeRect(rect);
+    if (!isInsideRect(x, y, relativeRect)) {
+      continue;
+    }
+    if (level > deepestLevel) {
+      deepestUuid = uuid;
+      deepestLevel = level;
+    } else if (fields.compareFieldPriority(uuid, deepestUuid) > 0) {
+      deepestUuid = uuid;
+    }
+  }
+  const skipFields = keyboard.isPressingControl.value;
+  const editableField = skipFields ? null : directive.getEditableAtPoint(x, y);
+  if (editableField) {
+    const editableUuid = editableField.type === itemEntityType ? editableField.uuid : void 0;
+    const canEdit = !editableUuid || permissions.checkBlockBundlePermission(editableField.bundle, "edit") && !permissions.blockHasRestrictedAncestor(editableUuid);
+    if (canEdit && (!editableUuid || editableUuid === deepestUuid)) {
+      return {
+        editableFieldName: editableField.fieldName,
+        uuid: editableUuid,
+        timestamp: Date.now(),
+        x,
+        y
+      };
+    }
+  }
+  const droppableField = skipFields ? null : directive.getDroppableAtPoint(x, y);
+  if (droppableField) {
+    const config = types.getDroppableFieldConfig(
+      droppableField.fieldName,
+      droppableField
+    );
+    if (config.type === "reference" && config.cardinality !== 1) {
+      const droppableUuid = droppableField.type === itemEntityType ? droppableField.uuid : void 0;
+      if (!droppableUuid || droppableUuid === deepestUuid) {
+        return {
+          droppableFieldName: droppableField.fieldName,
+          droppableEntityType: droppableField.type,
+          droppableEntityUuid: droppableField.uuid,
+          uuid: droppableUuid,
+          timestamp: Date.now(),
+          x,
+          y
+        };
+      }
+    }
+  }
+  if (deepestUuid) {
+    const restrictedAncestor = permissions.getRestrictedAncestor(deepestUuid);
+    return {
+      uuid: restrictedAncestor ?? deepestUuid,
+      timestamp: Date.now(),
+      x,
+      y
+    };
+  }
+  return null;
+}
+function onPointerMove(e) {
+  if (!handlePointerMove) {
+    return;
+  }
+  if (ui.isApproving.value) {
+    return;
+  }
+  if (keyboard.isPressingSpace.value || e.buttons & MOUSE_BUTTONS.AUXILIARY) {
+    return;
+  }
+  e.preventDefault();
+  e.stopPropagation();
+  e.stopImmediatePropagation();
+  if (e.pointerType === "touch") {
+    return onTouchMove(e);
+  }
+  if (e.buttons !== MOUSE_BUTTONS.PRIMARY) {
+    return;
+  }
+  if (!mouseStartCoordinates || selection.isMultiSelecting.value || selection.isDragging.value || keyboard.isPressingSpace.value) {
+    return;
+  }
+  const diffX = Math.abs(mouseStartCoordinates.x - e.clientX);
+  const diffY = Math.abs(mouseStartCoordinates.y - e.clientY);
+  if (!pointerDownElement) {
+    const timeDelta = Date.now() - pointerDownTimestamp;
+    const maxMovement = Math.max(diffX, diffY);
+    if (maxMovement > 6 && timeDelta > 150 || maxMovement > 20) {
+      canvasEl.value?.removeEventListener("pointermove", onPointerMove);
+      eventBus.emit("multi-select:start", {
+        x: e.clientX,
+        y: e.clientY
+      });
+    }
+    return;
+  }
+  if (state.editMode.value !== "editing") {
+    return;
+  }
+  if (diffX < 6 && diffY < 6) {
+    return;
+  }
+  const interacted = getInteractedElement(e);
+  if (interacted && interacted.uuid) {
+    if (selection.uuids.value.includes(interacted.uuid)) {
+      eventBus.emit("dragging:start", {
+        items: toDraggableExisting(selection.items.value),
+        coords: { x: e.clientX, y: e.clientY },
+        mode: "mouse"
+      });
+    } else {
+      const block = blocks.getBlock(interacted.uuid);
+      if (block) {
+        eventBus.emit("dragging:start", {
+          items: toDraggableExisting(block),
+          coords: { x: e.clientX, y: e.clientY },
+          mode: "mouse"
+        });
+      }
+    }
+    canvasEl.value?.removeEventListener("pointermove", onPointerMove);
+  }
+}
+function onPointerDown(e) {
+  if (e.buttons & MOUSE_BUTTONS.AUXILIARY) {
+    return;
+  }
+  if (ui.isApproving.value) {
+    return;
+  }
+  pointerDownOnCanvas = true;
+  if (canvasEl.value) {
+    canvasEl.value.focus();
+  }
+  if (!keyboard.isPressingSpace.value) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.stopImmediatePropagation();
+  }
+  keyboard.setShortcutStateFromEvent(e);
+  canvasEl.value?.removeEventListener("pointermove", onPointerMove);
+  if (selection.activeFieldLabel.value) {
+    return;
+  }
+  if (ui.openTooltip.value) {
+    return;
+  }
+  if (state.isLoading.value) {
+    return;
+  }
+  handlePointerMove = true;
+  if (e.pointerType === "touch") {
+    return onTouchStart(e);
+  }
+  if (selection.isDragging.value) {
+    return;
+  }
+  pointerDownTimestamp = Date.now();
+  const coords = { x: e.clientX, y: e.clientY };
+  mouseStartCoordinates = coords;
+  if (!e.shiftKey && e.buttons === MOUSE_BUTTONS.PRIMARY) {
+    const interacted = getInteractedElement(e);
+    pointerDownElement = interacted;
+    if (interacted) {
+      return;
+    }
+  }
+  eventBus.emit("mouse:down", { ...coords, type: "mouse", distance: 0 });
+}
+function isClickInArtboard(coords) {
+  const size = ui.artboardSize.value;
+  const scale = ui.artboardScale.value;
+  const rect = {
+    x: ui.artboardOffset.value.x,
+    y: ui.artboardOffset.value.y,
+    width: size.width * scale,
+    height: size.height * scale
+  };
+  return isInsideRect(coords.x, coords.y, rect);
+}
+function onPointerUp(e) {
+  if (e.button === MOUSE_BUTTON.AUXILIARY) {
+    e.preventDefault();
+    return;
+  }
+  if (ui.isApproving.value) {
+    return;
+  }
+  handlePointerMove = false;
+  e.preventDefault();
+  e.stopPropagation();
+  e.stopImmediatePropagation();
+  if (ui.openTooltip.value && !selection.activeFieldLabel.value) {
+    ui.openTooltip.value = "";
+    return;
+  }
+  const wasDragging = selection.isDragging.value;
+  const wasMultiSelecting = selection.isMultiSelecting.value;
+  pointerDownElement = null;
+  if (state.isLoading.value) {
+    return;
+  }
+  if (e.pointerType === "touch") {
+    return onTouchEnd(e);
+  }
+  const coords = getInteractionCoordinates(e);
+  const distance = mouseStartCoordinates ? getDistance(mouseStartCoordinates, coords) : 0;
+  eventBus.emit("mouse:up", {
+    x: e.clientX,
+    y: e.clientY,
+    type: "mouse",
+    distance,
+    duration: Date.now() - pointerDownTimestamp
+  });
+  if (wasDragging || wasMultiSelecting) {
+    eventBus.emit("dragging:end");
+    return;
+  }
+  if (keyboard.isPressingSpace.value) {
+    return;
+  }
+  if (selection.activeFieldLabel.value) {
+    if (pointerDownOnCanvas) {
+      eventBus.emit("window:clickAway");
+      lastInteractedElement = null;
+    }
+    pointerDownOnCanvas = false;
+    return;
+  }
+  if (animation.handleClick(e.clientX, e.clientY)) {
+    return;
+  }
+  const clicked = getInteractedElement(e);
+  if (clicked && pointerUpTimestamp && lastInteractedElement && (clicked.uuid === lastInteractedElement.uuid || clicked.editableFieldName === lastInteractedElement.editableFieldName || clicked.droppableFieldName === lastInteractedElement.droppableFieldName)) {
+    const deltaTime = Date.now() - pointerUpTimestamp;
+    const deltaX = Math.abs(lastInteractedElement.x - e.clientX);
+    const deltaY = Math.abs(lastInteractedElement.y - e.clientY);
+    if (deltaTime < 400 && deltaX < 3 && deltaY < 3) {
+      if (clicked.editableFieldName) {
+        pointerDownOnCanvas = false;
+        eventBus.emit("editable:open", {
+          fieldName: clicked.editableFieldName,
+          uuid: clicked.uuid
+        });
+        return;
+      }
+      if (clicked.droppableFieldName && clicked.droppableEntityUuid && clicked.droppableEntityType) {
+        pointerDownOnCanvas = false;
+        eventBus.emit("droppable:open", {
+          fieldName: clicked.droppableFieldName,
+          uuid: clicked.droppableEntityUuid,
+          entityType: clicked.droppableEntityType
+        });
+        return;
+      }
+      if (lastInteractedElement.uuid) {
+        const block = blocks.getBlock(lastInteractedElement.uuid);
+        if (!block) {
+          return;
+        }
+        ui.flushPendingChanges().then(
+          () => eventBus.emit("item:doubleClick", block)
+        );
+      }
+    }
+  }
+  lastInteractedElement = clicked;
+  pointerUpTimestamp = Date.now();
+  if (clicked?.uuid) {
+    dom.refreshBlockRect(clicked.uuid);
+    if (keyboard.isPressingControl.value || selection.isMultiSelecting.value) {
+      eventBus.emit("select:toggle", clicked.uuid);
+    } else if (keyboard.isPressingShift.value) {
+      eventBus.emit("select:shiftToggle", clicked.uuid);
+    } else {
+      eventBus.emit("select", clicked.uuid);
+    }
+    return;
+  }
+  eventBus.emit("window:clickAway");
+  if (isClickInArtboard(coords)) {
+    eventBus.emit("select:host");
+  } else {
+    eventBus.emit("select:host:unselect");
+  }
+}
+let longPressTimeout = null;
+let touchStartInteraction = null;
+let touchStartCoords = null;
+let longPressInteraction = null;
+let touchStartTimestamp = 0;
+function onTouchStart(e) {
+  if (e.isPrimary) {
+    touchStartTimestamp = Date.now();
+  }
+  longPressInteraction = null;
+  const coords = getInteractionCoordinates(e);
+  touchStartCoords = coords;
+  eventBus.emit("mouse:down", { ...coords, type: "touch", distance: 0 });
+  if (ui.openTooltip.value) {
+    return;
+  }
+  if (selection.isDragging.value) {
+    return;
+  }
+  clearTimeout(longPressTimeout);
+  const interacted = getInteractedElement(e);
+  if (!interacted?.uuid) {
+    return;
+  }
+  touchStartInteraction = interacted;
+  longPressTimeout = setTimeout(() => {
+    if (touchStartInteraction?.uuid) {
+      longPressInteraction = touchStartInteraction;
+      if (selection.uuids.value.includes(touchStartInteraction.uuid) && state.editMode.value === "editing") {
+        eventBus.emit("dragging:start", {
+          items: toDraggableExisting(selection.items.value),
+          coords: {
+            x: touchStartInteraction.x,
+            y: touchStartInteraction.y
+          },
+          mode: "touch"
+        });
+        return;
+      }
+      eventBus.emit("select:start", {
+        uuids: [...selection.uuids.value, touchStartInteraction.uuid],
+        mode: "touch"
+      });
+    }
+  }, 500);
+}
+function onTouchMove(e) {
+  if (!longPressTimeout || !touchStartInteraction) {
+    return;
+  }
+  const coords = getInteractionCoordinates(e);
+  const deltaX = Math.abs(coords.x - touchStartInteraction.x);
+  const deltaY = Math.abs(coords.y - touchStartInteraction.y);
+  if (deltaX > 10 || deltaY > 10) {
+    clearTimeout(longPressTimeout);
+    longPressTimeout = null;
+  }
+}
+function onTouchEnd(e) {
+  const wasDragging = selection.isDragging.value;
+  const coords = getInteractionCoordinates(e);
+  const distance = touchStartCoords ? getDistance(touchStartCoords, coords) : 0;
+  if (e.isPrimary) {
+    eventBus.emit("mouse:up", {
+      ...coords,
+      type: "touch",
+      distance,
+      duration: Date.now() - touchStartTimestamp
+    });
+  }
+  clearTimeout(longPressTimeout);
+  longPressTimeout = null;
+  if (ui.openTooltip.value) {
+    ui.openTooltip.value = "";
+    return;
+  }
+  if (wasDragging) {
+    return;
+  }
+  if (!touchStartCoords) {
+    return;
+  }
+  if (distance > 7) {
+    return;
+  }
+  if (animation.handleClick(coords.x, coords.y)) {
+    return;
+  }
+  const interacted = getInteractedElement(e);
+  if (interacted?.uuid) {
+    if (longPressInteraction && longPressInteraction.uuid === interacted.uuid) {
+      return;
+    }
+    if (selection.isMultiSelecting.value) {
+      eventBus.emit("select:toggle", interacted.uuid);
+    } else {
+      eventBus.emit("select", interacted.uuid);
+    }
+  } else {
+    eventBus.emit("window:clickAway");
+  }
+  longPressInteraction = null;
+}
+onBlokkliEvent("dragging:start", (e) => {
+  mouseStartCoordinates = e.coords;
+});
+function onClick(e) {
+  e.preventDefault();
+  e.stopImmediatePropagation();
+  e.stopPropagation();
+  if (ui.isApproving.value) {
+    const { x, y } = getInteractionCoordinates(e);
+    const editableField = directive.getEditableAtPoint(x, y);
+    if (editableField) {
+      eventBus.emit("editable:focus", {
+        fieldName: editableField.fieldName,
+        uuid: editableField.type === itemEntityType ? editableField.uuid : void 0
+      });
+    }
+    return;
+  }
+  if (canvasEl.value && !selection.activeFieldLabel.value && !ui.hasTooltipOpen.value) {
+    canvasEl.value.focus();
+  }
+}
+const canvasEl = useTemplateRef("canvasEl");
+watch(
+  canvasEl,
+  (newCanvas, oldCanvas) => {
+    if (oldCanvas) {
+      handlePointerMove = false;
+      animation.removeCanvasElement();
+    }
+    if (newCanvas) {
+      animation.setCanvasElement(newCanvas);
+      animation.requestDraw();
+    }
+  },
+  { immediate: true }
+);
+onBeforeUnmount(() => {
+  animation.removeCanvasElement();
+  handlePointerMove = false;
+});
+</script>

package/dist/runtime/editor/components/AnimationCanvas/index.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;