@shwfed/config 2.0.0 → 2.0.1

package/dist/runtime/components/form/utils/common.js

@@ -0,0 +1,57 @@
+import { Schema } from "effect";
+import { Expression } from "../../../share/expression.js";
+import { md } from "../../../share/markdown.js";
+export function commonFieldFields(configure) {
+  const CelBool = Expression({ configure, resultType: "bool" });
+  return {
+    id: Schema.UUID.annotations({ description: "\u5B57\u6BB5\u552F\u4E00\u6807\u8BC6\uFF1B\u5E03\u5C40\u901A\u8FC7\u8BE5 id \u5F15\u7528\u5B57\u6BB5" }),
+    displayName: Schema.optional(Schema.String.annotations({
+      title: "\u5185\u90E8\u540D\u79F0",
+      description: "\u4EC5\u5728\u7F16\u8F91\u5668\u5185\u53EF\u89C1\u7684\u5B57\u6BB5\u540D\uFF0C\u7528\u4E8E\u5728\u4FA7\u8FB9\u680F\u548C\u5E03\u5C40\u7F16\u8F91\u5668\u4E2D\u8BC6\u522B\u5B57\u6BB5\uFF1B\u8FD0\u884C\u65F6\u4E0D\u5C55\u793A"
+    })),
+    hidden: Schema.optional(CelBool.annotations({
+      title: "\u9690\u85CF\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u5B57\u6BB5\u5728\u6240\u6709\u5E03\u5C40\u4E2D\u90FD\u4E0D\u6E32\u67D3"
+    }))
+  };
+}
+export const FIELD_ORIENTATIONS = ["vertical", "floating"];
+export const FIELD_ORIENTATION_OPTIONS = [
+  { value: "vertical", label: "\u5782\u76F4\uFF08\u6807\u7B7E\u5728\u4E0A\uFF09" },
+  { value: "floating", label: "\u6D6E\u52A8\uFF08\u6807\u7B7E\u5D4C\u5165\u8F93\u5165\u6846\uFF09" }
+];
+export const FieldOrientationSchema = Schema.Literal(...FIELD_ORIENTATIONS).annotations({
+  title: "\u65B9\u5411",
+  description: "\u6807\u7B7E\u4E0E\u8F93\u5165\u6846\u7684\u6392\u5217\u65B9\u5411"
+});
+export const DEFAULT_FIELD_ORIENTATION = "vertical";
+export const DERIVED_MODES = ["formula", "prefill"];
+export const DERIVED_MODE_LABELS = {
+  formula: "\u8BA1\u7B97\u503C",
+  prefill: "\u667A\u80FD\u586B\u5145"
+};
+export function derivedField(configure, resultType) {
+  return Schema.optional(
+    Schema.Struct({
+      mode: Schema.Literal(...DERIVED_MODES).annotations({
+        title: "\u6D3E\u751F\u65B9\u5F0F",
+        description: "`\u8BA1\u7B97\u503C` \u53EA\u8BFB\u3001\u59CB\u7EC8\u4EE5\u8868\u8FBE\u5F0F\u4E3A\u51C6\uFF1B`\u667A\u80FD\u586B\u5145` \u53EF\u7F16\u8F91\u3001\u7528\u6237\u4FEE\u6539\u540E\u4EE5\u7528\u6237\u4E3A\u51C6"
+      }),
+      expression: Expression({ configure, resultType }).annotations({
+        title: "\u8868\u8FBE\u5F0F",
+        description: "\u8FD4\u56DE\u8BE5\u5B57\u6BB5\u503C\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u53EF\u8BBF\u95EE `form` \u5F53\u524D\u8868\u5355\u72B6\u6001"
+      })
+    }).annotations({
+      title: "\u6D3E\u751F\u503C",
+      description: md`
+        该字段值的**派生来源**，二选一：
+
+        - **计算值**：字段变为只读，其值始终由表达式计算得出，依赖字段提交时重算。
+
+        - **智能填充**：字段保持可编辑。用户未手动修改前由表达式持续计算并填入；一旦用户手动修改（含清空），即以用户输入为准，表达式不再覆盖。
+
+        两种方式都支持异步调用（如 \`http.get(...)\`）。
+      `
+    })
+  );
+}

