@blokkli/editor 2.0.0-alpha.5 → 2.0.0-alpha.51

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

@@ -0,0 +1,70 @@
+<template>
+  <div ref="rootEl" class="bk-scale-to-fit" :style="style">
+    <div ref="wrapper" class="bk-scale-to-fit-wrapper">
+      <div ref="inner" class="bk-scale-to-fit-wrapper-item" :style="innerStyle">
+        <slot />
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed, useTemplateRef } from "#imports";
+import { useAnimationFrame } from "#blokkli/editor/composables";
+const props = defineProps({
+  width: { type: Number, required: false },
+  maxHeight: { type: Number, required: false }
+});
+const rootEl = useTemplateRef("rootEl");
+const inner = useTemplateRef("inner");
+const wrapper = useTemplateRef("wrapper");
+const rootWidth = ref(260);
+const nativeWidth = ref(0);
+const nativeHeight = ref(0);
+const computedHeight = ref(0);
+const scale = computed(() => {
+  const contentWidth = props.width || nativeWidth.value;
+  const widthScale = Math.min(rootWidth.value, contentWidth) / contentWidth;
+  if (!props.maxHeight) {
+    return widthScale;
+  }
+  const heightScale = props.maxHeight / nativeHeight.value;
+  return Math.min(widthScale, heightScale);
+});
+const style = computed(() => {
+  const height = props.maxHeight ? Math.min(computedHeight.value, props.maxHeight) : computedHeight.value;
+  return {
+    height: height + "px"
+  };
+});
+const innerStyle = computed(() => {
+  const currentScale = scale.value;
+  const contentWidth = props.width || nativeWidth.value;
+  const scaledWidth = contentWidth * currentScale;
+  const scaledHeight = nativeHeight.value * currentScale;
+  const leftOffset = Math.max(0, (rootWidth.value - scaledWidth) / 2);
+  const useVerticalCentering = props.maxHeight && nativeHeight.value * scale.value > props.maxHeight;
+  const topOffset = useVerticalCentering ? (props.maxHeight - scaledHeight) / 2 : 0;
+  return {
+    width: props.width ? props.width + "px" : "auto",
+    transform: `translate(${leftOffset}px, ${topOffset}px) scale(${currentScale})`
+  };
+});
+useAnimationFrame(() => {
+  if (rootEl.value) {
+    rootWidth.value = rootEl.value.offsetWidth;
+  }
+  if (inner.value) {
+    const rect = inner.value.getBoundingClientRect();
+    nativeHeight.value = inner.value.offsetHeight;
+    nativeWidth.value = Math.max(inner.value.offsetWidth, rootWidth.value);
+    computedHeight.value = rect.height;
+  }
+});
+</script>
+
+<script>
+export default {
+  name: "ScaleToFit"
+};
+</script>

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

