@blokkli/editor 2.0.0-alpha.28 → 2.0.0-alpha.29

package/dist/runtime/editor/components/PluginConfigForm/Text/index.vue

@@ -0,0 +1,43 @@
+<template>
+  <FormTextarea
+    v-if="multiline"
+    :id="name"
+    v-model="value"
+    :label
+    :required
+    :placeholder
+    :description
+    :minlength="minLength"
+    :maxlength="maxLength"
+  />
+  <FormText
+    v-else
+    :id="name"
+    v-model="value"
+    :label
+    :required
+    :description
+    :placeholder
+    :minlength="minLength"
+    :maxlength="maxLength"
+  />
+</template>
+
+<script setup>
+import { FormText, FormTextarea } from "#blokkli/editor/components";
+defineProps({
+  type: { type: String, required: true },
+  name: { type: String, required: true },
+  label: { type: String, required: true },
+  description: { type: String, required: false },
+  required: { type: Boolean, required: true },
+  defaultValue: { type: String, required: false },
+  minLength: { type: Number, required: false },
+  maxLength: { type: Number, required: false },
+  placeholder: { type: String, required: false },
+  pattern: { type: String, required: false },
+  multiline: { type: Boolean, required: false },
+  rows: { type: Number, required: false }
+});
+const value = defineModel({ type: String });
+</script>

package/dist/runtime/editor/components/PluginConfigForm/Text/index.vue.d.ts