package/dist/runtime/components/form/utils/derived.d.ts

@@ -0,0 +1,72 @@
+import { Effect } from 'effect';
+import type { Ref } from 'vue';
+import type { FieldValue } from '../schema.js';
+import type { FormStateBag } from './state.js';
+/**
+ * Structural equality over JSON-ish values (the shape a derived expression
+ * returns: primitives, arrays, plain objects, `Date`). It is load-bearing: a
+ * derived value writes its result back into form state, which re-triggers the
+ * expression; a shallow `Object.is` would see a fresh-but-equal array/object
+ * as a change and loop forever. With deep equality a settled expression's
+ * re-write is a no-op and cascades converge.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+export type DerivedQuiescence = {
+    /** Count of derived-value evaluations currently in flight, form-wide. */
+    inFlight: Ref<number>;
+    begin: () => void;
+    end: () => void;
+    /** Resolves once every derived value — including cascades — has settled. */
+    settled: () => Promise<void>;
+};
+/**
+ * Provide the form-wide derivation quiescence tracker. Called once at the
+ * top-level form host; nested list rows inherit it, so `settled()` waits on
+ * every derived value in the form — top-level and row-level alike.
+ */
+export declare function provideDerivedQuiescence(): DerivedQuiescence;
+/**
+ * Inject the form's quiescence tracker. Falls back to a standalone instance
+ * when mounted outside a form host.
+ */
+export declare function useDerivedQuiescence(): DerivedQuiescence;
+export type DerivedOptions = {
+    /**
+     * Every field of this form unit. Derived values run regardless of layout
+     * placement or `hidden` state — a hidden derived field still feeds
+     * submission.
+     */
+    fields: () => ReadonlyArray<FieldValue>;
+    /** Evaluate a derived expression against the host's CEL context. */
+    evaluate: (expression: string) => Effect.Effect<unknown, unknown>;
+    /**
+     * Derived values start only after this resolves — the top-level form passes
+     * its `initial` seed promise so first-paint uses the seed, then derivation
+     * takes over; list rows pass an already-resolved promise.
+     */
+    ready: Promise<void>;
+    /**
+     * The form unit's state bag — the top form's or a list row's. Passed
+     * explicitly rather than injected: `useDerived` runs in the very component
+     * that provides the bag, and a component cannot inject its own provide.
+     */
+    formState: FormStateBag;
+    /** The form-wide derivation quiescence tracker (provided at the top form). */
+    quiescence: DerivedQuiescence;
+};
+/**
+ * Maintains every derived field's value in this form unit. A field carrying a
+ * `derived` config is computed from a CEL expression and written back to its
+ * `binding`, recomputed whenever committed form state changes. Two modes:
+ *
+ * - `formula` — the field is read-only; its value is *always* the expression's
+ *   result.
+ * - `prefill` — the field stays editable; the expression only fills it while
+ *   the user has not touched the binding. Once `formState.isDirty(binding)` is
+ *   true the user has taken over and the expression no longer writes.
+ *
+ * Mounted by each form-unit host — the top form and every list row — so a row
+ * derived value evaluates `item`/writes row state, a top-level one evaluates
+ * `form`/writes form state, all sharing one quiescence tracker.
+ */
+export declare function useDerived(options: DerivedOptions): void;

package/dist/runtime/components/form/utils/derived.js

