@shwfed/config 1.0.0

package/dist/runtime/components/config/use-editor.js

@@ -0,0 +1,388 @@
+import { Schema } from "effect";
+import { computed, ref, shallowRef, watch } from "vue";
+import { findFreePlacement, normalizeLayoutSet } from "../../share/layout.js";
+import { PageConfig } from "./schema.js";
+import { BLOCKS, findBlock } from "./utils/resolve.js";
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function makeId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function formatError(err) {
+  if (err instanceof Error) return err.message;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+export function useSlotEditor(slot, options = {}) {
+  const configure = options.configure ?? (() => {
+  });
+  const blocks = computed(
+    () => slot.value.blocks
+  );
+  const layouts = computed({
+    get: () => [...slot.value.layouts],
+    set: (next) => {
+      slot.value = { ...slot.value, layouts: next };
+    }
+  });
+  function setLayouts(next) {
+    layouts.value = next;
+  }
+  const selectedBlockIds = ref([]);
+  const activeLayoutIndex = ref(0);
+  watch(layouts, (next) => {
+    if (next.length === 0) {
+      activeLayoutIndex.value = 0;
+      return;
+    }
+    if (activeLayoutIndex.value >= next.length) {
+      activeLayoutIndex.value = next.length - 1;
+    }
+    if (activeLayoutIndex.value < 0) activeLayoutIndex.value = 0;
+  });
+  const pickerEntries = computed(() => {
+    const byType = /* @__PURE__ */ new Map();
+    for (const b of BLOCKS) {
+      const prev = byType.get(b.type);
+      if (!prev || b.compatibilityDate > prev.compatibilityDate) {
+        byType.set(b.type, {
+          type: b.type,
+          compatibilityDate: b.compatibilityDate,
+          name: b.metadata.name,
+          icon: b.metadata.icon
+        });
+      }
+    }
+    return [...byType.values()].sort((a, b) => a.name.localeCompare(b.name, "zh"));
+  });
+  function addBlock(entry, opts) {
+    const id = makeId();
+    const meta = findBlock(entry.type, entry.compatibilityDate);
+    const block = {
+      id,
+      type: entry.type,
+      compatibilityDate: entry.compatibilityDate,
+      ...meta?.defaultBody() ?? {}
+    };
+    const w = meta?.metadata.w.initial ?? 1;
+    const h = meta?.metadata.h.initial ?? 1;
+    const i = activeLayoutIndex.value;
+    const nextLayouts = slot.value.layouts.map((ls, idx) => {
+      if (idx !== i) return ls;
+      const placement = findFreePlacement(ls.layout.placements, w, h);
+      const placements = { ...ls.layout.placements, [id]: placement };
+      let cols = 0;
+      let rows = 0;
+      for (const p of Object.values(placements)) {
+        const [, [x2, y2]] = p.area;
+        if (x2 - 1 > cols) cols = x2 - 1;
+        if (y2 - 1 > rows) rows = y2 - 1;
+      }
+      return {
+        ...ls,
+        layout: {
+          ...ls.layout,
+          placements,
+          columns: Math.max(1, cols),
+          rows: Math.max(1, rows)
+        }
+      };
+    });
+    slot.value = {
+      ...slot.value,
+      blocks: [...slot.value.blocks, block],
+      layouts: nextLayouts
+    };
+    if (!opts?.silent) {
+      selectedBlockIds.value = [id];
+    }
+    return id;
+  }
+  function removeBlock(id) {
+    removeBlocks([id]);
+  }
+  function removeBlocks(ids) {
+    if (ids.length === 0) return;
+    const drop = new Set(ids);
+    const nextBlocks = blocks.value.filter((b) => !drop.has(b.id));
+    const nextLayouts = slot.value.layouts.map((ls) => {
+      const entries = Object.entries(ls.layout.placements).filter(([pid]) => !drop.has(pid));
+      if (entries.length === Object.keys(ls.layout.placements).length) return ls;
+      return normalizeLayoutSet({
+        ...ls,
+        layout: { ...ls.layout, placements: Object.fromEntries(entries) }
+      });
+    });
+    slot.value = { ...slot.value, blocks: nextBlocks, layouts: nextLayouts };
+    if (selectedBlockIds.value.some((x) => drop.has(x))) {
+      selectedBlockIds.value = selectedBlockIds.value.filter((x) => !drop.has(x));
+    }
+  }
+  function updateBlock(id, next) {
+    const updated = blocks.value.map((b) => b.id === id ? next : b);
+    slot.value = { ...slot.value, blocks: updated };
+  }
+  function getBlockLabel(b) {
+    const entry = findBlock(b.type, b.compatibilityDate);
+    return entry?.metadata.name ?? "\u672A\u547D\u540D\u5757";
+  }
+  function findBlockMeta(type, compatibilityDate) {
+    return findBlock(type, compatibilityDate);
+  }
+  const layoutsAccessor = {
+    get value() {
+      return layouts.value;
+    },
+    set value(next) {
+      layouts.value = next;
+    }
+  };
+  return {
+    selectedBlockIds,
+    activeLayoutIndex,
+    blocks,
+    layouts: layoutsAccessor,
+    pickerEntries,
+    addBlock,
+    removeBlock,
+    removeBlocks,
+    updateBlock,
+    setLayouts,
+    getBlockLabel,
+    findBlockMeta,
+    configure
+  };
+}
+export function useConfigEditor(model, options = {}) {
+  const configure = options.configure ?? (() => {
+  });
+  const baseline = ref(deepClone(model.value));
+  const draft = ref(deepClone(baseline.value));
+  const isDirty = computed(() => {
+    return JSON.stringify(draft.value) !== JSON.stringify(baseline.value);
+  });
+  const topSlot = computed({
+    get: () => draft.value.slot,
+    set: (next) => {
+      draft.value = { ...draft.value, slot: next };
+    }
+  });
+  const topSlotEditor = useSlotEditor(topSlot, { configure });
+  const stack = ref([{ kind: "layout" }]);
+  const top = computed(() => stack.value[stack.value.length - 1]);
+  const activeBlock = computed(() => {
+    const t = top.value;
+    if (t.kind !== "block") return null;
+    return topSlotEditor.blocks.value.find((b) => b.id === t.blockId) ?? null;
+  });
+  const activeBlockEntry = computed(() => {
+    const b = activeBlock.value;
+    return b ? findBlock(b.type, b.compatibilityDate) ?? null : null;
+  });
+  watch(
+    () => topSlotEditor.blocks.value.map((b) => b.id),
+    (ids) => {
+      const set = new Set(ids);
+      const next = [];
+      for (const e of stack.value) {
+        if (e.kind === "block" && !set.has(e.blockId)) break;
+        next.push(e);
+      }
+      if (next.length !== stack.value.length) stack.value = next;
+      if (topSlotEditor.selectedBlockIds.value.some((id) => !set.has(id))) {
+        topSlotEditor.selectedBlockIds.value = topSlotEditor.selectedBlockIds.value.filter((id) => set.has(id));
+      }
+    },
+    { flush: "sync" }
+  );
+  const subCrumbs = shallowRef([]);
+  const parentSuffixes = shallowRef([]);
+  function addCrumb() {
+    const crumb = {
+      label: ref(null),
+      back: ref(null),
+      dispose: () => {
+        subCrumbs.value = subCrumbs.value.filter((c) => c !== crumb);
+      }
+    };
+    subCrumbs.value = [...subCrumbs.value, crumb];
+    return crumb;
+  }
+  function addParentSuffix() {
+    const entry = {
+      value: ref(null),
+      dispose: () => {
+        parentSuffixes.value = parentSuffixes.value.filter((s) => s !== entry);
+      }
+    };
+    parentSuffixes.value = [...parentSuffixes.value, entry];
+    return entry;
+  }
+  function unwindSubCrumbsAfter(fromIndex) {
+    const snapshot = [...subCrumbs.value];
+    for (let i = snapshot.length - 1; i > fromIndex; i--) {
+      const cb = snapshot[i].back.value;
+      snapshot[i].back.value = null;
+      snapshot[i].label.value = null;
+      if (cb) cb();
+    }
+  }
+  function unwindSubCrumbs() {
+    unwindSubCrumbsAfter(-1);
+  }
+  const breadcrumbs = computed(() => {
+    const suffixes = parentSuffixes.value.map((s) => s.value.value).filter((v) => !!v);
+    const suffixDecoration = suffixes.length ? `\uFF08${suffixes.join("\u3001")}\uFF09` : "";
+    let lastBlockStackIndex = -1;
+    for (let i = stack.value.length - 1; i >= 0; i--) {
+      if (stack.value[i].kind === "block") {
+        lastBlockStackIndex = i;
+        break;
+      }
+    }
+    const base = stack.value.map((entry, i) => {
+      if (entry.kind === "layout") return { kind: "layout", label: "\u5E03\u5C40", index: i };
+      const b = topSlotEditor.blocks.value.find((x) => x.id === entry.blockId);
+      const meta = b ? findBlock(b.type, b.compatibilityDate)?.metadata : void 0;
+      const baseLabel = meta?.name ?? "\u5757";
+      const label = i === lastBlockStackIndex ? `${baseLabel}${suffixDecoration}` : baseLabel;
+      return {
+        kind: "block",
+        label,
+        index: i,
+        blockId: entry.blockId
+      };
+    });
+    const subs = subCrumbs.value;
+    const visibleFlags = subs.map((c) => !!c.label.value);
+    let deeperHasBack = false;
+    const clickable = subs.map(() => false);
+    for (let i = subs.length - 1; i >= 0; i--) {
+      clickable[i] = deeperHasBack;
+      if (visibleFlags[i] && subs[i].back.value) deeperHasBack = true;
+    }
+    for (let i = 0; i < subs.length; i++) {
+      if (visibleFlags[i]) {
+        base.push({
+          kind: "sub",
+          label: subs[i].label.value,
+          subIndex: i,
+          clickable: clickable[i]
+        });
+      }
+    }
+    return base;
+  });
+  function goTo(index) {
+    if (subCrumbs.value.some((c) => c.back.value)) {
+      unwindSubCrumbs();
+    }
+    if (index < 0 || index >= stack.value.length - 1) return;
+    stack.value = stack.value.slice(0, index + 1);
+  }
+  function goToSub(subIndex) {
+    if (subIndex < 0 || subIndex >= subCrumbs.value.length) return;
+    unwindSubCrumbsAfter(subIndex);
+  }
+  function popOne() {
+    if (subCrumbs.value.some((c) => c.back.value)) {
+      unwindSubCrumbs();
+      return;
+    }
+    if (stack.value.length <= 1) return;
+    stack.value = stack.value.slice(0, -1);
+  }
+  function pushBlock(blockId) {
+    if (!topSlotEditor.blocks.value.some((b) => b.id === blockId)) return;
+    stack.value = [...stack.value, { kind: "block", blockId }];
+    topSlotEditor.selectedBlockIds.value = [blockId];
+  }
+  function addBlock(entry, opts) {
+    topSlotEditor.addBlock(entry, opts);
+  }
+  function updateActiveBlock(next) {
+    const id = activeBlock.value?.id;
+    if (!id) return;
+    topSlotEditor.updateBlock(id, next);
+  }
+  function onDrillDown(blockId) {
+    pushBlock(blockId);
+  }
+  const validationError = ref(null);
+  function confirm() {
+    const schema = PageConfig(configure);
+    try {
+      const decoded = Schema.decodeUnknownSync(schema)(draft.value);
+      validationError.value = null;
+      model.value = decoded;
+      baseline.value = deepClone(decoded);
+      draft.value = deepClone(decoded);
+      stack.value = [{ kind: "layout" }];
+      topSlotEditor.selectedBlockIds.value = [];
+      topSlotEditor.activeLayoutIndex.value = 0;
+      subCrumbs.value = [];
+      parentSuffixes.value = [];
+      options.onClose?.();
+    } catch (err) {
+      validationError.value = formatError(err);
+    }
+  }
+  function reset() {
+    baseline.value = deepClone(model.value);
+    draft.value = deepClone(model.value);
+    stack.value = [{ kind: "layout" }];
+    topSlotEditor.selectedBlockIds.value = [];
+    topSlotEditor.activeLayoutIndex.value = 0;
+    validationError.value = null;
+    subCrumbs.value = [];
+    parentSuffixes.value = [];
+  }
+  function dismiss() {
+    reset();
+    options.onClose?.();
+  }
+  watch(draft, () => {
+    if (validationError.value) validationError.value = null;
+  }, { deep: true });
+  return {
+    draft,
+    stack,
+    selectedBlockIds: topSlotEditor.selectedBlockIds,
+    activeLayoutIndex: topSlotEditor.activeLayoutIndex,
+    validationError,
+    addCrumb,
+    addParentSuffix,
+    isDirty,
+    blocks: topSlotEditor.blocks,
+    layouts: topSlotEditor.layouts,
+    top,
+    activeBlock,
+    activeBlockEntry,
+    breadcrumbs,
+    pickerEntries: topSlotEditor.pickerEntries,
+    configure,
+    goTo,
+    goToSub,
+    popOne,
+    pushBlock,
+    addBlock,
+    removeBlock: topSlotEditor.removeBlock,
+    removeBlocks: topSlotEditor.removeBlocks,
+    updateActiveBlock,
+    setLayouts: topSlotEditor.setLayouts,
+    getBlockLabel: topSlotEditor.getBlockLabel,
+    findBlockMeta: topSlotEditor.findBlockMeta,
+    onDrillDown,
+    confirm,
+    dismiss,
+    reset
+  };
+}

package/dist/runtime/components/config/utils/block-ref-cache.d.ts

@@ -0,0 +1,9 @@
+import type { Schema } from 'effect';
+import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+type AnySchema = Schema.Schema<any, any, never>;
+export declare function registerBlockRef(configure: (env: Environment) => void, ref: AnySchema): void;
+export declare function lookupBlockRef(configure: (env: Environment) => void): AnySchema | undefined;
+type FindBlockFn = (type: string, compatibilityDate: string) => any | undefined;
+export declare function registerFindBlock(fn: FindBlockFn): void;
+export declare function lookupFindBlock(): FindBlockFn | null;
+export {};

package/dist/runtime/components/config/utils/block-ref-cache.js

@@ -0,0 +1,14 @@
+const blockRefCache = /* @__PURE__ */ new WeakMap();
+export function registerBlockRef(configure, ref) {
+  blockRefCache.set(configure, ref);
+}
+export function lookupBlockRef(configure) {
+  return blockRefCache.get(configure);
+}
+let findBlockImpl = null;
+export function registerFindBlock(fn) {
+  findBlockImpl = fn;
+}
+export function lookupFindBlock() {
+  return findBlockImpl;
+}

package/dist/runtime/components/config/utils/resolve.d.ts

@@ -0,0 +1,39 @@
+import type { Component } from 'vue';
+import { Schema } from 'effect';
+import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+type AnySchema = Schema.Schema<any, any, never>;
+/**
+ * Container blocks (e.g. tabs) receive a recursive `blockRef` second arg so
+ * their inner `Slot` accepts the same discriminated union of blocks —
+ * including themselves. Leaf blocks accept and ignore it.
+ */
+type SchemaFactory = (configure: (env: Environment) => void, blockRef: AnySchema) => AnySchema;
+export type BlockSizeRange = Readonly<{
+    initial: number;
+    min: number;
+    max: number;
+}>;
+export type BlockMetadata = Readonly<{
+    name: string;
+    icon: string;
+    w: BlockSizeRange;
+    h: BlockSizeRange;
+}>;
+export type BlockEntry = Readonly<{
+    type: string;
+    compatibilityDate: string;
+    metadata: BlockMetadata;
+    schema: SchemaFactory;
+    defaultBody: () => Record<string, unknown>;
+    config: Component;
+    runtime: Component;
+}>;
+export declare const BLOCKS: ReadonlyArray<BlockEntry>;
+/**
+ * Returns the recursive `Schema.suspend`-fronted union of all registered
+ * block schemas. Container blocks pass this into `Slot(blockRef, configure)`.
+ */
+export declare function blockRef(configure: (env: Environment) => void): AnySchema;
+export declare function allBlockSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;
+export declare function findBlock(type: string, compatibilityDate: string): BlockEntry | undefined;
+export {};

package/dist/runtime/components/config/utils/resolve.js

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+import { defineRegistry } from "../../../share/define-registry.js";
+import { registerBlockRef, registerFindBlock } from "./block-ref-cache.js";
+const schemaModules = import.meta.glob(
+  "../blocks/*/*/schema.ts",
+  { eager: true }
+);
+const configModules = import.meta.glob(
+  "../blocks/*/*/config.vue",
+  { eager: true, import: "default" }
+);
+const runtimeModules = import.meta.glob(
+  "../blocks/*/*/runtime.vue",
+  { eager: true, import: "default" }
+);
+const registry = defineRegistry({
+  hostName: "shwfed-config",
+  dirSegment: "blocks",
+  schemaModules,
+  configModules,
+  runtimeModules
+});
+export const BLOCKS = registry.ENTRIES.map((e) => ({
+  type: e.type,
+  compatibilityDate: e.compatibilityDate,
+  metadata: e.module.metadata,
+  schema: e.module.schema,
+  defaultBody: e.module.defaultBody,
+  config: e.config,
+  runtime: e.runtime
+}));
+const unionCache = /* @__PURE__ */ new WeakMap();
+function getOrBuildUnion(configure) {
+  const cached = unionCache.get(configure);
+  if (cached) return cached;
+  const entry = {
+    blockRef: null,
+    members: null,
+    union: null
+  };
+  entry.blockRef = Schema.suspend(() => {
+    if (!entry.union) {
+      throw new Error("[shwfed-config] BlockRef resolved before union built \u2014 circular factory init");
+    }
+    return entry.union;
+  });
+  unionCache.set(configure, entry);
+  registerBlockRef(configure, entry.blockRef);
+  entry.members = BLOCKS.map((b) => b.schema(configure, entry.blockRef));
+  entry.union = entry.members.length === 1 ? entry.members[0] : Schema.Union(...entry.members);
+  return entry;
+}
+export function blockRef(configure) {
+  return getOrBuildUnion(configure).blockRef;
+}
+export function allBlockSchemas(configure) {
+  return getOrBuildUnion(configure).members;
+}
+export function findBlock(type, compatibilityDate) {
+  return BLOCKS.find((b) => b.type === type && b.compatibilityDate === compatibilityDate);
+}
+registerFindBlock(findBlock);

package/dist/runtime/components/form/config.d.vue.ts

@@ -0,0 +1,16 @@
+import { Environment } from '../../vendor/cel-js/lib/index.js';
+import { type FormConfigValue } from './schema.js';
+type __VLS_Props = {
+    configure?: (env: Environment) => void;
+};
+type __VLS_ModelProps = {
+    modelValue: FormConfigValue;
+};
+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: FormConfigValue) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: FormConfigValue) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/form/config.vue

