@shwfed/config 2.12.1 → 2.12.3

package/dist/runtime/components/sidebar/node.vue

@@ -0,0 +1,102 @@
+<script setup>
+import { Icon } from "@iconify/vue";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../ui/collapsible";
+import {
+  SidebarMenuAction,
+  SidebarMenuButton,
+  SidebarMenuItem,
+  SidebarMenuSub
+} from "../ui/sidebar";
+defineOptions({ name: "ShwfedSidebarNode" });
+const props = defineProps({
+  node: { type: Object, required: true },
+  favorites: { type: null, required: true }
+});
+function onOpenUpdate(open) {
+  props.favorites.setOpen(props.node.key, open);
+}
+</script>
+
+<template>
+  <SidebarMenuItem>
+    <!-- Group: collapsible, recurses into a sub-menu -->
+    <Collapsible
+      v-if="node.children.length"
+      class="group/collapsible"
+      :open="favorites.isOpen(node.key, true)"
+      @update:open="onOpenUpdate"
+    >
+      <CollapsibleTrigger as-child>
+        <SidebarMenuButton>
+          <Icon
+            v-if="node.icon"
+            :icon="node.icon"
+          />
+          <span>{{ node.label }}</span>
+          <Icon
+            icon="fluent:chevron-right-20-regular"
+            class="ml-auto transition-transform group-data-[state=open]/collapsible:rotate-90"
+          />
+        </SidebarMenuButton>
+      </CollapsibleTrigger>
+      <CollapsibleContent>
+        <SidebarMenuSub>
+          <ShwfedSidebarNode
+            v-for="child in node.children"
+            :key="child.key"
+            :node="child"
+            :favorites="favorites"
+          />
+        </SidebarMenuSub>
+      </CollapsibleContent>
+    </Collapsible>
+
+    <!-- Link: navigable leaf with a route, star-favoritable -->
+    <template v-else-if="node.route">
+      <NuxtLink
+        :to="node.route"
+        custom
+      >
+        <template #default="{ navigate, isExactActive }">
+          <SidebarMenuButton
+            as-child
+            :is-active="isExactActive"
+          >
+            <button
+              type="button"
+              @click="navigate"
+            >
+              <Icon
+                v-if="node.icon"
+                :icon="node.icon"
+              />
+              <span>{{ node.label }}</span>
+            </button>
+          </SidebarMenuButton>
+        </template>
+      </NuxtLink>
+      <SidebarMenuAction
+        v-if="node.favoritable"
+        :show-on-hover="!favorites.isFavorite(node.key)"
+        class="text-yellow-500!"
+        @click.stop="favorites.toggleFavorite(node.key)"
+      >
+        <Icon :icon="favorites.isFavorite(node.key) ? 'fluent:star-20-filled' : 'fluent:star-20-regular'" />
+      </SidebarMenuAction>
+    </template>
+
+    <!-- Plain label: childless, no route -->
+    <SidebarMenuButton
+      v-else
+      as-child
+    >
+      <span>
+        <Icon
+          v-if="node.icon"
+          :icon="node.icon"
+        />
+        <span>{{ node.label }}</span>
+      </span>
+    </SidebarMenuButton>
+  </SidebarMenuItem>
+</template>

package/dist/runtime/components/sidebar/node.vue.d.ts

@@ -0,0 +1,9 @@
+import type { NavNode } from './types.js';
+import type { SidebarFavorites } from './favorites.js';
+type __VLS_Props = {
+    node: NavNode;
+    favorites: SidebarFavorites;
+};
+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/sidebar/schema.d.ts