@@ -0,0 +1,116 @@
+import { Effect } from "effect";
+import { computed, inject, nextTick, onScopeDispose, provide, ref, watch } from "vue";
+export function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  if (a instanceof Date || b instanceof Date) {
+    return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+  }
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => deepEqual(v, b[i]));
+  }
+  const ak = Object.keys(a);
+  const bk = Object.keys(b);
+  if (ak.length !== bk.length) return false;
+  return ak.every(
+    (k) => Object.prototype.hasOwnProperty.call(b, k) && deepEqual(a[k], b[k])
+  );
+}
+const QUIESCENCE_KEY = Symbol("shwfed-form-derived-quiescence");
+function createQuiescence() {
+  const inFlight = ref(0);
+  return {
+    inFlight,
+    begin: () => {
+      inFlight.value += 1;
+    },
+    end: () => {
+      inFlight.value -= 1;
+    },
+    async settled() {
+      for (; ; ) {
+        if (inFlight.value > 0) {
+          await new Promise((resolve) => {
+            const stop = watch(inFlight, (n) => {
+              if (n === 0) {
+                stop();
+                resolve();
+              }
+            });
+          });
+        }
+        await nextTick();
+        if (inFlight.value === 0) return;
+      }
+    }
+  };
+}
+export function provideDerivedQuiescence() {
+  const q = createQuiescence();
+  provide(QUIESCENCE_KEY, q);
+  return q;
+}
+export function useDerivedQuiescence() {
+  return inject(QUIESCENCE_KEY, null) ?? createQuiescence();
+}
+export function useDerived(options) {
+  const { state, getAt, setAtSilent, isDirty, markDirty } = options.formState;
+  const quiescence = options.quiescence;
+  const derivedFields = computed(
+    () => options.fields().flatMap((field) => {
+      const binding = field.binding;
+      const derived = field.derived;
+      if (typeof binding !== "string" || !derived || typeof derived !== "object") return [];
+      const mode = derived.mode;
+      const expression = derived.expression;
+      if (mode !== "formula" && mode !== "prefill" || typeof expression !== "string") return [];
+      return [{ binding, mode, expression }];
+    })
+  );
+  let generation = 0;
+  let started = false;
+  function evaluateField(field, gen) {
+    quiescence.begin();
+    Effect.runPromise(options.evaluate(field.expression)).then(
+      (result) => {
+        if (gen !== generation) return;
+        if (field.mode === "prefill" && isDirty(field.binding)) return;
+        if (!deepEqual(getAt(field.binding), result)) setAtSilent(field.binding, result);
+      },
+      () => {
+      }
+    ).finally(() => {
+      quiescence.end();
+    });
+  }
+  function runAll() {
+    const gen = generation += 1;
+    for (const field of derivedFields.value) evaluateField(field, gen);
+  }
+  watch([state, derivedFields], () => {
+    if (started) runAll();
+  });
+  function claimSeededValues() {
+    for (const field of derivedFields.value) {
+      if (field.mode === "prefill" && getAt(field.binding) !== void 0) {
+        markDirty(field.binding);
+      }
+    }
+  }
+  let disposed = false;
+  onScopeDispose(() => {
+    disposed = true;
+  });
+  options.ready.then(() => {
+    if (disposed) return;
+    started = true;
+    claimSeededValues();
+    runAll();
+  }, () => {
+    if (disposed) return;
+    started = true;
+    claimSeededValues();
+    runAll();
+  });
+}

package/dist/runtime/components/form/utils/field-value.d.ts

@@ -0,0 +1,35 @@
+import type { ComputedRef, WritableComputedRef } from 'vue';
+export type FieldValueController<T> = {
+    /**
+     * Live draft — bind to the input's `v-model`. Updates on every keystroke,
+     * but does NOT reach form state until `commit()` runs.
+     */
+    draft: WritableComputedRef<T>;
+    /** `true` while the draft holds an uncommitted user edit. */
+    dirty: ComputedRef<boolean>;
+    /** Flush the draft into form state. Wire to `@blur` / Enter / clear. */
+    commit: () => void;
+};
+export type FieldValueOptions<T> = {
+    /** Bound dot-prop path; `undefined` ⇒ uncontrolled (no form-state slot). */
+    binding: () => string | undefined;
+    /** Normalize a raw form-state value into the display-typed draft. */
+    fromState: (raw: unknown) => T;
+    /** Normalize the draft into the value written to form state. */
+    toState: (draft: T) => unknown;
+    /** Equality for dirty-detection; defaults to `Object.is`. */
+    equals?: (a: T, b: T) => boolean;
+};
+/**
+ * Splits a text-like field's value into a live `draft` and the committed
+ * form-state value. Keystrokes move the draft; `commit()` (wired to blur) is
+ * the only thing that writes form state — so every CEL expression and
+ * derived value reading `form` sees a stable per-commit cadence rather than
+ * per-keystroke churn.
+ *
+ * An external write to the committed value (initial seed, reset, parent
+ * v-model, a later derived write-back) reverse-syncs into the draft — unless
+ * the draft is dirty, so a mid-edit value the user has not committed is
+ * never clobbered.
+ */
+export declare function useFieldValue<T>(options: FieldValueOptions<T>): FieldValueController<T>;

