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

package/dist/runtime/editor/features/analyze/Renderer/index.vue

@@ -0,0 +1,259 @@
+<template>
+  <div />
+</template>
+
+<script setup>
+import { useBlokkli, computed, watch } from "#imports";
+import {
+  setBuffersAndAttributes,
+  drawBufferInfo,
+  setUniforms
+} from "twgl.js";
+import vs from "./vertex.glsl?raw";
+import fs from "./fragment.glsl?raw";
+import { RectangleBufferCollector } from "#blokkli/editor/helpers/webgl";
+import { toShaderColor } from "#blokkli/editor/helpers/color";
+import { defineRenderer, onBlokkliEvent } from "#blokkli/editor/composables";
+const props = defineProps({
+  results: { type: Array, required: true },
+  isStale: { type: Boolean, required: true },
+  isRunning: { type: Boolean, required: true },
+  manualAnalyzerIds: { type: Set, required: true }
+});
+const { animation, ui, theme, selection, element, dom, blocks } = useBlokkli();
+const activeId = defineModel({ type: String, ...{
+  default: ""
+} });
+const statusPriority = {
+  violation: 3,
+  incomplete: 2,
+  pass: 1,
+  inapplicable: 0
+};
+const nodes = computed(() => {
+  const mappedNodes = [];
+  for (let i = 0; i < props.results.length; i++) {
+    const result = props.results[i];
+    if (!result) {
+      continue;
+    }
+    if (result.status !== "incomplete" && result.status !== "violation") {
+      continue;
+    }
+    for (let j = 0; j < result.nodes.length; j++) {
+      const node = result.nodes[j];
+      if (!node) {
+        continue;
+      }
+      for (let k = 0; k < node.targets.length; k++) {
+        const target = node.targets[k];
+        if (!target) {
+          continue;
+        }
+        let targetElement = null;
+        if (typeof target.target === "string") {
+          targetElement = element.query(
+            ui.providerElement,
+            target.target,
+            "Find analyze node target element."
+          );
+        } else if (target.target instanceof HTMLElement) {
+          targetElement = target.target;
+        } else {
+          const item = blocks.getBlock(target.target.uuid);
+          if (item) {
+            targetElement = dom.getDragElement(item) ?? null;
+          }
+        }
+        if (targetElement) {
+          mappedNodes.push({
+            id: result.id,
+            element: targetElement,
+            index: target.globalIndex,
+            title: result.title,
+            status: result.status,
+            plugin: result.plugin
+          });
+        }
+      }
+    }
+  }
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const node of mappedNodes) {
+    const existing = nodeMap.get(node.element);
+    if (!existing || statusPriority[node.status] > statusPriority[existing.status]) {
+      nodeMap.set(node.element, node);
+    }
+  }
+  const finalNodes = Array.from(nodeMap.values());
+  return finalNodes;
+});
+const activeRectId = computed(() => {
+  if (!activeId.value) {
+    return -1;
+  }
+  for (let i = 0; i < nodes.value.length; i++) {
+    const node = nodes.value[i];
+    const id = node.id + "_____" + node.index;
+    if (activeId.value === id) {
+      return i;
+    }
+  }
+  return -1;
+});
+class AnalyzeRectangleBufferCollector extends RectangleBufferCollector {
+  prevKey = "";
+  rectCache = /* @__PURE__ */ new Map();
+  clearCache() {
+    this.rectCache.clear();
+    this.prevKey = "";
+  }
+  getBufferInfo(gl, force) {
+    const key = nodes.value.map((node, index) => {
+      if (!this.rectCache.has(node.element)) {
+        const rect2 = ui.getAbsoluteElementRect(node.element);
+        this.rectCache.set(node.element, rect2);
+      }
+      const rect = this.rectCache.get(node.element);
+      if (!rect) {
+        return `${index}_no_rect`;
+      }
+      return `${index}_${rect.x}_${rect.y}_${rect.width}_${rect.height}_${node.status}`;
+    }).join("_");
+    const hasChanged = force || this.prevKey !== key;
+    if (hasChanged) {
+      this.reset();
+      for (let i = 0; i < nodes.value.length; i++) {
+        const node = nodes.value[i];
+        const id = `analyze_${i}`;
+        if (this.added.has(id)) {
+          continue;
+        }
+        const rect = this.rectCache.get(node.element);
+        if (!rect) {
+          continue;
+        }
+        this.added.add(id);
+        const isManual = props.manualAnalyzerIds.has(node.plugin);
+        const statusType = node.status === "violation" ? isManual ? 0 : 1 : isManual ? 2 : 3;
+        this.addRectangle(
+          {
+            id,
+            x: rect.x,
+            y: rect.y,
+            width: rect.width,
+            height: rect.height,
+            status: node.status,
+            plugin: node.plugin,
+            nodeIndex: node.index
+          },
+          statusType
+        );
+      }
+      this.prevKey = key;
+    }
+    if (hasChanged && gl) {
+      this.bufferInfo = this.createBufferInfo(gl);
+    }
+    return { info: this.bufferInfo, hasChanged };
+  }
+}
+function getOpacity() {
+  return props.isRunning ? 0.3 : 1;
+}
+const { collector } = defineRenderer("analyze-overlay", {
+  zIndex: 500,
+  collector: () => new AnalyzeRectangleBufferCollector(),
+  program: () => ({ shaders: [vs, fs] }),
+  enabled: () => !selection.isMultiSelecting.value && !selection.isDragging.value && !selection.isChangingOptions.value,
+  render: (_ctx, gl, program) => {
+    gl.useProgram(program.program);
+    const { info } = collector.getBufferInfo(gl);
+    if (!info) {
+      return;
+    }
+    setUniforms(program, {
+      u_color_violation: toShaderColor(theme.red.value.normal),
+      u_color_incomplete: toShaderColor(theme.yellow.value.normal),
+      u_opacity: getOpacity(),
+      u_manual_stale: props.isStale ? 1 : 0,
+      u_active_id: activeRectId.value
+    });
+    animation.setSharedUniforms(gl, program);
+    setBuffersAndAttributes(gl, program, info);
+    drawBufferInfo(gl, info, gl.TRIANGLES);
+  },
+  renderFallback: (ctx, ctx2d) => {
+    collector.getBufferInfo();
+    const rects = Object.values(collector.rects);
+    if (rects.length === 0) {
+      return;
+    }
+    const rgbaToCss = (rgb, alpha) => {
+      return `rgba(${rgb[0]}, ${rgb[1]}, ${rgb[2]}, ${alpha})`;
+    };
+    const globalOpacity = getOpacity();
+    const borderRadius = 8 * ctx.dpi;
+    for (let i = 0; i < rects.length; i++) {
+      const rect = rects[i];
+      const isManual = props.manualAnalyzerIds.has(rect.plugin);
+      const finalOpacity = isManual && props.isStale ? 0.3 : globalOpacity;
+      const fillAlpha = 0.3 * finalOpacity;
+      const baseColor = rect.status === "violation" ? theme.red.value.normal : theme.yellow.value.normal;
+      const fillColor = rgbaToCss(baseColor, fillAlpha);
+      const x = (rect.x * ctx.artboardScale + ctx.artboardOffset.x) * ctx.dpi;
+      const y = (rect.y * ctx.artboardScale + ctx.artboardOffset.y) * ctx.dpi;
+      const width = rect.width * ctx.artboardScale * ctx.dpi;
+      const height = rect.height * ctx.artboardScale * ctx.dpi;
+      ctx2d.fillStyle = fillColor;
+      ctx2d.beginPath();
+      ctx2d.roundRect(x, y, width, height, borderRadius);
+      ctx2d.fill();
+    }
+  }
+});
+onBlokkliEvent("ui:resized", function() {
+  collector.clearCache();
+  collector.reset();
+});
+onBlokkliEvent("option:finish-change", () => {
+  collector.clearCache();
+  collector.reset();
+});
+watch(
+  () => props.results,
+  () => {
+    collector.clearCache();
+    collector.reset();
+  }
+);
+onBlokkliEvent("mouse:up", (e) => {
+  const artboardX = (e.x - ui.artboardOffset.value.x) / ui.artboardScale.value;
+  const artboardY = (e.y - ui.artboardOffset.value.y) / ui.artboardScale.value;
+  for (let i = 0; i < nodes.value.length; i++) {
+    const node = nodes.value[i];
+    const rect = collector.rectCache.get(node.element);
+    if (!rect) {
+      continue;
+    }
+    if (artboardX >= rect.x && artboardX <= rect.x + rect.width && artboardY >= rect.y && artboardY <= rect.y + rect.height) {
+      const id = node.id + "_____" + node.index;
+      if (activeId.value === id) {
+        activeId.value = "";
+      } else {
+        activeId.value = id;
+      }
+      return;
+    }
+  }
+});
+onBlokkliEvent("window:clickAway", () => {
+  activeId.value = "";
+});
+</script>
+
+<script>
+export default {
+  name: "AnalyzeOverlay"
+};
+</script>

