@shwfed/config 2.3.28 → 2.4.0

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/runtime.vue

@@ -0,0 +1,395 @@
+<script setup>
+import { Icon } from "@iconify/vue";
+import { Effect, Fiber, Option } from "effect";
+import { Fetch } from "fx-fetch";
+import { computed, ref, shallowRef, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { cel as _rawCel } from "../../../../../utils/cel";
+import { celBindings, injectCELContext } from "../../../../../utils/cel-context";
+import { getLocalizedText } from "../../../../../share/locale";
+import { Field, FieldLabel } from "../../../../ui/field";
+import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput } from "../../../../ui/input-group";
+import { Markdown } from "../../../../ui/markdown";
+import { Skeleton } from "../../../../ui/skeleton";
+import { Tree as UiTree } from "../../../../ui/tree";
+import { interpolateMarkdown } from "../../../../table/utils/runtime";
+import { useFormReadonly } from "../../../utils/readonly";
+import { useFormState } from "../../../utils/state";
+defineOptions({ name: "ShwfedTreeSingleFieldRuntime" });
+const props = defineProps({
+  fieldId: { type: String, required: true },
+  config: { type: null, required: true }
+});
+const { locale, t } = useI18n({
+  inheritLocale: true,
+  messages: {
+    zh: {
+      "tree-single-search-label": "\u641C\u7D22",
+      "tree-single-search-clear": "\u6E05\u9664\u641C\u7D22",
+      "tree-single-load-error": "\u52A0\u8F7D\u5931\u8D25",
+      "tree-single-empty": "\u65E0\u53EF\u9009\u9879",
+      "tree-single-readonly-empty": "\u2014"
+    },
+    en: {
+      "tree-single-search-label": "Search",
+      "tree-single-search-clear": "Clear search",
+      "tree-single-load-error": "Failed to load",
+      "tree-single-empty": "No options",
+      "tree-single-readonly-empty": "\u2014"
+    },
+    ja: {
+      "tree-single-search-label": "\u691C\u7D22",
+      "tree-single-search-clear": "\u691C\u7D22\u3092\u30AF\u30EA\u30A2",
+      "tree-single-load-error": "\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F",
+      "tree-single-empty": "\u9078\u629E\u80A2\u306A\u3057",
+      "tree-single-readonly-empty": "\u2014"
+    }
+  }
+});
+const { state, getAt, setAt } = useFormState();
+const inherited = injectCELContext();
+const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
+const labelText = computed(() => getLocalizedText(props.config.label, locale.value));
+const tooltipText = computed(
+  () => props.config.tooltip ? getLocalizedText(props.config.tooltip, locale.value) : void 0
+);
+function evalBool(expression, label) {
+  if (!expression) return false;
+  try {
+    return Effect.runSync($cel(expression, { form: state.value ?? {} }));
+  } catch (err) {
+    console.error(`[shwfed-form] failed to evaluate ${label} for ${props.fieldId}:`, err);
+    return false;
+  }
+}
+const isDisabled = computed(() => evalBool(props.config.disabled, "disabled"));
+const formReadonly = useFormReadonly();
+const isReadonly = computed(
+  () => props.config.readonly != null ? evalBool(props.config.readonly, "readonly") : formReadonly.value
+);
+const effectiveReadonly = computed(() => isReadonly.value || props.config.derived?.mode === "formula");
+const uncontrolled = ref(void 0);
+const model = computed({
+  get: () => {
+    const path = props.config.binding;
+    const raw = path == null ? uncontrolled.value : getAt(path);
+    return raw == null || raw === "" ? void 0 : String(raw);
+  },
+  set: (next) => {
+    const coerced = next == null ? void 0 : String(next);
+    const path = props.config.binding;
+    if (path == null) {
+      uncontrolled.value = coerced;
+      return;
+    }
+    setAt(path, coerced ?? "");
+  }
+});
+const roots = ref([]);
+const loading = ref(false);
+const fetchError = ref(null);
+async function fetchTree() {
+  const dataSource = props.config.dataSource;
+  if (!dataSource) {
+    roots.value = [];
+    return;
+  }
+  const effect = Effect.gen(function* () {
+    let jsonOpt = Option.none();
+    if (dataSource.request) {
+      const builder = yield* $cel(dataSource.request, {
+        form: state.value ?? {}
+      });
+      const response = yield* builder.json();
+      jsonOpt = Option.some(response);
+    }
+    const dataRaw = yield* $cel(dataSource.data, {
+      form: state.value ?? {},
+      json: jsonOpt
+    });
+    return Array.isArray(dataRaw) ? dataRaw : [];
+  });
+  const program = Effect.gen(function* () {
+    const showMaskFiber = yield* Effect.fork(
+      Effect.sync(() => {
+        loading.value = true;
+      }).pipe(Effect.delay("30 millis"))
+    );
+    return yield* Effect.ensuring(effect, Fiber.interrupt(showMaskFiber));
+  }).pipe(
+    Effect.ensuring(Effect.sync(() => {
+      loading.value = false;
+    }))
+  );
+  try {
+    const result = await Effect.runPromise(Effect.provide(program, Fetch.layer));
+    roots.value = result;
+    fetchError.value = null;
+  } catch (e) {
+    console.warn("[shwfed-form] tree dataSource fetch failed", e);
+    fetchError.value = e;
+  }
+}
+watch(
+  () => [props.config.dataSource?.request, props.config.dataSource?.data],
+  () => {
+    void fetchTree();
+  },
+  { immediate: true }
+);
+function nodeCtx(node) {
+  return { form: state.value ?? {}, node };
+}
+function getKey(node) {
+  try {
+    const v = Effect.runSync($cel(props.config.nodeKey, nodeCtx(node)));
+    return String(v);
+  } catch (err) {
+    console.error(`[shwfed-form] failed to evaluate nodeKey for ${props.fieldId}:`, err);
+    return "";
+  }
+}
+function getChildren(node) {
+  let raw;
+  try {
+    raw = Effect.runSync($cel(props.config.nodeChildren, nodeCtx(node)));
+  } catch (err) {
+    console.error(`[shwfed-form] failed to evaluate nodeChildren for ${props.fieldId}:`, err);
+    return void 0;
+  }
+  if (raw == null) return void 0;
+  if (!Array.isArray(raw)) return void 0;
+  if (raw.length === 0) return void 0;
+  return raw;
+}
+function nodeSelectable(node, _depth) {
+  if (isDisabled.value) return false;
+  const expr = props.config.nodeSelectable;
+  if (!expr) return true;
+  try {
+    return Effect.runSync($cel(expr, nodeCtx(node)));
+  } catch (err) {
+    console.error(`[shwfed-form] failed to evaluate nodeSelectable for ${props.fieldId}:`, err);
+    return false;
+  }
+}
+function safeInterpolate(tpl, node) {
+  try {
+    return interpolateMarkdown(tpl, $cel, { form: state.value ?? {}, node });
+  } catch (err) {
+    console.error(`[shwfed-form] failed to interpolate node text for ${props.fieldId}:`, err);
+    return tpl;
+  }
+}
+function nodeLabelText(node) {
+  const tpl = getLocalizedText(props.config.nodeLabel, locale.value) ?? "";
+  return tpl ? safeInterpolate(tpl, node) : "";
+}
+function nodeTooltipText(node) {
+  if (!props.config.nodeTooltip) return void 0;
+  const tpl = getLocalizedText(props.config.nodeTooltip, locale.value);
+  if (!tpl) return void 0;
+  return safeInterpolate(tpl, node);
+}
+const initialExpanded = computed(() => {
+  if (!props.config.expandAll) return [];
+  const out = [];
+  const stack = [...roots.value];
+  while (stack.length) {
+    const n = stack.pop();
+    const kids = getChildren(n);
+    if (kids && kids.length) {
+      out.push(getKey(n));
+      stack.push(...kids);
+    }
+  }
+  return out;
+});
+const filterQuery = ref("");
+function evalKeywords(node) {
+  const expr = props.config.filter?.keywords;
+  if (!expr) return [];
+  try {
+    const raw = Effect.runSync($cel(expr, nodeCtx(node)));
+    if (!Array.isArray(raw)) return [];
+    return raw.map((v) => String(v));
+  } catch {
+    return [];
+  }
+}
+const searchCorpus = shallowRef(/* @__PURE__ */ new Map());
+watch(
+  () => [
+    roots.value,
+    locale.value,
+    props.config.nodeLabel,
+    props.config.filter?.keywords
+  ],
+  () => {
+    const map = /* @__PURE__ */ new Map();
+    const stack = [...roots.value];
+    while (stack.length) {
+      const n = stack.pop();
+      const label = nodeLabelText(n).trim().toLowerCase();
+      const kw = evalKeywords(n).map((k) => k.trim().toLowerCase()).join("\n");
+      map.set(getKey(n), kw ? `${label}
+${kw}` : label);
+      const kids = getChildren(n);
+      if (kids && kids.length) stack.push(...kids);
+    }
+    searchCorpus.value = map;
+  },
+  { immediate: true }
+);
+function filterPredicate(node, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const hay = searchCorpus.value.get(getKey(node));
+  if (hay !== void 0) return hay.includes(q);
+  return nodeLabelText(node).trim().toLowerCase().includes(q);
+}
+const filterLabelText = computed(() => {
+  const localized = props.config.filter?.label ? getLocalizedText(props.config.filter.label, locale.value) : void 0;
+  return localized && localized.length > 0 ? localized : t("tree-single-search-label");
+});
+const readonlyText = computed(() => {
+  const selected = model.value;
+  const empty = t("tree-single-readonly-empty");
+  if (selected == null) return empty;
+  const stack = [...roots.value];
+  while (stack.length) {
+    const n = stack.pop();
+    if (getKey(n) === selected) {
+      const label = nodeLabelText(n);
+      return label.length > 0 ? label : selected;
+    }
+    const kids = getChildren(n);
+    if (kids && kids.length) stack.push(...kids);
+  }
+  return selected;
+});
+</script>
+
+<template>
+  <Field
+    orientation="vertical"
+    :data-disabled="isDisabled || void 0"
+  >
+    <FieldLabel
+      v-if="labelText"
+      class="text-xs text-zinc-500"
+    >
+      <template
+        v-if="tooltipText"
+        #tooltip
+      >
+        <Markdown
+          :source="tooltipText"
+          class="prose prose-xs prose-zinc"
+        />
+      </template>
+      {{ labelText }}
+    </FieldLabel>
+
+    <div
+      v-if="effectiveReadonly"
+      class="min-h-9 py-1.5 text-sm text-zinc-700"
+    >
+      {{ readonlyText }}
+    </div>
+
+    <template v-else>
+      <Field
+        v-if="config.filter?.enabled"
+        orientation="floating"
+      >
+        <FieldLabel>{{ filterLabelText }}</FieldLabel>
+        <InputGroup>
+          <InputGroupAddon align="inline-start">
+            <Icon icon="lucide:search" />
+          </InputGroupAddon>
+          <InputGroupInput
+            v-model="filterQuery"
+            :disabled="isDisabled"
+          />
+          <InputGroupAddon
+            v-if="filterQuery.length > 0"
+            align="inline-end"
+          >
+            <InputGroupButton
+              size="icon-xs"
+              :aria-label="t('tree-single-search-clear')"
+              @click="filterQuery = ''"
+            >
+              <Icon icon="lucide:x" />
+            </InputGroupButton>
+          </InputGroupAddon>
+        </InputGroup>
+      </Field>
+
+      <div
+        v-if="fetchError && roots.length === 0"
+        class="min-h-9 py-1.5 text-sm text-red-500"
+      >
+        {{ t("tree-single-load-error") }}
+      </div>
+      <div
+        v-else-if="loading && roots.length === 0"
+        class="flex flex-col gap-1.5 py-1"
+        aria-busy="true"
+      >
+        <Skeleton class="h-6 w-2/3" />
+        <Skeleton class="h-6 w-1/2" />
+        <Skeleton class="h-6 w-3/5" />
+        <Skeleton class="h-6 w-2/5" />
+      </div>
+
+      <UiTree
+        v-else
+        v-model="model"
+        :roots="roots"
+        :get-key="getKey"
+        :get-children="getChildren"
+        selection-mode="single"
+        :selectable="nodeSelectable"
+        :filter-predicate="filterPredicate"
+        :filter-query="filterQuery"
+        :initial-expanded="initialExpanded"
+        :show-focused-row="false"
+        :class="isDisabled ? 'pointer-events-none opacity-60' : void 0"
+      >
+        <template #node="{ node, selected }">
+          <span class="flex items-start gap-2">
+            <!-- Presentational radio glyph: mirrors the row's selection state
+                 but never owns it. Row click / keyboard in `<UiTree>` remains
+                 the single source of truth — this is a visual reflection only. -->
+            <Icon
+              :icon="selected ? 'fluent:radio-button-20-filled' : 'fluent:radio-button-20-regular'"
+              class="pointer-events-none mt-0.5 size-4 shrink-0"
+              :class="selected ? 'text-(--primary)' : 'text-zinc-300'"
+              aria-hidden="true"
+            />
+            <span class="flex flex-col gap-0.5">
+              <Markdown
+                :source="nodeLabelText(node)"
+                class="prose prose-sm prose-zinc text-zinc-700"
+              />
+              <Markdown
+                v-if="nodeTooltipText(node)"
+                :source="nodeTooltipText(node)"
+                block
+                class="prose prose-xs prose-zinc text-zinc-400"
+              />
+            </span>
+          </span>
+        </template>
+
+        <template #empty>
+          <div class="min-h-9 py-1.5 text-sm text-zinc-400">
+            {{ t("tree-single-empty") }}
+          </div>
+        </template>
+      </UiTree>
+    </template>
+  </Field>
+</template>

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/runtime.vue.d.ts