package/dist/runtime/components/form/utils/field-value.js

@@ -0,0 +1,40 @@
+import { computed, onBeforeUnmount, ref, watch } from "vue";
+import { useCommitBus } from "./commit-bus.js";
+import { useFormState } from "./state.js";
+export function useFieldValue(options) {
+  const { getAt, setAt } = useFormState();
+  const equals = options.equals ?? Object.is;
+  const uncontrolled = ref(void 0);
+  const committed = computed(() => {
+    const path = options.binding();
+    const raw = path == null ? uncontrolled.value : getAt(path);
+    return options.fromState(raw);
+  });
+  const local = ref(committed.value);
+  const touched = ref(false);
+  const draft = computed({
+    get: () => local.value,
+    set: (next) => {
+      local.value = next;
+      touched.value = true;
+    }
+  });
+  function commit() {
+    if (!touched.value) return;
+    touched.value = false;
+    if (equals(local.value, committed.value)) return;
+    const path = options.binding();
+    const next = options.toState(local.value);
+    if (path == null) uncontrolled.value = next;
+    else setAt(path, next);
+  }
+  watch(committed, (next) => {
+    if (!touched.value) local.value = next;
+  });
+  const unregister = useCommitBus().register(commit);
+  onBeforeUnmount(() => {
+    unregister();
+    commit();
+  });
+  return { draft, dirty: computed(() => touched.value), commit };
+}

package/dist/runtime/components/form/utils/history.d.ts

@@ -0,0 +1,36 @@
+import type { Ref } from 'vue';
+import type { DerivedQuiescence } from './derived.js';
+import type { FormState } from './state.js';
+/**
+ * Deep clone over the form-state value space — primitives, `null`, arrays,
+ * plain objects, and `Date` (constructor preserved, so a `Date` subclass
+ * stays an instance of itself). `File`/`Blob` are immutable and shared by
+ * reference rather than copied.
+ *
+ * Used to snapshot form state into the undo history: `setAt` mutates nested
+ * objects in place, so a stored snapshot must be a structural copy or a
+ * later edit would reach back and corrupt history.
+ */
+export declare function deepClone<T>(value: T): T;
+export type FormHistory = {
+    undo: () => void;
+    redo: () => void;
+    canUndo: Ref<boolean>;
+    canRedo: Ref<boolean>;
+};
+/**
+ * Whole-form undo/redo. One snapshot is recorded per user-initiated change —
+ * a field commit plus the derivation cascade it triggers — taken once that
+ * cascade settles, so an undo step always lands on a coherent derived state.
+ *
+ * `useManualRefHistory` is deliberate over `useRefHistory`: snapshots are
+ * driven by commit boundaries, not by every `state` mutation (which would
+ * record per-keystroke and per-derivation-write churn). It tracks a private
+ * `{ state, dirty }` composite ref; undo/redo restore both back into the
+ * live `state` / `dirty` refs.
+ */
+export declare function useFormHistory(state: Ref<FormState>, options: {
+    quiescence: DerivedQuiescence;
+    seeded: Promise<void>;
+    dirty: Ref<Set<string>>;
+}): FormHistory;

package/dist/runtime/components/form/utils/history.js