package/dist/runtime/editor/features/analyze/Renderer/index.vue.d.ts

@@ -0,0 +1,22 @@
+import type { AnalyzeResultMapped } from '#blokkli/analyzer/types';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<{
+    results: AnalyzeResultMapped[];
+    isStale: boolean;
+    isRunning: boolean;
+    manualAnalyzerIds: Set<string>;
+} & {
+    modelValue?: string;
+}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<{
+    results: AnalyzeResultMapped[];
+    isStale: boolean;
+    isRunning: boolean;
+    manualAnalyzerIds: Set<string>;
+} & {
+    modelValue?: string;
+}> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/editor/features/analyze/Results/Results.d.vue.ts

@@ -0,0 +1,15 @@
+import type { AnalyzeResultMapped } from '../analyzers/types.js';
+type __VLS_Props = {
+    results: AnalyzeResultMapped[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/features/analyze/Results/Results.vue

@@ -0,0 +1,102 @@
+<template>
+  <div>
+    <details
+      v-for="group in grouped"
+      :key="group.group"
+      :open="group.open"
+      class="bk-analyze-results"
+    >
+      <summary v-show="!group.open">
+        <div>
+          <span>{{ group.label }}</span>
+          <div>
+            <span class="bk-pill">{{ group.results.length }}</span>
+          </div>
+        </div>
+        <Icon name="bk_mdi_arrow_drop_down" />
+      </summary>
+      <ul
+        :class="{
+  'bk-is-always-open': group.open
+}"
+      >
+        <li>
+          <ResultsItem
+            v-for="result in group.results"
+            v-bind="result"
+            :key="group.group + result.id"
+            v-model="activeId"
+          />
+        </li>
+      </ul>
+    </details>
+  </div>
+</template>
+
+<script setup>
+import { computed, useBlokkli } from "#imports";
+import ResultsItem from "./ResultsItem.vue";
+import { Icon } from "#blokkli/editor/components";
+const props = defineProps({
+  results: { type: Array, required: true }
+});
+const { $t } = useBlokkli();
+const activeId = defineModel({ type: String, ...{ default: "" } });
+const groupOrder = {
+  problems: 1,
+  success: 2,
+  inapplicable: 3
+};
+const statusOrder = {
+  violation: 1,
+  incomplete: 2,
+  pass: 3,
+  inapplicable: 4
+};
+function getGroup(status) {
+  if (status === "violation" || status === "incomplete") {
+    return "problems";
+  } else if (status === "pass") {
+    return "success";
+  }
+  return "inapplicable";
+}
+function getGroupLabel(group) {
+  if (group === "problems") {
+    return "Problems";
+  } else if (group === "success") {
+    return $t("analyzeStatusPass", "Pass");
+  }
+  return $t("analyzeStatusInapplicable", "Inapplicable");
+}
+const grouped = computed(() => {
+  const map = props.results.reduce(
+    (acc, result) => {
+      const group = getGroup(result.status);
+      if (!acc[group]) {
+        acc[group] = [];
+      }
+      acc[group].push(result);
+      return acc;
+    },
+    {}
+  );
+  return Object.entries(map).map(([key, results]) => {
+    const group = key;
+    return {
+      group,
+      label: getGroupLabel(group),
+      open: group === "problems",
+      results: results.sort((a, b) => {
+        const statusDiff = statusOrder[a.status] - statusOrder[b.status];
+        if (statusDiff !== 0) {
+          return statusDiff;
+        }
+        return a.title.localeCompare(b.title);
+      })
+    };
+  }).sort((a, b) => {
+    return groupOrder[a.group] - groupOrder[b.group];
+  });
+});
+</script>

package/dist/runtime/editor/features/analyze/Results/Results.vue.d.ts

@@ -0,0 +1,15 @@
+import type { AnalyzeResultMapped } from '../analyzers/types.js';
+type __VLS_Props = {
+    results: AnalyzeResultMapped[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/features/analyze/Results/ResultsItem.d.vue.ts

@@ -0,0 +1,23 @@
+import type { AnalyzeCategory, AnalyzeImpact, AnalyzeNodeMapped, AnalyzeStatus } from '../analyzers/types.js';
+type __VLS_Props = {
+    id: string;
+    title: string;
+    category: AnalyzeCategory;
+    description: string;
+    link?: string;
+    status: AnalyzeStatus;
+    impact?: AnalyzeImpact;
+    plugin: string;
+    nodes: AnalyzeNodeMapped[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/features/analyze/Results/ResultsItem.vue

@@ -0,0 +1,56 @@
+<template>
+  <div class="bk-analyze-results-item">
+    <div class="bk-analyze-results-item-tags">
+      <Status :status :title="key" />
+      <div class="bk-pill bk-is-mono">{{ categoryLabel }}</div>
+      <div class="bk-analyze-results-item-help">
+        <a v-if="link" :href="link" target="_blank" :title="link">
+          <span>{{ $t("analyzeMoreLink", "More") }}</span>
+          <Icon name="bk_mdi_help-fill" />
+        </a>
+      </div>
+    </div>
+    <h3>{{ title }}</h3>
+    <p v-if="descriptionMapped || link">
+      {{ descriptionMapped }}
+    </p>
+
+    <ResultsItemNodes v-model="activeId" :nodes :result-id="id" />
+  </div>
+</template>
+
+<script setup>
+import { computed, useBlokkli } from "#imports";
+import { Icon } from "#blokkli/editor/components";
+import Status from "./Status.vue";
+import ResultsItemNodes from "./ResultsItemNodes.vue";
+import { useAnalyzeHelper } from "../helper";
+const props = defineProps({
+  id: { type: String, required: true },
+  title: { type: String, required: true },
+  category: { type: String, required: true },
+  description: { type: String, required: true },
+  link: { type: String, required: false },
+  status: { type: String, required: true },
+  impact: { type: String, required: false },
+  plugin: { type: String, required: true },
+  nodes: { type: Array, required: true }
+});
+const activeId = defineModel({ type: String, ...{ default: "" } });
+const { getCategoryLabel } = useAnalyzeHelper();
+const { $t } = useBlokkli();
+const categoryLabel = computed(() => {
+  return getCategoryLabel(props.category);
+});
+const descriptionMapped = computed(() => {
+  if (!props.description) {
+    return "";
+  }
+  const punctuation = /[.!?]$/;
+  if (punctuation.test(props.description.trim())) {
+    return props.description;
+  }
+  return props.description + ".";
+});
+const key = computed(() => `${props.plugin}:${props.id}`);
+</script>

package/dist/runtime/editor/features/analyze/Results/ResultsItem.vue.d.ts

@@ -0,0 +1,23 @@
+import type { AnalyzeCategory, AnalyzeImpact, AnalyzeNodeMapped, AnalyzeStatus } from '../analyzers/types.js';
+type __VLS_Props = {
+    id: string;
+    title: string;
+    category: AnalyzeCategory;
+    description: string;
+    link?: string;
+    status: AnalyzeStatus;
+    impact?: AnalyzeImpact;
+    plugin: string;
+    nodes: AnalyzeNodeMapped[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/features/analyze/Results/ResultsItemNodes.d.vue.ts

@@ -0,0 +1,16 @@
+import type { AnalyzeNodeMapped } from '../analyzers/types.js';
+type __VLS_Props = {
+    resultId: string;
+    nodes: AnalyzeNodeMapped[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/features/analyze/Results/ResultsItemNodes.vue

@@ -0,0 +1,80 @@
+<template>
+  <details
+    v-if="nodes.length"
+    class="bk-analyze-results-item-nodes"
+    :open="isSingle || isOpen"
+    @toggle="shouldRender = true"
+  >
+    <summary v-show="!isSingle">
+      <span>{{ $t("multipleItemsLabel", "Items") }}</span>
+      <Icon name="bk_mdi_arrow_drop_down" />
+    </summary>
+
+    <div v-if="shouldRender" class="bk-analyze-results-item-nodes-list">
+      <ul v-for="(group, i) in grouped" :key="i">
+        <li>
+          <p
+            v-if="group.description && group.description !== 'NONE'"
+            :class="{
+  'bk-is-single': isSingle
+}"
+            v-html="group.description"
+          />
+          <ul>
+            <li v-for="(node, j) in group.nodes" :key="i + '_' + j">
+              <ResultsItemNodesTarget
+                v-for="(target, k) in node.targets"
+                :key="i + '_' + j + '_' + k"
+                v-model="activeId"
+                :target
+                :result-id
+              />
+            </li>
+          </ul>
+        </li>
+      </ul>
+    </div>
+  </details>
+</template>
+
+<script setup>
+import { computed, ref, useBlokkli, watch } from "#imports";
+import ResultsItemNodesTarget from "./ResultsItemNodesTarget.vue";
+import { Icon } from "#blokkli/editor/components";
+const props = defineProps({
+  resultId: { type: String, required: true },
+  nodes: { type: Array, required: true }
+});
+const activeId = defineModel({ type: String, ...{ default: "" } });
+const shouldRender = ref(false);
+const isOpen = ref(false);
+const { $t } = useBlokkli();
+const isSingle = computed(
+  () => props.nodes.length === 1 && props.nodes[0]?.targets.length === 1
+);
+const grouped = computed(() => {
+  const map = props.nodes.reduce(
+    (acc, node) => {
+      const description = node.description ?? "NONE";
+      if (!acc[description]) {
+        acc[description] = [];
+      }
+      acc[description].push(node);
+      return acc;
+    },
+    {}
+  );
+  return Object.entries(map).map(([description, nodes]) => {
+    return {
+      description: description === "none" ? "" : description,
+      nodes
+    };
+  });
+});
+watch(activeId, (id) => {
+  const resultId = id.split("_____")[0];
+  if (resultId === props.resultId) {
+    isOpen.value = true;
+  }
+});
+</script>

package/dist/runtime/editor/features/analyze/Results/ResultsItemNodes.vue.d.ts

@@ -0,0 +1,16 @@
+import type { AnalyzeNodeMapped } from '../analyzers/types.js';
+type __VLS_Props = {
+    resultId: string;
+    nodes: AnalyzeNodeMapped[];
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/editor/features/analyze/Results/ResultsItemNodesTarget.d.vue.ts

@@ -0,0 +1,16 @@
+import type { AnalyzeNodeTargetMapped } from '#blokkli/analyzer/types';
+type __VLS_Props = {
+    resultId: string;
+    target: AnalyzeNodeTargetMapped;
+};
+type __VLS_ModelProps = {
+    modelValue?: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;