@@ -0,0 +1,72 @@
+import { Schema } from 'effect';
+import type { Environment } from '../../vendor/cel-js/lib/index.js';
+import type { LocaleValue } from '../../share/locale.js';
+export { getStructFieldDescription, getStructFieldTitle } from '../table/utils/schema-meta.js';
+declare const KIND = "shwfed.component.sidebar";
+/**
+ * Standalone, data-driven navigation sidebar. A PEER of the page config
+ * (`ShwfedConfig`), NOT a block inside it: its own serializable `kind`, its own
+ * editor modal, its own CEL context. It never touches `blockRef` / `PageConfig`
+ * / the block registry.
+ *
+ * The navigation TREE is data-driven, modeled on the `tree.single` block: one
+ * `DataSource` returns the whole node payload, and per-node CEL expressions
+ * (sharing a `node` var) walk and render it. Arbitrary-depth nesting and
+ * CEL-computed link targets fall out of `nodeChildren` / `nodeRoute` — there is
+ * no hand-authored static tree. A node with children renders collapsible; a
+ * node whose `nodeRoute` resolves non-empty renders as a navigable link (and is
+ * favoritable — the star is a runtime affordance, not a schema field).
+ */
+export declare function SidebarConfig(configure: (env: Environment) => void): Schema.Struct<{
+    kind: Schema.tag<"shwfed.component.sidebar">;
+    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.suspend<readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], string | readonly [{
+        readonly locale: "zh";
+        readonly message: string;
+    }, ...{
+        readonly locale: "en" | "ja" | "ko";
+        readonly message: string;
+    }[]], never>>;
+    nodeIcon: Schema.optional<Schema.Schema<string, string, never>>;
+    nodeRoute: Schema.optional<Schema.Schema<string, string, never>>;
+    nodeVisible: Schema.optional<Schema.Schema<string, string, never>>;
+    style: Schema.optional<Schema.Schema<string, string, never>>;
+}>;
+/**
+ * Creation-time defaults for a fresh sidebar. Seeds working expressions (like
+ * the tree block's `defaultBody`) so a freshly-added sidebar renders a sane
+ * skeleton the designer can immediately edit against real data shapes.
+ */
+export declare function defaults(): Omit<SidebarConfigValue, 'kind'>;
+export declare function createSidebarConfig(body?: Partial<Omit<SidebarConfigValue, 'kind'>>): SidebarConfigValue;
+export type SidebarConfigValue = Readonly<{
+    kind: typeof KIND;
+    dataSource: Readonly<{
+        request?: string;
+        data: string;
+    }>;
+    nodeKey: string;
+    nodeChildren: string;
+    nodeLabel: LocaleValue;
+    nodeIcon?: string;
+    nodeRoute?: string;
+    nodeVisible?: string;
+    style?: string;
+}>;

package/dist/runtime/components/sidebar/schema.js