@@ -0,0 +1,74 @@
+import { useManualRefHistory } from "@vueuse/core";
+import { nextTick, ref, watch } from "vue";
+import { deepEqual } from "./derived.js";
+export function deepClone(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Date) {
+    return new value.constructor(value.getTime());
+  }
+  if (typeof File !== "undefined" && value instanceof File) return value;
+  if (typeof Blob !== "undefined" && value instanceof Blob) return value;
+  if (Array.isArray(value)) return value.map((v) => deepClone(v));
+  const out = {};
+  for (const key of Object.keys(value)) {
+    out[key] = deepClone(value[key]);
+  }
+  return out;
+}
+function sameDirty(a, b) {
+  return a.length === b.length && a.every((p) => b.includes(p));
+}
+export function useFormHistory(state, options) {
+  const { dirty } = options;
+  function capture() {
+    return { state: state.value, dirty: [...dirty.value] };
+  }
+  function clone(s) {
+    return { state: deepClone(s.state), dirty: [...s.dirty] };
+  }
+  const tracked = ref(capture());
+  const history = useManualRefHistory(tracked, {
+    dump: clone,
+    parse: clone,
+    capacity: 50
+  });
+  let navigating = false;
+  let recording = false;
+  let snapshotPending = false;
+  async function scheduleSnapshot() {
+    if (snapshotPending) return;
+    snapshotPending = true;
+    await options.quiescence.settled();
+    snapshotPending = false;
+    if (!recording || navigating) return;
+    tracked.value = capture();
+    const last = history.last.value.snapshot;
+    if (!deepEqual(tracked.value.state, last.state) || !sameDirty(tracked.value.dirty, last.dirty)) {
+      history.commit();
+    }
+  }
+  watch(state, () => {
+    if (recording && !navigating) void scheduleSnapshot();
+  });
+  options.seeded.then(() => options.quiescence.settled()).then(() => {
+    tracked.value = capture();
+    history.commit();
+    history.clear();
+    recording = true;
+  });
+  function navigate(run) {
+    navigating = true;
+    run();
+    state.value = deepClone(tracked.value.state);
+    dirty.value = new Set(tracked.value.dirty);
+    void nextTick(() => {
+      navigating = false;
+    });
+  }
+  return {
+    undo: () => navigate(() => history.undo()),
+    redo: () => navigate(() => history.redo()),
+    canUndo: history.canUndo,
+    canRedo: history.canRedo
+  };
+}

package/dist/runtime/components/form/utils/readonly.d.ts

@@ -0,0 +1,8 @@
+import type { Ref } from 'vue';
+/** Provide the form-wide readonly flag. Called once at the top-level form. */
+export declare function provideFormReadonly(readonly: Ref<boolean>): void;
+/**
+ * Inject the form-wide readonly flag. Falls back to a never-readonly ref when
+ * a field is mounted outside a form host.
+ */
+export declare function useFormReadonly(): Ref<boolean>;

package/dist/runtime/components/form/utils/readonly.js

@@ -0,0 +1,9 @@
+import { inject, provide, ref } from "vue";
+const FORM_READONLY_KEY = Symbol("shwfed-form-readonly");
+const NEVER_READONLY = ref(false);
+export function provideFormReadonly(readonly) {
+  provide(FORM_READONLY_KEY, readonly);
+}
+export function useFormReadonly() {
+  return inject(FORM_READONLY_KEY, NEVER_READONLY);
+}

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