@@ -0,0 +1,16 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    width?: number;
+    maxHeight?: number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    width?: number;
+    maxHeight?: number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,25 @@
+type __VLS_Props = {
+    disabled?: boolean;
+    error?: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, 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/editor/components/ScheduleDate/index.vue

@@ -0,0 +1,131 @@
+<template>
+  <div class="bk-schedule-date">
+    <div class="bk-schedule-date-picker">
+      <FormDatepicker
+        v-model="selectedDate"
+        :min="minDate"
+        :disabled="disabled"
+        :error="!!error"
+      />
+    </div>
+    <div v-if="selectedDate" class="bk-schedule-date-time">
+      <div v-if="formattedDateTime" class="bk-schedule-date-formatted">
+        {{ formattedDateTime }}
+      </div>
+      <div class="bk-schedule-date-time-input">
+        <input
+          id="schedule-time"
+          v-model="selectedTime"
+          type="time"
+          class="bk-form-input"
+          :disabled="disabled"
+          :class="{
+  'bk-is-invalid': error
+}"
+        />
+        <button
+          type="button"
+          class="bk-button bk-schedule-date-time-button bk-is-icon-only"
+          :disabled="disabled"
+          @click="decrementHour"
+        >
+          <Icon name="bk_mdi_remove" />
+        </button>
+        <button
+          type="button"
+          class="bk-button bk-schedule-date-time-button bk-is-icon-only"
+          :disabled="disabled"
+          @click="incrementHour"
+        >
+          <Icon name="bk_mdi_add" />
+        </button>
+      </div>
+
+      <slot />
+      <div v-if="error" class="bk-schedule-date-error">
+        {{ error }}
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed, watch, useBlokkli } from "#imports";
+import { FormDatepicker, Icon } from "#blokkli/editor/components";
+const { ui } = useBlokkli();
+defineProps({
+  disabled: { type: Boolean, required: false },
+  error: { type: String, required: false }
+});
+const modelValue = defineModel({ type: String });
+const selectedDate = ref("");
+const selectedTime = ref("12:00");
+const formattedDateTime = computed(() => {
+  if (!selectedDate.value || !selectedTime.value) {
+    return "";
+  }
+  const dateTimeString = `${selectedDate.value}T${selectedTime.value}:00`;
+  const date = new Date(dateTimeString);
+  return ui.formatDate(date, {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+});
+if (modelValue.value) {
+  const date = new Date(modelValue.value);
+  selectedDate.value = formatDate(date);
+  selectedTime.value = formatTime(date);
+}
+const minDate = computed(() => {
+  const today = /* @__PURE__ */ new Date();
+  return formatDate(today);
+});
+function formatDate(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function formatTime(date) {
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${hours}:${minutes}`;
+}
+watch([selectedDate, selectedTime], () => {
+  if (!selectedDate.value) {
+    modelValue.value = void 0;
+    return;
+  }
+  const dateTimeString = `${selectedDate.value}T${selectedTime.value}:00`;
+  const date = new Date(dateTimeString);
+  modelValue.value = date.toISOString();
+});
+watch(modelValue, (newValue) => {
+  if (!newValue) {
+    selectedDate.value = "";
+    selectedTime.value = "12:00";
+    return;
+  }
+  const date = new Date(newValue);
+  const newDate = formatDate(date);
+  const newTime = formatTime(date);
+  if (newDate !== selectedDate.value || newTime !== selectedTime.value) {
+    selectedDate.value = newDate;
+    selectedTime.value = newTime;
+  }
+});
+function incrementHour() {
+  const [hours = 0, minutes = 0] = selectedTime.value.split(":").map(Number);
+  const newHours = minutes > 0 ? (hours + 1) % 24 : (hours + 1) % 24;
+  selectedTime.value = `${String(newHours).padStart(2, "0")}:00`;
+}
+function decrementHour() {
+  const [hours = 0, minutes = 0] = selectedTime.value.split(":").map(Number);
+  const newHours = minutes > 0 ? hours : hours === 0 ? 23 : hours - 1;
+  selectedTime.value = `${String(newHours).padStart(2, "0")}:00`;
+}
+</script>

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

@@ -0,0 +1,25 @@
+type __VLS_Props = {
+    disabled?: boolean;
+    error?: string;
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, 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/editor/components/ScrollBoundary/index.d.vue.ts

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    /**
+     * Allow scrolling during dragging.
+     */
+    dragging?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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>;
+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/editor/components/ScrollBoundary/index.vue

@@ -0,0 +1,23 @@
+<template>
+  <div @wheel.passive="onWheel">
+    <slot />
+  </div>
+</template>
+
+<script setup>
+import { useBlokkli } from "#imports";
+const { selection } = useBlokkli();
+const props = defineProps({
+  dragging: { type: Boolean, required: false }
+});
+function onWheel(e) {
+  if (selection.isDragging.value && !props.dragging) {
+    e.preventDefault();
+    return;
+  }
+  if (e.ctrlKey || e.metaKey) {
+    return;
+  }
+  e.stopImmediatePropagation();
+}
+</script>

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

@@ -0,0 +1,19 @@
+type __VLS_Props = {
+    /**
+     * Allow scrolling during dragging.
+     */
+    dragging?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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>;
+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/editor/components/ShortcutIndicator/index.d.vue.ts

@@ -0,0 +1,21 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    group?: string;
+    viewOnly?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    keyCode: string;
+    label?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    pressed: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    group?: string;
+    viewOnly?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    keyCode: string;
+    label?: string;
+}> & Readonly<{
+    onPressed?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,79 @@
+<template>
+  <kbd :title="label" class="bk-shortcut">
+    <template v-if="meta"> <kbd>CTRL</kbd> + </template>
+    <template v-if="shift"> <kbd>SHIFT</kbd> + </template>
+    <kbd
+      :class="{
+  'bk-is-single': keyLabel.length === 1
+}"
+      >{{ keyLabel }}</kbd
+    >
+  </kbd>
+</template>
+
+<script setup>
+import { computed, useBlokkli } from "#imports";
+import { defineShortcut, onBlokkliEvent } from "#blokkli/editor/composables";
+const props = defineProps({
+  group: { type: String, required: false },
+  viewOnly: { type: Boolean, required: false },
+  meta: { type: Boolean, required: false },
+  shift: { type: Boolean, required: false },
+  keyCode: { type: String, required: true },
+  label: { type: String, required: false }
+});
+const emit = defineEmits(["pressed"]);
+const { state, ui, $t } = useBlokkli();
+const key = computed(
+  () => [props.meta, props.shift, props.keyCode.toLowerCase()].join("-")
+);
+const keyLabel = computed(() => {
+  if (props.keyCode === "Delete") {
+    return "\u232B";
+  } else if (props.keyCode === "ArrowDown") {
+    return "\u2193";
+  } else if (props.keyCode === "ArrowUp") {
+    return "\u2191";
+  } else if (props.keyCode === "ArrowRight") {
+    return "\u2192";
+  } else if (props.keyCode === "ArrowLeft") {
+    return "\u2190";
+  } else if (props.keyCode === "Digit0" || props.keyCode === "0") {
+    return "\uE07B";
+  } else if (props.keyCode === " ") {
+    return $t("keyboardSpace", "Space");
+  }
+  return props.keyCode.toUpperCase();
+});
+if (!props.viewOnly) {
+  if (props.label) {
+    defineShortcut({
+      meta: props.meta,
+      shift: props.shift,
+      code: props.keyCode,
+      label: props.label,
+      group: props.group
+    });
+  }
+  onBlokkliEvent("keyPressed", (e) => {
+    if (ui.hasDialogOpen.value || ui.hasNestedEditorOpen.value) {
+      return;
+    }
+    const checkKey = [e.meta, e.shift, e.code.toLowerCase()].join("-");
+    if (key.value !== checkKey) {
+      return;
+    }
+    e.originalEvent.preventDefault();
+    if (state.isLoading.value || ui.hasTransformOverlayOpen.value) {
+      return;
+    }
+    emit("pressed");
+  });
+}
+</script>
+
+<script>
+export default {
+  name: "ShortcutIndicator"
+};
+</script>

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

@@ -0,0 +1,21 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    group?: string;
+    viewOnly?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    keyCode: string;
+    label?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    pressed: (...args: any[]) => void;
+}, string, import("vue").PublicProps, Readonly<{
+    group?: string;
+    viewOnly?: boolean;
+    meta?: boolean;
+    shift?: boolean;
+    keyCode: string;
+    label?: string;
+}> & Readonly<{
+    onPressed?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,17 @@
+import type { DraggableItem } from '#blokkli/editor/types/draggable';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    getDragItems?: (activeItem?: DraggableItem) => DraggableItem[] | null;
+    buildItem: (el: HTMLElement) => DraggableItem | null | undefined;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    getDragItems?: (activeItem?: DraggableItem) => DraggableItem[] | null;
+    buildItem: (el: HTMLElement) => DraggableItem | null | undefined;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,81 @@
+<template>
+  <div
+    @pointerdown.capture.prevent="onPointerDown"
+    @pointerup.capture.prevent="onPointerUp"
+    @pointermove.capture.prevent="onPointerMove"
+  >
+    <slot />
+  </div>
+</template>
+
+<script setup>
+import { useBlokkli } from "#imports";
+import { getInteractionCoordinates } from "#blokkli/editor/helpers/dom";
+import { getDistance } from "#blokkli/editor/helpers/geometry";
+const { eventBus } = useBlokkli();
+const props = defineProps({
+  getDragItems: { type: Function, required: false },
+  buildItem: { type: Function, required: true }
+});
+let pointerStartCoords = null;
+let activeItem = null;
+function onPointerDown(e) {
+  if (!(e.target instanceof HTMLElement || e.target instanceof SVGElement)) {
+    return;
+  }
+  if (e.button !== 0) {
+    pointerStartCoords = null;
+    return;
+  }
+  pointerStartCoords = getInteractionCoordinates(e);
+  const sortliItem = e.target.closest("[data-sortli-id]");
+  if (!(sortliItem instanceof HTMLElement)) {
+    return;
+  }
+  const item = props.buildItem(sortliItem);
+  if (!item) {
+    return;
+  }
+  activeItem = item;
+}
+function onPointerMove(e) {
+  if (!pointerStartCoords || !activeItem || e.pointerType === "touch") {
+    return;
+  }
+  const coords = getInteractionCoordinates(e);
+  const distance = getDistance(coords, pointerStartCoords);
+  if (distance > 7) {
+    const dragItems = props.getDragItems ? props.getDragItems(activeItem) : null;
+    eventBus.emit("dragging:start", {
+      items: dragItems && dragItems.length ? dragItems : [activeItem],
+      coords,
+      mode: "mouse"
+    });
+    activeItem = null;
+    pointerStartCoords = null;
+  }
+}
+function onPointerUp(e) {
+  if (!pointerStartCoords || !activeItem) {
+    pointerStartCoords = null;
+    activeItem = null;
+    return;
+  }
+  const coords = getInteractionCoordinates(e);
+  const distance = getDistance(coords, pointerStartCoords);
+  if (e.pointerType === "touch" && distance < 5) {
+    eventBus.emit("dragging:start", {
+      items: [activeItem],
+      coords,
+      mode: "touch"
+    });
+  }
+  pointerStartCoords = null;
+}
+</script>
+
+<script>
+export default {
+  name: "Sortli"
+};
+</script>

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

@@ -0,0 +1,17 @@
+import type { DraggableItem } from '#blokkli/editor/types/draggable';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<{
+    getDragItems?: (activeItem?: DraggableItem) => DraggableItem[] | null;
+    buildItem: (el: HTMLElement) => DraggableItem | null | undefined;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    getDragItems?: (activeItem?: DraggableItem) => DraggableItem[] | null;
+    buildItem: (el: HTMLElement) => DraggableItem | null | undefined;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,9 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    status: "pending" | "active" | "success" | "error";
+    bulletText?: string | number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    status: "pending" | "active" | "success" | "error";
+    bulletText?: string | number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

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

@@ -0,0 +1,31 @@
+<template>
+  <div class="bk-status-icon" :class="`bk-is-${status}`">
+    <Icon v-if="icon" :name="icon" />
+    <span v-else class="bk-status-icon-bullet" v-html="bulletText" />
+  </div>
+</template>
+
+<script setup>
+import { computed } from "#imports";
+import Icon from "../Icon/index.vue";
+const props = defineProps({
+  status: { type: String, required: true },
+  bulletText: { type: [String, Number], required: false }
+});
+const icon = computed(() => {
+  if (props.status === "active") {
+    return "loader";
+  } else if (props.status === "success") {
+    return "bk_mdi_check";
+  } else if (props.status === "error") {
+    return "bk_mdi_priority_high";
+  }
+  return null;
+});
+</script>
+
+<script>
+export default {
+  name: "StatusIcon"
+};
+</script>

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

@@ -0,0 +1,9 @@
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    status: "pending" | "active" | "success" | "error";
+    bulletText?: string | number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    status: "pending" | "active" | "success" | "error";
+    bulletText?: string | number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/editor/components/SystemRequirements/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;