@@ -0,0 +1,84 @@
+import { Schema } from "effect";
+import { Expression, LocaleMarkdown } from "../../share/expression.js";
+import { registerNodeVariableIfAbsent } from "../../share/tree-node-var.js";
+import { DataSource } from "../table/schema.js";
+export { getStructFieldDescription, getStructFieldTitle } from "../table/utils/schema-meta.js";
+const KIND = "shwfed.component.sidebar";
+export function SidebarConfig(configure) {
+  const nodeConfigure = (env) => {
+    configure(env);
+    registerNodeVariableIfAbsent(env);
+  };
+  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`. Mirrors the table's
+    // `data` expression.
+    resultType: (t) => t === "dyn" || t.startsWith("list") || t.startsWith("optional")
+  });
+  const NodeLocaleMd = LocaleMarkdown({ configure: nodeConfigure });
+  const CelNodeString = Expression({
+    configure: nodeConfigure,
+    resultType: (t) => t === "string" || t === "dyn" || t.startsWith("optional")
+  });
+  const CelNodeBool = Expression({ configure: nodeConfigure, resultType: "bool" });
+  const CelStyle = Expression({
+    configure,
+    resultType: (t) => t === "string" || t === "dyn" || t.startsWith("map") || t.startsWith("optional")
+  });
+  return Schema.Struct({
+    kind: Schema.tag(KIND),
+    dataSource: DataSource(configure).annotations({
+      title: "\u6570\u636E\u6E90",
+      description: "\u8FD4\u56DE\u5B8C\u6574\u5BFC\u822A\u6811\uFF08\u6839\u8282\u70B9\u5217\u8868\uFF09\u7684\u6570\u636E\u6E90\uFF1B\u4FA7\u680F\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\uFF0C\u4E5F\u7528\u4F5C\u6536\u85CF\u6807\u8BC6"
+    }),
+    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 }}` \u63D2\u503C"
+    }),
+    nodeIcon: Schema.optional(CelNodeString.annotations({
+      title: "\u8282\u70B9\u56FE\u6807",
+      description: "\u8FD4\u56DE Iconify \u56FE\u6807 ID\uFF08\u5982 `'fluent:home-20-regular'`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `node`\uFF1B\u7559\u7A7A\u5219\u4E0D\u663E\u793A\u56FE\u6807"
+    })),
+    nodeRoute: Schema.optional(CelNodeString.annotations({
+      title: "\u8282\u70B9\u94FE\u63A5",
+      description: "\u8FD4\u56DE\u76EE\u6807\u8DEF\u7531\uFF08`string`\uFF09\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8BBF\u95EE `node`\uFF1B\u89E3\u6790\u4E3A\u975E\u7A7A\u65F6\u8BE5\u8282\u70B9\u6210\u4E3A\u53EF\u70B9\u51FB\u7684\u5BFC\u822A\u94FE\u63A5\uFF08\u5E76\u53EF\u88AB\u6536\u85CF\uFF09\uFF0C\u5426\u5219\u4EC5\u4F5C\u4E3A\u5206\u7EC4\u6807\u9898"
+    })),
+    nodeVisible: Schema.optional(CelNodeBool.annotations({
+      title: "\u8282\u70B9\u53EF\u89C1\u6761\u4EF6",
+      description: "\u8FD4\u56DE `true` \u8868\u793A\u8BE5\u8282\u70B9\uFF08\u53CA\u5176\u5B50\u6811\uFF09\u53EF\u89C1\uFF1B\u7559\u7A7A\u5219\u59CB\u7EC8\u53EF\u89C1\u3002\u5E38\u7528\u4E8E\u6309\u6743\u9650\u63A7\u5236\u5BFC\u822A\u9879"
+    })),
+    style: Schema.optional(CelStyle).annotations({
+      title: "\u6837\u5F0F",
+      description: "\u8FD4\u56DE\u5E94\u7528\u5728\u4FA7\u680F\u6839\u5143\u7D20\u4E0A\u7684\u6837\u5F0F\u7684 CEL \u8868\u8FBE\u5F0F\uFF0C\u53EF\u8FD4\u56DE CSS \u5B57\u7B26\u4E32\u6216\u6837\u5F0F\u5BF9\u8C61\uFF1B\u7559\u7A7A\u5219\u4E0D\u8BBE\u989D\u5916\u6837\u5F0F"
+    })
+  }).annotations({
+    title: "SidebarConfig",
+    description: "\u6570\u636E\u9A71\u52A8\u7684\u5BFC\u822A\u4FA7\u680F\u5B8C\u6574\u914D\u7F6E"
+  });
+}
+export function defaults() {
+  return {
+    dataSource: { data: "[]" },
+    nodeKey: "string(node.id)",
+    nodeChildren: "has(node.children) ? node.children : null",
+    nodeLabel: [{ locale: "zh", message: "{{ node.label }}" }],
+    nodeRoute: "node.route"
+  };
+}
+export function createSidebarConfig(body) {
+  return { kind: KIND, ...defaults(), ...body };
+}

package/dist/runtime/components/sidebar/tree.d.vue.ts

@@ -0,0 +1,10 @@
+import type { Environment } from '../../vendor/cel-js/lib/index.js';
+import type { SidebarConfigValue } from './schema.js';
+type __VLS_Props = {
+    config: SidebarConfigValue;
+    configure?: (env: Environment) => void;
+    storageKey: string;
+};
+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/sidebar/tree.vue