@@ -0,0 +1,111 @@
+<script setup>
+import { computed, ref } from "vue";
+import { Environment } from "../../vendor/cel-js/lib/index";
+import {
+  provideCELContext
+} from "../../plugins/cel/context";
+import { ExpressionEditor } from "../ui/expression-editor";
+import { Field, FieldLabel } from "../ui/field";
+import { Markdown } from "../ui/markdown";
+import {
+  FormConfig,
+  getStructFieldDescription,
+  getStructFieldTitle
+} from "./schema";
+import ShwfedFormUnitConfig, {} from "./unit-config.vue";
+defineOptions({ name: "ShwfedFormConfig" });
+const config = defineModel({ type: Object, ...{ required: true } });
+const props = defineProps({
+  configure: { type: Function, required: false }
+});
+const configure = props.configure ?? (() => {
+});
+const formConfigSchema = FormConfig(configure);
+const generalFieldTitle = (f) => getStructFieldTitle(formConfigSchema, f) ?? f;
+const generalFieldDescription = (f) => getStructFieldDescription(formConfigSchema, f);
+const advertisedContext = (() => {
+  const probe = new Environment({ unlistedVariablesAreDyn: false });
+  const baseline = new Set(probe.getDefinitions().variables.map((v) => v.name));
+  configure(probe);
+  const out = {
+    form: {
+      type: "dyn",
+      label: "\u8868\u5355\u503C",
+      description: "\u5F53\u524D\u8868\u5355\u72B6\u6001",
+      value: void 0
+    },
+    // Mirrors the runtime `now` binding in `form/index.vue`. Editor never
+    // evaluates so we leave `value` undefined.
+    now: {
+      type: "Date",
+      label: "now",
+      description: "\u5F53\u524D\u65E5\u671F/\u65F6\u95F4",
+      value: void 0
+    }
+  };
+  for (const v of probe.getDefinitions().variables) {
+    if (baseline.has(v.name)) continue;
+    out[v.name] = {
+      type: v.type,
+      label: v.name,
+      description: v.description ?? void 0,
+      value: void 0
+    };
+  }
+  return out;
+})();
+provideCELContext(advertisedContext);
+const unitModel = computed({
+  get: () => ({ fields: config.value.fields, layouts: config.value.layouts }),
+  set: (next) => {
+    config.value = { ...config.value, fields: next.fields, layouts: next.layouts };
+  }
+});
+const EXTRAS = [
+  { id: "general", label: "\u901A\u7528\u914D\u7F6E", icon: "fluent:settings-20-regular" }
+];
+const selection = ref({ kind: "extras", id: "general" });
+function updateInitial(value) {
+  const next = { ...config.value };
+  if (value.trim() === "") {
+    const { initial: _omit, ...rest } = next;
+    config.value = rest;
+  } else {
+    config.value = { ...next, initial: value };
+  }
+}
+</script>
+
+<template>
+  <ShwfedFormUnitConfig
+    v-model="unitModel"
+    v-model:selection="selection"
+    :extras="EXTRAS"
+  >
+    <template #extras-pane>
+      <Field orientation="vertical">
+        <FieldLabel class="text-xs text-zinc-500">
+          <template
+            v-if="generalFieldDescription('initial')"
+            #tooltip
+          >
+            <Markdown
+              :source="generalFieldDescription('initial')"
+              block
+              class="prose prose-sm prose-zinc"
+            />
+          </template>
+          {{ generalFieldTitle("initial") }}
+        </FieldLabel>
+        <ExpressionEditor
+          :model-value="config.initial ?? ''"
+          placeholder="如 { 'name': '', 'age': 0 }"
+          result-type="dyn"
+          multiline
+          class="min-h-20"
+          @update:model-value="updateInitial"
+        />
+      </Field>
+    </template>
+  </ShwfedFormUnitConfig>
+</template>

package/dist/runtime/components/form/config.vue.d.ts

@@ -0,0 +1,16 @@
+import { Environment } from '../../vendor/cel-js/lib/index.js';
+import { type FormConfigValue } from './schema.js';
+type __VLS_Props = {
+    configure?: (env: Environment) => void;
+};
+type __VLS_ModelProps = {
+    modelValue: FormConfigValue;
+};
+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: FormConfigValue) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: FormConfigValue) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/form/field-layout.d.ts

@@ -0,0 +1,5 @@
+import type { InjectionKey, Ref } from 'vue';
+export interface FormFieldLayoutExtension {
+    fullPane: Ref<boolean>;
+}
+export declare const FORM_FIELD_LAYOUT_KEY: InjectionKey<FormFieldLayoutExtension>;

package/dist/runtime/components/form/field-layout.js

@@ -0,0 +1 @@
+export const FORM_FIELD_LAYOUT_KEY = Symbol("shwfed.form.field-layout");