@@ -0,0 +1,77 @@
+import type { Component } from 'vue';
+import type { Effect, Schema } from 'effect';
+import type { Environment } from '../../../vendor/cel-js/lib/index.js';
+type AnySchema = Schema.Schema<any, any, never>;
+type SchemaFactory = (configure: (env: Environment) => void) => AnySchema;
+/**
+ * Capabilities a migration function may need from the host. Currently exposes
+ * the Nuxt-provided CEL evaluator so legacy fields with embedded CEL
+ * expressions can be evaluated during the rewrite. New capabilities are
+ * additive — extend this type rather than introducing a parallel context.
+ */
+export type MigrationContext = Readonly<{
+    $cel: <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, unknown>;
+}>;
+/**
+ * Migrates a value of the previous compatibilityDate's schema to this entry's
+ * schema. Lives on the *target* (newer) entry. The Effect's success channel
+ * is the migrated value; failures surface to the host as a toast — see
+ * src/runtime/components/form/config.vue's migrate handler.
+ */
+export type MigrateFn = (prev: unknown, ctx: MigrationContext) => Effect.Effect<unknown, Error>;
+export type FieldSizeRange = Readonly<{
+    /** Span (in step units) used when the field is first placed. */
+    initial: number;
+    /** Lower bound (inclusive) the user may shrink the field to. */
+    min: number;
+    /** Upper bound (inclusive) the user may grow the field to. */
+    max: number;
+    /**
+     * When true, this axis escapes the grid's `1fr` equal-share and follows
+     * content instead. Currently honored only on `h` by the form runtime: any
+     * row track containing at least one visible field whose `h.grow` is true is
+     * rendered as `auto`, while other rows keep `minmax(0, 1fr)`.
+     */
+    grow?: boolean;
+}>;
+export type FieldMetadata = Readonly<{
+    name: string;
+    icon: string;
+    w: FieldSizeRange;
+    h: FieldSizeRange;
+}>;
+/**
+ * Optional creation-time defaults factory. Returns a partial config that
+ * merges into the seed when the user adds a new field, so newly-added fields
+ * arrive with sensible values populated. Schemas remain pure validators —
+ * defaults live here. Mirrors `getColumnDefaults` in table/config.vue.
+ */
+export type FieldDefaults = () => Record<string, any>;
+export type FieldEntry = Readonly<{
+    type: string;
+    compatibilityDate: string;
+    metadata: FieldMetadata;
+    schema: SchemaFactory;
+    config: Component;
+    runtime: Component;
+    /** True iff a newer entry with the same `type` exists in the registry. */
+    deprecated: boolean;
+    /** `compatibilityDate` of the newest entry sharing this `type`, when deprecated. */
+    supersededBy?: string;
+    /**
+     * Optional migration from the previous compatibilityDate's schema to this
+     * entry's schema. When present, the host renders a "迁移" button on
+     * deprecated fields whose superseding entry exposes this function.
+     */
+    migrate?: MigrateFn;
+    /**
+     * Optional creation-time defaults. The host merges the returned partial
+     * onto the seed when the user adds a new field via the picker. Absent →
+     * the field is created with only `{ id, type, compatibilityDate }`.
+     */
+    defaults?: FieldDefaults;
+}>;
+export declare const FIELDS: ReadonlyArray<FieldEntry>;
+export declare function allFieldSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;
+export declare function findField(type: string, compatibilityDate: string): FieldEntry | undefined;
+export {};

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