@@ -0,0 +1,260 @@
+<script setup>
+import { Icon } from "@iconify/vue";
+import { Effect, Fiber, Option } from "effect";
+import { Fetch } from "fx-fetch";
+import { computed, ref, watch } from "vue";
+import { useI18n } from "vue-i18n";
+import { fetchJsonOption } from "../../share/request";
+import { cel as _rawCel } from "../../utils/cel";
+import { celBindings, injectCELContext } from "../../utils/cel-context";
+import { getLocalizedText } from "../../share/locale";
+import { interpolateMarkdown } from "../table/utils/runtime";
+import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../ui/collapsible";
+import { SidebarContent, SidebarGroup, SidebarGroupContent, SidebarGroupLabel, SidebarMenu } from "../ui/sidebar";
+import { Skeleton } from "../ui/skeleton";
+import SidebarNode from "./node.vue";
+import { useSidebarFavorites } from "./favorites";
+defineOptions({ name: "ShwfedSidebarTree" });
+const props = defineProps({
+  config: { type: Object, required: true },
+  configure: { type: Function, required: false },
+  storageKey: { type: String, required: true }
+});
+const { locale, t } = useI18n({
+  inheritLocale: true,
+  useScope: "global",
+  messages: {
+    zh: { "sidebar-favorites": "\u6536\u85CF" },
+    en: { "sidebar-favorites": "Favorites" },
+    ja: { "sidebar-favorites": "\u304A\u6C17\u306B\u5165\u308A" },
+    ko: { "sidebar-favorites": "\uC990\uACA8\uCC3E\uAE30" }
+  }
+});
+const favorites = useSidebarFavorites(props.storageKey);
+const inherited = injectCELContext();
+const $cel = (expression, context) => _rawCel(expression, { ...celBindings(inherited), ...context });
+const styleValue = computed(() => {
+  const expr = props.config.style;
+  if (!expr) return void 0;
+  try {
+    const r = Effect.runSync($cel(expr, {}));
+    if (r == null) return void 0;
+    if (typeof r === "string") return r;
+    if (typeof r === "object") return r;
+    return String(r);
+  } catch {
+    return void 0;
+  }
+});
+const roots = ref([]);
+const loading = ref(false);
+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) {
+      jsonOpt = yield* fetchJsonOption(yield* $cel(dataSource.request, {}));
+    }
+    const dataRaw = yield* $cel(dataSource.data, { 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 {
+    roots.value = await Effect.runPromise(Effect.provide(program, Fetch.layer));
+  } catch (e) {
+    console.warn("[shwfed-sidebar] dataSource fetch failed", e);
+  }
+}
+watch(
+  () => [props.config.dataSource?.request, props.config.dataSource?.data],
+  () => {
+    void fetchTree();
+  },
+  { immediate: true }
+);
+function nodeCtx(node) {
+  return { node };
+}
+function getKey(node) {
+  try {
+    return String(Effect.runSync($cel(props.config.nodeKey, nodeCtx(node))));
+  } catch (err) {
+    console.error("[shwfed-sidebar] failed to evaluate nodeKey:", err);
+    return "";
+  }
+}
+function getChildren(node) {
+  let raw;
+  try {
+    raw = Effect.runSync($cel(props.config.nodeChildren, nodeCtx(node)));
+  } catch (err) {
+    console.error("[shwfed-sidebar] failed to evaluate nodeChildren:", err);
+    return [];
+  }
+  return Array.isArray(raw) ? raw : [];
+}
+function getOptionalString(expr, node) {
+  if (!expr) return void 0;
+  try {
+    const r = Effect.runSync($cel(expr, nodeCtx(node)));
+    if (r == null) return void 0;
+    const s = String(r);
+    return s.length > 0 ? s : void 0;
+  } catch (err) {
+    console.error("[shwfed-sidebar] failed to evaluate node string expr:", err);
+    return void 0;
+  }
+}
+function nodeVisible(node) {
+  const expr = props.config.nodeVisible;
+  if (!expr) return true;
+  try {
+    return Effect.runSync($cel(expr, nodeCtx(node)));
+  } catch (err) {
+    console.error("[shwfed-sidebar] failed to evaluate nodeVisible:", err);
+    return false;
+  }
+}
+function nodeLabelText(node) {
+  const tpl = getLocalizedText(props.config.nodeLabel, locale.value) ?? "";
+  if (!tpl) return "";
+  try {
+    return interpolateMarkdown(tpl, $cel, { node });
+  } catch (err) {
+    console.error("[shwfed-sidebar] failed to interpolate node label:", err);
+    return tpl;
+  }
+}
+function buildNode(raw) {
+  if (!nodeVisible(raw)) return null;
+  const children = getChildren(raw).map(buildNode).filter((n) => n !== null);
+  const route = getOptionalString(props.config.nodeRoute, raw);
+  return {
+    key: getKey(raw),
+    label: nodeLabelText(raw),
+    icon: getOptionalString(props.config.nodeIcon, raw),
+    route,
+    favoritable: children.length === 0 && !!route,
+    children
+  };
+}
+const tree = computed(
+  () => roots.value.map(buildNode).filter((n) => n !== null)
+);
+const favoriteNodes = computed(() => {
+  const out = [];
+  const walk = (nodes) => {
+    for (const n of nodes) {
+      if (n.favoritable && favorites.isFavorite(n.key)) out.push(n);
+      if (n.children.length) walk(n.children);
+    }
+  };
+  walk(tree.value);
+  return out;
+});
+</script>
+
+<template>
+  <SidebarContent
+    class="gap-2 py-1"
+    :style="styleValue"
+  >
+    <div
+      v-if="loading && roots.length === 0"
+      class="flex flex-col gap-1.5 px-2 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" />
+    </div>
+
+    <template v-else>
+      <SidebarGroup v-if="favoriteNodes.length">
+        <SidebarGroupLabel class="text-sm text-zinc-700">
+          {{ t("sidebar-favorites") }}
+        </SidebarGroupLabel>
+        <SidebarGroupContent>
+          <SidebarMenu>
+            <SidebarNode
+              v-for="n in favoriteNodes"
+              :key="`fav-${n.key}`"
+              :node="n"
+              :favorites="favorites"
+            />
+          </SidebarMenu>
+        </SidebarGroupContent>
+      </SidebarGroup>
+
+      <template
+        v-for="n in tree"
+        :key="n.key"
+      >
+        <!-- Top-level group: the group label IS the collapsible trigger -->
+        <SidebarGroup v-if="n.children.length">
+          <Collapsible
+            class="group/collapsible"
+            :open="favorites.isOpen(n.key, true)"
+            @update:open="(v) => favorites.setOpen(n.key, v)"
+          >
+            <SidebarGroupLabel
+              as-child
+              class="group/label w-full cursor-pointer text-sm text-zinc-700 hover:bg-zinc-100 hover:text-zinc-900"
+            >
+              <CollapsibleTrigger class="w-full">
+                <Icon
+                  v-if="n.icon"
+                  :icon="n.icon"
+                />
+                {{ n.label }}
+                <Icon
+                  icon="fluent:chevron-right-20-regular"
+                  class="ml-auto transition-transform group-data-[state=open]/collapsible:rotate-90"
+                />
+              </CollapsibleTrigger>
+            </SidebarGroupLabel>
+            <CollapsibleContent class="overflow-hidden data-[state=open]:overflow-visible">
+              <SidebarGroupContent>
+                <SidebarMenu class="pl-4">
+                  <SidebarNode
+                    v-for="child in n.children"
+                    :key="child.key"
+                    :node="child"
+                    :favorites="favorites"
+                  />
+                </SidebarMenu>
+              </SidebarGroupContent>
+            </CollapsibleContent>
+          </Collapsible>
+        </SidebarGroup>
+
+        <!-- Top-level direct link -->
+        <SidebarGroup v-else>
+          <SidebarGroupContent>
+            <SidebarMenu>
+              <SidebarNode
+                :node="n"
+                :favorites="favorites"
+              />
+            </SidebarMenu>
+          </SidebarGroupContent>
+        </SidebarGroup>
+      </template>
+    </template>
+  </SidebarContent>
+</template>

package/dist/runtime/components/sidebar/tree.vue.d.ts

@@ -0,0 +1,10 @@
+import type { Environment } from '../../vendor/cel-js/lib/index.js';
+import type { SidebarConfigValue } from './schema.js';
+type __VLS_Props = {
+    config: SidebarConfigValue;
+    configure?: (env: Environment) => void;
+    storageKey: string;
+};
+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/sidebar/types.d.ts

@@ -0,0 +1,19 @@
+/**
+ * A normalized navigation node — the product of walking the raw `DataSource`
+ * payload and evaluating every per-node CEL expression once. The recursive
+ * renderer (`node.vue`) consumes this plain structure and never touches CEL, so
+ * evaluation happens a single time per node in `tree.vue` rather than once per
+ * recursive component instance.
+ *
+ * Group-vs-link is decided here: a node with `children` renders collapsible; a
+ * childless node whose `route` is non-empty renders as a navigable link (and is
+ * `favoritable`).
+ */
+export interface NavNode {
+    key: string;
+    label: string;
+    icon?: string;
+    route?: string;
+    favoritable: boolean;
+    children: NavNode[];
+}

package/dist/runtime/components/sidebar/use-editor.d.ts

@@ -0,0 +1,18 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { Environment } from '../../vendor/cel-js/lib/index.js';
+import { type SidebarConfigValue } from './schema.js';
+export interface SidebarEditorState {
+    draft: Ref<SidebarConfigValue>;
+    validationError: Ref<string | null>;
+    isDirty: ComputedRef<boolean>;
+    configure: (env: Environment) => void;
+    confirm: () => void;
+    dismiss: () => void;
+    reset: () => void;
+}
+export interface UseSidebarEditorOptions {
+    configure?: (env: Environment) => void;
+    /** Called after a successful 确认 commits the draft to the outer model. */
+    onClose?: () => void;
+}
+export declare function useSidebarEditor(model: Ref<SidebarConfigValue>, options?: UseSidebarEditorOptions): SidebarEditorState;

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

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+import { computed, ref, watch } from "vue";
+import { formatValidationError } from "../config/utils/validation-error.js";
+import { SidebarConfig } from "./schema.js";
+function deepClone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+export function useSidebarEditor(model, options = {}) {
+  const configure = options.configure ?? (() => {
+  });
+  const baseline = ref(deepClone(model.value));
+  const draft = ref(deepClone(baseline.value));
+  const isDirty = computed(
+    () => JSON.stringify(draft.value) !== JSON.stringify(baseline.value)
+  );
+  const validationError = ref(null);
+  function confirm() {
+    const schema = SidebarConfig(configure);
+    try {
+      const decoded = Schema.decodeUnknownSync(schema)(draft.value);
+      validationError.value = null;
+      model.value = decoded;
+      baseline.value = deepClone(decoded);
+      draft.value = deepClone(decoded);
+      options.onClose?.();
+    } catch (err) {
+      validationError.value = formatValidationError(err, () => void 0, draft.value);
+    }
+  }
+  function reset() {
+    baseline.value = deepClone(model.value);
+    draft.value = deepClone(model.value);
+    validationError.value = null;
+  }
+  function dismiss() {
+    reset();
+    options.onClose?.();
+  }
+  watch(draft, () => {
+    if (validationError.value) validationError.value = null;
+  }, { deep: true });
+  return { draft, validationError, isDirty, configure, confirm, dismiss, reset };
+}

package/dist/runtime/components/table/columns/2026-05-24/com.shwfed.table.column.combobox-single.remote.options-remote/config.d.vue.ts

@@ -24,6 +24,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly options: string;
         readonly compatibilityDate: "2026-05-24";
         readonly grow?: boolean | undefined;
         readonly triggers?: readonly {
@@ -44,7 +45,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         readonly readonly?: string | undefined;
         readonly request: string;
         readonly enableSorting?: boolean | undefined;
-        readonly options: string;
         readonly optionValue: string;
         readonly optionLabel: readonly [{
             readonly locale: "zh";
@@ -79,6 +79,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
             readonly locale: "en" | "ja" | "ko";
             readonly message: string;
         }[]] | undefined;
+        readonly options: string;
         readonly compatibilityDate: "2026-05-24";
         readonly grow?: boolean | undefined;
         readonly triggers?: readonly {
@@ -99,7 +100,6 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_ModelProps, {},
         readonly readonly?: string | undefined;
         readonly request: string;
         readonly enableSorting?: boolean | undefined;
-        readonly options: string;
         readonly optionValue: string;
         readonly optionLabel: readonly [{
             readonly locale: "zh";