@@ -0,0 +1,5 @@
+declare const __VLS_export: import("vue").DefineComponent<any, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | undefined) => any;
+}, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, any, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,30 @@
+import type { PluginConfigInput } from '#blokkli/editor/types/pluginConfig';
+type __VLS_Props = {
+    config: PluginConfigInput[];
+};
+declare function updateSeed(): void;
+type __VLS_ModelProps = {
+    modelValue?: Record<string, any>;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {}, __VLS_18: {};
+type __VLS_Slots = {} & {
+    before?: (props: typeof __VLS_1) => any;
+} & {
+    after?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    updateSeed: typeof updateSeed;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: Record<string, any>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Record<string, any>) => 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/PluginConfigForm/index.vue

@@ -0,0 +1,59 @@
+<template>
+  <ol>
+    <slot name="before" />
+    <li v-for="item in renderedConfig" :key="item.name" class="bk-form-item">
+      <FormCheckbox
+        v-if="item.type === 'checkbox'"
+        v-bind="item"
+        v-model="value[item.name]"
+      />
+      <FormText
+        v-else-if="item.type === 'text'"
+        v-bind="item"
+        v-model="value[item.name]"
+      />
+      <FormOptions
+        v-else-if="item.type === 'options'"
+        v-bind="item"
+        v-model="value[item.name]"
+      />
+      <slot name="after" />
+    </li>
+  </ol>
+</template>
+
+<script setup>
+import FormCheckbox from "./Checkbox/index.vue";
+import FormText from "./Text/index.vue";
+import FormOptions from "./Options/index.vue";
+import { computed } from "#imports";
+const props = defineProps({
+  config: { type: Array, required: true }
+});
+const renderedConfig = computed(
+  () => props.config.filter((v) => v.type !== "seed")
+);
+const value = defineModel({ type: Object, ...{
+  default: () => {
+    return {};
+  }
+} });
+function updateSeed() {
+  props.config.forEach((config) => {
+    if (config.type === "seed") {
+      value.value[config.name] = Math.round(
+        Date.now() * Math.random()
+      ).toString();
+    }
+  });
+}
+props.config.forEach((config) => {
+  if ("defaultValue" in config) {
+    value.value[config.name] = config.defaultValue;
+  }
+});
+updateSeed();
+defineExpose({
+  updateSeed
+});
+</script>

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

@@ -0,0 +1,30 @@
+import type { PluginConfigInput } from '#blokkli/editor/types/pluginConfig';
+type __VLS_Props = {
+    config: PluginConfigInput[];
+};
+declare function updateSeed(): void;
+type __VLS_ModelProps = {
+    modelValue?: Record<string, any>;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare var __VLS_1: {}, __VLS_18: {};
+type __VLS_Slots = {} & {
+    before?: (props: typeof __VLS_1) => any;
+} & {
+    after?: (props: typeof __VLS_18) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
+    updateSeed: typeof updateSeed;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: Record<string, any>) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: Record<string, any>) => 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/PreviewProvider.d.vue.ts

@@ -0,0 +1,29 @@
+import '#blokkli-build/styles.css';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        entity?: T;
+        entityType: string;
+        entityUuid: string;
+        entityBundle: string;
+        language: string;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: {
+            mutatedEntity: T;
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/editor/components/PreviewProvider.vue

@@ -0,0 +1,176 @@
+<template>
+  <slot :mutated-entity="mutatedEntity" />
+</template>
+
+<script setup>
+import {
+  ref,
+  reactive,
+  computed,
+  provide,
+  onMounted,
+  onBeforeUnmount,
+  useRouter,
+  useAsyncData
+} from "#imports";
+import "#blokkli-build/styles.css";
+import getAdapter from "#blokkli-build/edit-adapter";
+import {
+  INJECT_EDIT_CONTEXT,
+  INJECT_IS_PREVIEW,
+  INJECT_MUTATED_FIELDS_MAP
+} from "#blokkli/helpers/injections";
+import broadcastProvider from "#blokkli/editor/providers/broadcast";
+import { getFieldKey } from "#blokkli/helpers";
+import { intersects } from "#blokkli/editor/helpers/geometry";
+import { eventBus, frameEventBus } from "#blokkli/editor/events";
+import definitionProvider from "#blokkli/editor/providers/definition";
+import { addElementClasses } from "#blokkli/editor/composables";
+const props = defineProps({
+  entity: { type: null, required: false },
+  entityType: { type: String, required: true },
+  entityUuid: { type: String, required: true },
+  entityBundle: { type: String, required: true },
+  language: { type: String, required: true }
+});
+defineSlots();
+const context = computed(() => {
+  return {
+    entityType: props.entityType,
+    entityBundle: props.entityBundle,
+    entityUuid: props.entityUuid,
+    language: props.language
+  };
+});
+const adapter = await getAdapter(context);
+const router = useRouter();
+const broadcast = broadcastProvider();
+const definitions = definitionProvider();
+let timeout = null;
+let lastChanged = 0;
+const mutatedFieldsMap = reactive({});
+const mutatedOptions = reactive({});
+const mutatedEntityFromState = ref(null);
+const mutatedEntity = computed(
+  () => mutatedEntityFromState.value || props.entity
+);
+const { data, refresh, error } = await useAsyncData(
+  () => adapter.loadState().then((v) => adapter.mapState(v))
+);
+function updateMutatedFields(fields) {
+  fields.forEach((field) => {
+    const key = getFieldKey(field.entityUuid, field.name);
+    mutatedFieldsMap[key] = field;
+  });
+}
+const updateState = () => {
+  const fields = data.value?.mutatedState?.fields || [];
+  updateMutatedFields(fields);
+  mutatedEntityFromState.value = data.value?.mutatedEntity;
+  const options = mutatedOptions.value || data.value?.mutatedState?.mutatedOptions || {};
+  const optionKeys = Object.keys(options);
+  for (let i = 0; i < optionKeys.length; i++) {
+    const key = optionKeys[i];
+    if (key) {
+      const newOptions = options[key];
+      const existing = mutatedOptions[key];
+      if (!existing || JSON.stringify(existing) !== JSON.stringify(newOptions)) {
+        mutatedOptions[key] = newOptions;
+      }
+    }
+  }
+};
+updateState();
+const isPreview = computed(() => !error.value);
+provide(INJECT_MUTATED_FIELDS_MAP, mutatedFieldsMap);
+provide(INJECT_IS_PREVIEW, isPreview);
+provide(INJECT_EDIT_CONTEXT, {
+  mutatedOptions,
+  eventBus,
+  definitions
+});
+function onMessage(e) {
+  if (e.data && typeof e.data === "object" && e.data.name && typeof e.data.name === "string" && e.data.name.startsWith("blokkli__")) {
+    const name = e.data.name.replace("blokkli__", "");
+    const data2 = e.data.data;
+    frameEventBus.emit(name, data2);
+  }
+}
+const onMouseDown = () => {
+  broadcast.emit("previewFocused");
+};
+function checkChangedDate() {
+  if (!isPreview.value) {
+    return;
+  }
+  clearTimeout(timeout);
+  const delay = adapter.getLastChanged ? 1e3 : 5e3;
+  timeout = setTimeout(async () => {
+    const changed = adapter.getLastChanged ? await adapter.getLastChanged() : Date.now();
+    if (changed) {
+      if (lastChanged !== 0 && lastChanged !== changed) {
+        await refresh();
+        updateState();
+      }
+      lastChanged = changed;
+      checkChangedDate();
+    }
+  }, delay);
+}
+const onWheel = (e) => {
+  if (e.ctrlKey) {
+    e.preventDefault();
+  }
+};
+const isInIframe = () => window.parent !== window;
+const onFocusItem = (uuid) => {
+  const el = document.querySelector(`[data-bk-uuid="${uuid}"]`);
+  if (el) {
+    const elRect = el.getBoundingClientRect();
+    if (!intersects(elRect, {
+      x: 0,
+      y: 0,
+      width: window.innerWidth,
+      height: window.innerHeight
+    })) {
+      el.scrollIntoView({
+        behavior: "smooth",
+        block: "center",
+        inline: "center"
+      });
+    }
+  }
+};
+const onUpdateOption = (option) => {
+  const { uuid, key, value } = option;
+  if (!mutatedOptions[uuid]) {
+    mutatedOptions[uuid] = {};
+  }
+  mutatedOptions[uuid][key] = value;
+};
+addElementClasses(document.body, "bk-body-preview");
+addElementClasses(document.documentElement, "bk-html-preview");
+onMounted(() => {
+  if (isInIframe()) {
+    frameEventBus.on("mutatedFields", updateMutatedFields);
+    frameEventBus.on("focus", onFocusItem);
+    frameEventBus.on("updateOption", onUpdateOption);
+    window.addEventListener("message", onMessage);
+    window.addEventListener("wheel", onWheel, { passive: false });
+    document.documentElement.addEventListener("mousedown", onMouseDown);
+    router.push = () => Promise.resolve();
+    router.replace = () => Promise.resolve();
+  } else {
+    checkChangedDate();
+  }
+});
+onBeforeUnmount(() => {
+  clearTimeout(timeout);
+  window.removeEventListener("wheel", onWheel);
+  window.removeEventListener("message", onMessage);
+  document.documentElement.removeEventListener("mousedown", onMouseDown);
+  frameEventBus.off("mutatedFields", updateMutatedFields);
+  frameEventBus.off("focus", onFocusItem);
+  frameEventBus.off("updateOption", onUpdateOption);
+});
+</script>

package/dist/runtime/editor/components/PreviewProvider.vue.d.ts

@@ -0,0 +1,29 @@
+import '#blokkli-build/styles.css';
+declare const __VLS_export: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: import("vue").PublicProps & __VLS_PrettifyLocal<{
+        entity?: T;
+        entityType: string;
+        entityUuid: string;
+        entityBundle: string;
+        language: string;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        default(props: {
+            mutatedEntity: T;
+        }): any;
+    };
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

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

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

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

@@ -0,0 +1,59 @@
+<template>
+  <slot :formatted="formatted" />
+</template>
+
+<script setup>
+import { ref, computed, onMounted, onBeforeUnmount, useBlokkli } from "#imports";
+const props = defineProps({
+  timestamp: { type: Number, required: true }
+});
+function getRelativeTimeString(date, lang = navigator.language) {
+  const timeMs = typeof date === "number" ? date : date.getTime();
+  const deltaSeconds = Math.round((timeMs - Date.now()) / 1e3);
+  const cutoffs = [
+    60,
+    3600,
+    86400,
+    86400 * 7,
+    86400 * 30,
+    86400 * 365,
+    Infinity
+  ];
+  const units = [
+    "second",
+    "minute",
+    "hour",
+    "day",
+    "week",
+    "month",
+    "year"
+  ];
+  const unitIndex = cutoffs.findIndex(
+    (cutoff) => cutoff > Math.abs(deltaSeconds)
+  );
+  const divisor = unitIndex ? cutoffs[unitIndex - 1] : 1;
+  const rtf = new Intl.RelativeTimeFormat(lang, { numeric: "auto" });
+  return rtf.format(Math.floor(deltaSeconds / divisor), units[unitIndex]);
+}
+const { ui } = useBlokkli();
+const incrementToggle = ref(0);
+let interval = null;
+const formatted = computed(() => {
+  const date = new Date(props.timestamp * 1e3 + incrementToggle.value);
+  return getRelativeTimeString(date, ui.interfaceLanguage.value);
+});
+onMounted(() => {
+  interval = setInterval(() => {
+    incrementToggle.value = incrementToggle.value ? 0 : 1;
+  }, 1e3);
+});
+onBeforeUnmount(() => {
+  clearInterval(interval);
+});
+</script>
+
+<script>
+export default {
+  name: "RelativeTime"
+};
+</script>

package/dist/runtime/editor/components/RelativeTime/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<{
+    timestamp: number;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{
+    timestamp: number;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {
+        formatted: any;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

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

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

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

package/dist/runtime/editor/components/ScaleToFit/index.d.vue.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/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;
+    };
+};