@@ -0,0 +1,74 @@
+import { defineRegistry } from "../../../share/define-registry.js";
+const schemaModules = import.meta.glob(
+  "../fields/*/*/schema.{ts,js}",
+  { eager: true, exhaustive: true }
+);
+const configModules = import.meta.glob(
+  "../fields/*/*/config.vue",
+  { eager: true, import: "default", exhaustive: true }
+);
+const runtimeModules = import.meta.glob(
+  "../fields/*/*/runtime.vue",
+  { eager: true, import: "default", exhaustive: true }
+);
+const registry = defineRegistry({
+  hostName: "shwfed-form",
+  dirSegment: "fields",
+  schemaModules,
+  configModules,
+  runtimeModules,
+  // An entry is deprecated iff another entry shares its `type` with a strictly
+  // greater `compatibilityDate`. The picker already shows only the latest per
+  // type; this flag drives the deprecation alert in the right-pane inspector.
+  deriveEntryExtras: (drafts) => {
+    const latestByType = /* @__PURE__ */ new Map();
+    for (const d of drafts) {
+      const prev = latestByType.get(d.type);
+      if (!prev || d.compatibilityDate > prev) latestByType.set(d.type, d.compatibilityDate);
+    }
+    return (draft) => {
+      const latest = latestByType.get(draft.type);
+      const deprecated = draft.compatibilityDate < latest;
+      return deprecated ? { deprecated: true, supersededBy: latest } : { deprecated: false };
+    };
+  }
+});
+let _fields = null;
+function getFields() {
+  if (_fields) return _fields;
+  _fields = registry.ENTRIES.map((e) => ({
+    type: e.type,
+    compatibilityDate: e.compatibilityDate,
+    metadata: e.module.metadata,
+    schema: e.module.schema,
+    config: e.config,
+    runtime: e.runtime,
+    deprecated: e.deprecated,
+    ...e.supersededBy !== void 0 ? { supersededBy: e.supersededBy } : {},
+    migrate: e.module.migrate,
+    defaults: e.module.defaults
+  }));
+  return _fields;
+}
+export const FIELDS = new Proxy([], {
+  get(_, prop) {
+    const list = getFields();
+    const v = list[prop];
+    return typeof v === "function" ? v.bind(list) : v;
+  },
+  has(_, prop) {
+    return prop in getFields();
+  },
+  ownKeys() {
+    return Reflect.ownKeys(getFields());
+  },
+  getOwnPropertyDescriptor(_, prop) {
+    return Reflect.getOwnPropertyDescriptor(getFields(), prop);
+  }
+});
+export function allFieldSchemas(configure) {
+  return getFields().map((entry) => entry.schema(configure));
+}
+export function findField(type, compatibilityDate) {
+  return getFields().find((f) => f.type === type && f.compatibilityDate === compatibilityDate);
+}

package/dist/runtime/components/form/utils/schema-meta.d.ts

@@ -0,0 +1,5 @@
+import { type Schema } from 'effect';
+type AnySchema = Schema.Schema<any, any, any>;
+export declare function getStructFieldTitle(schema: AnySchema, fieldName: string): string | undefined;
+export declare function getStructFieldDescription(schema: AnySchema, fieldName: string): string | undefined;
+export {};

package/dist/runtime/components/form/utils/schema-meta.js

@@ -0,0 +1,48 @@
+import { Option, SchemaAST } from "effect";
+function getTypeLiteral(ast) {
+  switch (ast._tag) {
+    case "TypeLiteral":
+      return ast;
+    case "Transformation":
+      return getTypeLiteral(ast.to);
+    case "Refinement":
+      return getTypeLiteral(ast.from);
+    case "Suspend":
+      return getTypeLiteral(ast.f());
+    default:
+      return null;
+  }
+}
+function findPropertySignature(schema, fieldName) {
+  const tl = getTypeLiteral(schema.ast);
+  if (!tl) return null;
+  return tl.propertySignatures.find((p) => p.name === fieldName) ?? null;
+}
+function resolveFieldType(ps) {
+  const t = ps.type;
+  if (t._tag === "Union" && ps.isOptional) {
+    const nonUndef = t.types.find((m) => m._tag !== "UndefinedKeyword");
+    if (nonUndef) return nonUndef;
+  }
+  return t;
+}
+function getFieldAnnotation(schema, fieldName, getter) {
+  const ps = findPropertySignature(schema, fieldName);
+  if (!ps) return void 0;
+  const fromPS = getter(ps);
+  if (Option.isSome(fromPS)) return fromPS.value;
+  const resolved = resolveFieldType(ps);
+  const fromResolved = getter(resolved);
+  if (Option.isSome(fromResolved)) return fromResolved.value;
+  if (resolved !== ps.type) {
+    const fromType = getter(ps.type);
+    if (Option.isSome(fromType)) return fromType.value;
+  }
+  return void 0;
+}
+export function getStructFieldTitle(schema, fieldName) {
+  return getFieldAnnotation(schema, fieldName, SchemaAST.getTitleAnnotation);
+}
+export function getStructFieldDescription(schema, fieldName) {
+  return getFieldAnnotation(schema, fieldName, SchemaAST.getDescriptionAnnotation);
+}