@@ -0,0 +1,8 @@
+import type { Value } from './schema.js';
+type __VLS_Props = {
+    fieldId: string;
+    config: Value;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/schema.d.ts

@@ -0,0 +1,96 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../../../../vendor/cel-js/lib/index.js';
+export declare const type: "com.shwfed.form.field.tree.single";
+export declare const compatibilityDate: "2026-05-28";
+export declare const metadata: {
+    readonly name: "树（单选）";
+    readonly icon: "fluent:tree-evergreen-20-regular";
+    readonly w: {
+        readonly initial: 8;
+        readonly min: 4;
+        readonly max: number;
+    };
+    readonly h: {
+        readonly initial: 8;
+        readonly min: 4;
+        readonly max: number;
+        readonly grow: true;
+    };
+};
+export declare function schema(configure: (env: Environment) => void): Schema.Struct<{
+    label: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    tooltip: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    binding: Schema.optional<Schema.refine<string, typeof Schema.String>>;
+    disabled: Schema.optional<Schema.Schema<string, string, never>>;
+    readonly: Schema.optional<Schema.Schema<string, string, never>>;
+    derived: Schema.optional<Schema.Struct<{
+        mode: Schema.Literal<["formula", "prefill"]>;
+        expression: Schema.Schema<string, string, never>;
+    }>>;
+    dataSource: Schema.Struct<{
+        request: Schema.optional<Schema.Schema<string, string, never>>;
+        data: Schema.Schema<string, string, never>;
+    }>;
+    nodeKey: Schema.Schema<string, string, never>;
+    nodeChildren: Schema.Schema<string, string, never>;
+    nodeLabel: Schema.refine<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>;
+    nodeTooltip: Schema.optional<Schema.refine<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], Schema.TupleType<readonly [Schema.Struct<{
+        locale: Schema.Literal<["zh"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>], [Schema.Struct<{
+        locale: Schema.Literal<["ja", "en", "ko"]>;
+        message: Schema.SchemaClass<string, string, never>;
+    }>]>>>;
+    nodeSelectable: Schema.optional<Schema.Schema<string, string, never>>;
+    expandAll: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => false;
+    }>;
+    filter: Schema.optional<Schema.Struct<{
+        enabled: Schema.SchemaClass<boolean, boolean, never>;
+        label: Schema.optional<Schema.TupleType<readonly [Schema.Struct<{
+            locale: Schema.Literal<["zh"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>], [Schema.Struct<{
+            locale: Schema.Literal<["ja", "en", "ko"]>;
+            message: Schema.SchemaClass<string, string, never>;
+        }>]>>;
+        keywords: Schema.optional<Schema.Schema<string, string, never>>;
+    }>>;
+    id: Schema.refine<string, typeof Schema.String>;
+    displayName: Schema.optional<Schema.SchemaClass<string, string, never>>;
+    hidden: Schema.optional<Schema.Schema<string, string, never>>;
+    type: Schema.Literal<["com.shwfed.form.field.tree.single"]>;
+    compatibilityDate: Schema.Literal<["2026-05-28"]>;
+}>;
+export type Value = Schema.Schema.Type<ReturnType<typeof schema>>;
+export declare function defaults(): Partial<Value>;

package/dist/runtime/components/form/fields/2026-05-28/com.shwfed.form.field.tree.single/schema.js

@@ -0,0 +1,118 @@
+import { Schema } from "effect";
+import { Expression, LocaleMarkdown } from "../../../../../share/expression.js";
+import { Locale } from "../../../../../share/locale.js";
+import { DataSource } from "../../../../table/schema.js";
+import { commonFieldFields, derivedField } from "../../../utils/common.js";
+export const type = "com.shwfed.form.field.tree.single";
+export const compatibilityDate = "2026-05-28";
+export const metadata = {
+  name: "\u6811\uFF08\u5355\u9009\uFF09",
+  icon: "fluent:tree-evergreen-20-regular",
+  w: { initial: 8, min: 4, max: Infinity },
+  h: { initial: 8, min: 4, max: Infinity, grow: true }
+};
+export function schema(configure) {
+  const CelBool = Expression({ configure, resultType: "bool" });
+  const nodeConfigure = (env) => {
+    configure(env);
+    env.registerVariable("node", "dyn", { description: "\u5F53\u524D\u8282\u70B9\uFF1B\u7531 `\u6570\u636E` \u8868\u8FBE\u5F0F\u8FD4\u56DE\u7684\u6BCF\u4E00\u9879" });
+  };
+  const CelNodeKey = Expression({
+    configure: nodeConfigure,
+    resultType: (t) => t === "string" || t === "number" || t === "dyn"
+  });
+  const CelNodeChildren = Expression({
+    configure: nodeConfigure,
+    // Accept lists, optional lists, and `dyn` — CEL infers an empty literal
+    // such as `[]` as `list<dyn>`; a configured expression like
+    // `has(node.kids) ? node.kids : null` lands on `dyn`. The looser predicate
+    // mirrors the table's `data` expression.
+    resultType: (t) => t === "dyn" || t.startsWith("list") || t.startsWith("optional")
+  });
+  const CelNodeBool = Expression({ configure: nodeConfigure, resultType: "bool" });
+  const NodeLocaleMd = LocaleMarkdown({ configure: nodeConfigure });
+  const CelKeywords = Expression({
+    configure: nodeConfigure,
+    resultType: (t) => t === "dyn" || t.startsWith("list") || t.startsWith("optional")
+  });
+  return Schema.Struct({
+    type: Schema.Literal(type),
+    compatibilityDate: Schema.Literal(compatibilityDate),
+    ...commonFieldFields(configure),
+    label: Schema.optional(Locale.annotations({
+      title: "\u6807\u7B7E",
+      description: "\u5B57\u6BB5\u524D\u5C55\u793A\u7684\u6587\u672C\uFF1B\u7559\u7A7A\u5219\u4E0D\u6E32\u67D3\u6807\u7B7E"
+    })),
+    tooltip: Schema.optional(Locale.annotations({
+      title: "\u63D0\u793A",
+      description: "\u9F20\u6807\u60AC\u505C\u5728\u6807\u7B7E\u4E0A\u65F6\u5C55\u793A\u7684\u8BF4\u660E"
+    })),
+    binding: Schema.optional(Schema.String.pipe(Schema.minLength(1)).annotations({
+      title: "\u7ED1\u5B9A\u8DEF\u5F84",
+      description: "\u5199\u5165\u8868\u5355\u72B6\u6001\u7684 `dot-prop` \u8DEF\u5F84\uFF1B\u5199\u5165\u503C\u4E3A\u6240\u9009\u8282\u70B9 ID \u7684\u5B57\u7B26\u4E32\uFF08\u6807\u91CF\uFF09\uFF1B\u7559\u7A7A\u5219\u4E3A\u975E\u53D7\u63A7\u5B57\u6BB5"
+    })),
+    disabled: Schema.optional(CelBool.annotations({
+      title: "\u7981\u7528\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4ECD\u6E32\u67D3\u4F46\u4E0D\u53EF\u9009\u62E9"
+    })),
+    readonly: Schema.optional(CelBool.annotations({
+      title: "\u53EA\u8BFB\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u65F6\u4EC5\u4EE5\u7EAF\u6587\u672C\u5C55\u793A\u5F53\u524D\u6240\u9009\u8282\u70B9\u7684\u6807\u7B7E"
+    })),
+    derived: derivedField(configure, "dyn"),
+    dataSource: DataSource(configure).annotations({
+      title: "\u6570\u636E\u6E90",
+      description: "\u8FD4\u56DE\u5B8C\u6574\u6811\uFF08\u6839\u8282\u70B9\u5217\u8868\uFF09\u7684\u6570\u636E\u6E90\uFF1B\u6811\u901A\u8FC7 `\u8282\u70B9\u5B50\u7EA7` \u8868\u8FBE\u5F0F\u9010\u5C42\u5411\u4E0B\u8BFB\u53D6\u5B50\u7EA7"
+    }),
+    nodeKey: CelNodeKey.annotations({
+      title: "\u8282\u70B9 ID",
+      description: "\u4E3A\u6BCF\u4E2A\u8282\u70B9\u8BA1\u7B97\u7A33\u5B9A\u552F\u4E00 ID \u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `node`\uFF1B\u8FD0\u884C\u65F6\u4EE5\u5B57\u7B26\u4E32\u5F62\u5F0F\u5B58\u50A8"
+    }),
+    nodeChildren: CelNodeChildren.annotations({
+      title: "\u8282\u70B9\u5B50\u7EA7",
+      description: "\u8FD4\u56DE\u5F53\u524D\u8282\u70B9\u7684\u5B50\u7EA7\u5217\u8868\u7684 CEL \u8868\u8FBE\u5F0F\uFF1B\u8FD4\u56DE `none` / `null` \u89C6\u4E3A\u53F6\u5B50\u8282\u70B9"
+    }),
+    nodeLabel: NodeLocaleMd.annotations({
+      title: "\u8282\u70B9\u6807\u7B7E",
+      description: "\u8282\u70B9\u5C55\u793A\u7684\u672C\u5730\u5316\u6587\u672C\uFF0C\u652F\u6301 Markdown \u4E0E `{{ node.foo }}` / `{{ form.foo }}` \u63D2\u503C"
+    }),
+    nodeTooltip: Schema.optional(NodeLocaleMd.annotations({
+      title: "\u8282\u70B9\u63D0\u793A",
+      description: "\u9F20\u6807\u60AC\u505C\u5728\u8282\u70B9\u4E0A\u65F6\u5C55\u793A\u7684\u672C\u5730\u5316\u63D0\u793A\uFF0C\u652F\u6301 Markdown \u4E0E\u63D2\u503C"
+    })),
+    nodeSelectable: Schema.optional(CelNodeBool.annotations({
+      title: "\u8282\u70B9\u53EF\u9009\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u8868\u793A\u8BE5\u8282\u70B9\u53EF\u88AB\u9009\u62E9"
+    })),
+    expandAll: Schema.optionalWith(Schema.Boolean, { default: () => false }).annotations({
+      title: "\u9ED8\u8BA4\u5168\u90E8\u5C55\u5F00",
+      description: "\u5F00\u542F\u540E\u6302\u8F7D\u65F6\u5C55\u5F00\u6240\u6709\u975E\u53F6\u5B50\u8282\u70B9"
+    }),
+    filter: Schema.optional(Schema.Struct({
+      enabled: Schema.Boolean.annotations({ title: "\u542F\u7528", description: "\u662F\u5426\u5728\u6811\u4E0A\u65B9\u663E\u793A\u641C\u7D22\u8F93\u5165\u6846" }),
+      label: Schema.optional(Locale.annotations({
+        title: "\u6807\u7B7E",
+        description: "\u641C\u7D22\u8F93\u5165\u6846\u7684\u6D6E\u52A8\u6807\u7B7E\uFF1B\u7559\u7A7A\u5219\u4F7F\u7528\u9ED8\u8BA4\u503C\u300C\u641C\u7D22\u300D"
+      })),
+      keywords: Schema.optional(CelKeywords.annotations({
+        title: "\u989D\u5916\u5173\u952E\u8BCD",
+        description: "\u8FD4\u56DE\u5B57\u7B26\u4E32\u5217\u8868\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `node`\uFF1B\u5339\u914D\u89C4\u5219\u4E3A\u300C\u8282\u70B9\u6807\u7B7E \u6216 \u4EFB\u4E00\u5173\u952E\u8BCD\u300D\u5305\u542B\u641C\u7D22\u8BCD\uFF08\u4E0D\u533A\u5206\u5927\u5C0F\u5199\uFF09"
+      }))
+    }).annotations({
+      title: "\u8FC7\u6EE4",
+      description: "\u5BA2\u6237\u7AEF\u8FC7\u6EE4\uFF1B\u8FC7\u6EE4\u4E0D\u4F1A\u5F71\u54CD\u5DF2\u9009\u4E2D\u7684\u8282\u70B9 ID"
+    }))
+  }).annotations({
+    title: "TreeSingleField",
+    description: "\u57FA\u4E8E\u6811\u5F62\u6570\u636E\u7684\u5355\u9009\u8F93\u5165"
+  });
+}
+export function defaults() {
+  return {
+    dataSource: { data: "[]" },
+    nodeKey: "string(node.id)",
+    nodeChildren: "has(node.children) ? node.children : null",
+    nodeLabel: [{ locale: "zh", message: "{{ node.label }}" }],
+    expandAll: false
+  };
+}

package/dist/runtime/components/form/fields/2026-05-28/tree-combobox-shared.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Wrapping + adapter helpers shared by `tree.combobox.single` and
+ * `tree.combobox.multi`. The whole tree comes from `dataSource` in one
+ * shot, so wrapping is a pure walk over CEL-derived children: each raw
+ * node either has children (`branch`) or it doesn't (`terminal`).
+ */
+export type WrappedNode = {
+    readonly kind: 'branch';
+    readonly raw: unknown;
+    readonly key: string;
+    readonly children: WrappedNode[];
+} | {
+    readonly kind: 'terminal';
+    readonly raw: unknown;
+    readonly key: string;
+};
+export interface WrapStructureContext {
+    /** Stringified node id; one per raw node. Reuses `nodeKey` CEL. */
+    nodeKey: (raw: unknown) => string;
+    /**
+     * Normalised children array. `undefined`/`null`/empty all collapse to
+     * `undefined` here — the wrapping logic interprets that as
+     * "this node has no children" → `terminal`.
+     */
+    nodeChildren: (raw: unknown) => unknown[] | undefined;
+}
+export declare function wrapStructural(raw: unknown, ctx: WrapStructureContext): WrappedNode;
+export declare function wrapStructuralAll(raws: unknown[], ctx: WrapStructureContext): WrappedNode[];
+/** Synchronous `getChildren` adapter for ui/tree. */
+export declare function getWrappedChildren(w: WrappedNode): WrappedNode[] | undefined;
+/**
+ * Find the path from root to a node whose `key` matches. Returns `null`
+ * if the key isn't present in `roots`.
+ */
+export declare function findWrappedPath(roots: WrappedNode[], key: string): WrappedNode[] | null;

package/dist/runtime/components/form/fields/2026-05-28/tree-combobox-shared.js

@@ -0,0 +1,31 @@
+export function wrapStructural(raw, ctx) {
+  const kids = ctx.nodeChildren(raw);
+  if (!kids || kids.length === 0) {
+    return { kind: "terminal", raw, key: ctx.nodeKey(raw) };
+  }
+  return {
+    kind: "branch",
+    raw,
+    key: ctx.nodeKey(raw),
+    children: kids.map((c) => wrapStructural(c, ctx))
+  };
+}
+export function wrapStructuralAll(raws, ctx) {
+  return raws.map((r) => wrapStructural(r, ctx));
+}
+export function getWrappedChildren(w) {
+  return w.kind === "branch" ? w.children : void 0;
+}
+export function findWrappedPath(roots, key) {
+  const trail = [];
+  function walk(siblings) {
+    for (const n of siblings) {
+      trail.push(n);
+      if (n.key === key) return true;
+      if (n.kind === "branch" && n.children.length > 0 && walk(n.children)) return true;
+      trail.pop();
+    }
+    return false;
+  }
+  return walk(roots) ? trail.slice() : null;
+}