@shwfed/config 3.0.7 → 3.0.8

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

@@ -3,6 +3,7 @@ import type { Schema, Effect } from 'effect';
 import type { ColumnDef } from '@tanstack/vue-table';
 import type { Environment } from '../../../vendor/cel-js/lib/index.js';
 import type { LocaleValue } from '../../../share/locale.js';
+import { type RegistryEdge } from '../../../share/define-registry.js';
 import type { ColumnValue } from '../schema.js';
 type CelEvaluator = <T>(expression: string, context?: Record<string, unknown>) => Effect.Effect<T, any>;
 type AnySchema = Schema.Schema<any, any, never>;
@@ -159,6 +160,10 @@ export type ColumnEntry = Readonly<{
      * `enableRowSelection`. See `ColumnRowSelection`.
      */
     rowSelection?: ColumnRowSelection;
+    /** The column's `prompt.md` (L2 fragment) raw text, surfaced by the AI describe tool. */
+    prompt?: string;
+    /** Recursion edges the AI scope cursor walks (empty for leaf columns). */
+    edges: ReadonlyArray<RegistryEdge>;
 }>;
 export declare const COLUMNS: ReadonlyArray<ColumnEntry>;
 export declare function allColumnSchemas(configure: (env: Environment) => void): ReadonlyArray<AnySchema>;

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

@@ -11,6 +11,10 @@ const runtimeModules = import.meta.glob(
   "../columns/*/*/runtime.vue",
   { eager: true, import: "default", exhaustive: true }
 );
+const promptModules = import.meta.glob(
+  "../columns/*/*/prompt.md",
+  { eager: true, query: "?raw", import: "default", exhaustive: true }
+);
 const sourceKey = (type, compatibilityDate) => `${type}@${compatibilityDate}`;
 const registry = defineRegistry({
   hostName: "shwfed-table",
@@ -18,6 +22,7 @@ const registry = defineRegistry({
   schemaModules,
   configModules,
   runtimeModules,
+  promptModules,
   validateModule: (mod, type, date) => {
     const hasToColumnDef = typeof mod.toColumnDef === "function";
     const hasExpand = typeof mod.expand === "function";
@@ -30,6 +35,10 @@ const registry = defineRegistry({
   // Generator (`expand`) entries have no cell renderer, so they need no
   // sibling `runtime.vue`. Every other column keeps requiring one.
   runtimeOptional: (mod) => typeof mod.expand === "function",
+  // Validate declared `edges` keys against the built schema (only column.actions
+  // declares one today). Inert configure — the edge check only reads field names.
+  buildSchemaForEdges: (mod) => mod.schema(() => {
+  }),
   // Deprecation rules mirror the form host:
   //   (a) date-versioned: another entry shares this entry's `type` with a
   //       strictly greater `compatibilityDate`;
@@ -80,13 +89,15 @@ export const COLUMNS = registry.ENTRIES.map((e) => ({
   config: e.config,
   runtime: e.runtime,
   toColumnDef: e.module.toColumnDef,
+  edges: e.module.edges ?? [],
   deprecated: e.deprecated,
   ...e.supersededBy !== void 0 ? { supersededBy: e.supersededBy } : {},
   ...e.module.migrate !== void 0 ? { migrate: e.module.migrate } : {},
   ...e.module.migrateFrom !== void 0 ? { migrateFrom: e.module.migrateFrom } : {},
   ...e.module.defaults !== void 0 ? { defaults: e.module.defaults } : {},
   ...e.module.expand !== void 0 ? { expand: e.module.expand } : {},
-  ...e.module.rowSelection !== void 0 ? { rowSelection: e.module.rowSelection } : {}
+  ...e.module.rowSelection !== void 0 ? { rowSelection: e.module.rowSelection } : {},
+  ...e.prompt !== void 0 ? { prompt: e.prompt } : {}
 }));
 const migrationTargets = (() => {
   const map = /* @__PURE__ */ new Map();

package/dist/runtime/share/define-registry.d.ts

@@ -1,4 +1,40 @@
 import type { Component } from 'vue';
+import type { Schema } from 'effect';
+type AnySchema = Schema.Schema<any, any, any>;
+/**
+ * A recursion edge: a schema field on this block/host that embeds ANOTHER
+ * host's config (a table's `TableConfig`, a container's `Slot`, an actions
+ * bar's `ActionsConfig`…). Declared next to the schema — NEVER in a central
+ * table (that switch would be the drift class CLAUDE.md bans) — and aggregated
+ * by the registry so the AI scope cursor can walk them (`config/utils/ai-cursor`).
+ *
+ * - `key` — the schema field holding the embedded config. Validated at registry
+ *   load (see `buildSchemaForEdges`): the declared key MUST be a real top-level
+ *   field on the block's schema, exactly like the type/date drift checks.
+ * - `host` — the host kind whose tool family configures that subtree
+ *   (`table` / `form` / `actions` / `slot`). The cursor maps this to a family;
+ *   hosts with no family yet stay declared-but-not-enterable (Phase C).
+ * - `label` — designer-facing crumb for the edge (breadcrumb / orientation).
+ * - `itemSlot` — set when `key` is an ARRAY of items and the embedded host
+ *   config lives at `item[itemSlot]` on each element (tabs: `key: 'tabs'`,
+ *   `itemSlot: 'slot'`). Absent → `key` holds the embedded config directly.
+ * - `self` — set when the embedded host config is NOT under a sub-field but the
+ *   record ITSELF (its fields spread the embedded host's fields, as `field.actions`
+ *   / `column.actions` spread `ActionSchemaFields` at the top level). `key` still
+ *   names a real field (for the load-time existence check), but the cursor bridges
+ *   the whole record and the family merges its keys back (`config/utils/ai-cursor`).
+ * - `celScope` — names a per-edge CEL scope extension the cursor threads into the
+ *   child frame's `configure` when entering (`loop-item` → `item`/`index`). Absent
+ *   → the child inherits the parent scope unchanged. See design §5.
+ */
+export type RegistryEdge = Readonly<{
+    key: string;
+    host: string;
+    label: string;
+    itemSlot?: string;
+    self?: boolean;
+    celScope?: string;
+}>;
 /**
  * Minimum shape every host's schema module must satisfy. Hosts extend this
  * with their own metadata / capability fields via the generic.
@@ -6,6 +42,13 @@ import type { Component } from 'vue';
 export type RegistryModuleBase = Readonly<{
     type: string;
     compatibilityDate: string;
+    /**
+     * Optional recursion-edge declarations — a block/host embedding another
+     * host's config lists them here (see `RegistryEdge`). Validated at load when
+     * the host supplies `buildSchemaForEdges`; otherwise carried through
+     * unvalidated. Absent for leaf and generator entries.
+     */
+    edges?: ReadonlyArray<RegistryEdge>;
 }>;
 /**
  * Per-entry shape produced by the factory before host-specific extras are
@@ -18,6 +61,8 @@ export type RegistryDraft<TModule extends RegistryModuleBase> = Readonly<{
     config: Component;
     runtime: Component;
     module: TModule;
+    /** The sibling `prompt.md`'s raw text (L2 fragment), when one exists. */
+    prompt?: string;
 }>;
 export type RegistryOptions<TModule extends RegistryModuleBase, TEntryExtras extends object> = Readonly<{
     /** Error-message prefix, e.g. `shwfed-form`. */
@@ -30,12 +75,30 @@ export type RegistryOptions<TModule extends RegistryModuleBase, TEntryExtras ext
     configModules: Record<string, Component>;
     /** Eager `import.meta.glob` over the host's runtime.vue files (default import). */
     runtimeModules: Record<string, Component>;
+    /**
+     * Optional eager `import.meta.glob` over the host's sibling `prompt.md` files
+     * ({ query: '?raw', import: 'default', eager: true }), keyed by path exactly
+     * like `schemaModules`. Each entry's `prompt` is looked up from here by the
+     * same folder-suffix match. `prompt.md` is OPTIONAL per folder — an absent one
+     * leaves `entry.prompt` undefined. No dist extension tolerance is needed
+     * (unlike `schema.{ts,js}`): `@nuxt/module-builder` transpiles `.ts`→`.js` but
+     * copies `.md` verbatim, so the `.md` suffix is stable in source and `dist`.
+     */
+    promptModules?: Record<string, string>;
     /**
      * Optional per-module validation beyond the type/date drift checks. Throw
      * to fail at module load. Used by table to require `toColumnDef`
      * to be a function.
      */
     validateModule?: (mod: TModule, type: string, date: string) => void;
+    /**
+     * Optional builder that constructs a module's schema with INERT args (a
+     * no-op configure, a stand-in `blockRef`) purely so the registry can verify
+     * every declared `edges[].key` is a real top-level field on it — the
+     * edge-declaration analog of the type/date drift check. Only invoked for
+     * modules that declare `edges`. Omit → edges are carried through unvalidated.
+     */
+    buildSchemaForEdges?: (mod: TModule) => AnySchema;
     /**
      * Optional predicate deciding whether a given module may ship WITHOUT a
      * sibling `runtime.vue`. Returns true → the runtime lookup is tolerant and
@@ -60,9 +123,12 @@ export type RegistryEntry<TModule extends RegistryModuleBase, TEntryExtras exten
     config: Component;
     runtime: Component;
     module: TModule;
+    /** The sibling `prompt.md`'s raw text (L2 fragment), when one exists. */
+    prompt?: string;
 } & TEntryExtras>;
 export type Registry<TModule extends RegistryModuleBase, TEntryExtras extends object> = Readonly<{
     ENTRIES: ReadonlyArray<RegistryEntry<TModule, TEntryExtras>>;
     find: (type: string, compatibilityDate: string) => RegistryEntry<TModule, TEntryExtras> | undefined;
 }>;
 export declare function defineRegistry<TModule extends RegistryModuleBase, TEntryExtras extends object = Record<never, never>>(options: RegistryOptions<TModule, TEntryExtras>): Registry<TModule, TEntryExtras>;
+export {};

package/dist/runtime/share/define-registry.js

@@ -1,3 +1,21 @@
+function topLevelFieldNames(schema) {
+  const unwrap = (ast) => {
+    switch (ast._tag) {
+      case "TypeLiteral":
+        return ast;
+      case "Transformation":
+        return unwrap(ast.to);
+      case "Refinement":
+        return unwrap(ast.from);
+      case "Suspend":
+        return unwrap(ast.f());
+      default:
+        return null;
+    }
+  };
+  const tl = unwrap(schema.ast);
+  return tl ? tl.propertySignatures.map((p) => String(p.name)) : [];
+}
 export function defineRegistry(options) {
   const {
     hostName,
@@ -5,7 +23,9 @@ export function defineRegistry(options) {
     schemaModules,
     configModules,
     runtimeModules,
+    promptModules,
     validateModule,
+    buildSchemaForEdges,
     runtimeOptional,
     deriveEntryExtras
   } = options;
@@ -27,6 +47,18 @@ export function defineRegistry(options) {
     if (found === void 0) throw new Error(`[${hostName}] missing ${file} for ${type}@${date}`);
     return found;
   };
+  const validateEdges = (mod, type, date) => {
+    const edges = mod.edges;
+    if (!edges || edges.length === 0 || !buildSchemaForEdges) return;
+    const fields = new Set(topLevelFieldNames(buildSchemaForEdges(mod)));
+    for (const edge of edges) {
+      if (!fields.has(edge.key)) {
+        throw new Error(
+          `[${hostName}] edge key "${edge.key}" declared on "${type}@${date}" is not a field on its schema (has: ${[...fields].join(", ") || "<none>"})`
+        );
+      }
+    }
+  };
   let cached = null;
   const compute = () => {
     if (cached) return cached;
@@ -40,13 +72,16 @@ export function defineRegistry(options) {
         throw new Error(`[${hostName}] compatibilityDate "${mod.compatibilityDate}" does not match folder "${date}"`);
       }
       validateModule?.(mod, type, date);
+      validateEdges(mod, type, date);
       const runtime = runtimeOptional?.(mod) ? findSiblingOptional(runtimeModules, date, type, "runtime.vue") : findSibling(runtimeModules, date, type, "runtime.vue");
       drafts.push({
         type: mod.type,
         compatibilityDate: mod.compatibilityDate,
         config: findSibling(configModules, date, type, "config.vue"),
         runtime,
-        module: mod
+        module: mod,
+        // `prompt.md` is optional per folder; absent → undefined.
+        ...promptModules ? { prompt: findSiblingOptional(promptModules, date, type, "prompt.md") } : {}
       });
     }
     const mapExtras = deriveEntryExtras ? deriveEntryExtras(drafts) : () => ({});
@@ -56,6 +91,7 @@ export function defineRegistry(options) {
       config: draft.config,
       runtime: draft.runtime,
       module: draft.module,
+      ...draft.prompt !== void 0 ? { prompt: draft.prompt } : {},
       ...mapExtras(draft)
     }));
     return cached;

package/dist/runtime/share/use-persisted-chat.d.ts

@@ -1,16 +1,18 @@
 import { type Ref } from 'vue';
 import type { UIMessage } from '../utils/ai/parts.js';
 /**
- * Mirrors a table editor's AI-chat history into `sessionStorage`, keyed on the
- * table's stable `config.id`, so the conversation survives both the chat
- * component unmounting — switching away from the "AI 生成" section `v-if`-
- * unmounts `<TableAiGenerate>`, dropping its local `ref<UIMessage[]>` — and a
- * page reload. It clears when the browser tab is closed (`sessionStorage`
- * lifetime), giving each table a per-instance, session-scoped chat memory.
+ * Mirrors an AI-chat history into `sessionStorage`, keyed on a stable id (the
+ * top-level config panel uses `location.pathname`), so the conversation survives
+ * both the chat component unmounting — switching away from the AI view
+ * `v-if`-unmounts it, dropping its local `ref<UIMessage[]>` — and a page reload.
+ * It clears when the browser tab is closed (`sessionStorage` lifetime), giving a
+ * per-instance, session-scoped chat memory. (Originally built for the table AI
+ * panel, removed in Phase C; now serves the top-level `config/ai-generate.vue`.)
  *
  * Modeled on `usePersistedQuery`: every access is SSR-guarded and guarded
- * against unavailable storage (privacy modes). With no `tableId()` persistence
- * is a no-op (in-memory only) so id-less drafts can't collide on a shared key.
+ * against unavailable storage (privacy modes). With no `tableId()` (the key
+ * getter — a misnomer kept from its table origin) persistence is a no-op
+ * (in-memory only) so id-less drafts can't collide on a shared key.
  *
  * - `restore()` seeds `messages` from the stored snapshot. Call it in
  *   `onMounted`, after the fresh component's empty ref exists, so a remount
@@ -24,7 +26,7 @@ import type { UIMessage } from '../utils/ai/parts.js';
  * replays history as prose only (`partsToText` in `utils/ai`), so a continued
  * conversation never re-sends a dangling tool_use across the restore boundary.
  */
-export declare function usePersistedChat(tableId: () => string | undefined, messages: Ref<UIMessage[]>): {
+export declare function usePersistedChat(tableId: () => string | undefined, messages: Ref<UIMessage[]>, keyPrefix?: string): {
     restore: () => void;
     clear: () => void;
 };

package/dist/runtime/share/use-persisted-chat.js

@@ -1,7 +1,7 @@
 import { watch } from "vue";
 const STORAGE_PREFIX = "shwfed.table.ai-chat.";
-export function usePersistedChat(tableId, messages) {
-  const key = () => `${STORAGE_PREFIX}${tableId()}`;
+export function usePersistedChat(tableId, messages, keyPrefix = STORAGE_PREFIX) {
+  const key = () => `${keyPrefix}${tableId()}`;
   const active = () => Boolean(tableId()) && typeof window !== "undefined";
   function restore() {
     if (!active()) return;
@@ -18,7 +18,7 @@ export function usePersistedChat(tableId, messages) {
     const id = tableId();
     if (!id) return;
     try {
-      window.sessionStorage.removeItem(`${STORAGE_PREFIX}${id}`);
+      window.sessionStorage.removeItem(`${keyPrefix}${id}`);
     } catch {
     }
   }

package/dist/runtime/utils/ai/index.d.ts

@@ -31,7 +31,7 @@ export interface GenerateObjectInput<A, I extends Record<string, unknown>> {
 export interface StreamChatInput {
     readonly messages: ReadonlyArray<UIMessage>;
     readonly system?: string;
-    readonly tools?: ReadonlyArray<AgenticTool>;
+    readonly tools?: ReadonlyArray<AgenticTool> | (() => ReadonlyArray<AgenticTool>);
     readonly signal?: AbortSignal;
     readonly maxTokens?: number;
     readonly onMessageUpdate?: (assistant: UIMessage) => void;

package/dist/runtime/utils/ai/index.js

@@ -257,25 +257,32 @@ function partsToText(parts) {
   return parts.filter((p) => p.type === "text").map((p) => p.text).join("");
 }
 async function streamChat(input) {
-  const helperTools = input.tools ?? [];
-  const helperByName = new Map(helperTools.map((t) => [t.name, t]));
-  const tools = helperTools.length > 0 ? helperTools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.inputJsonSchema
-  })) : void 0;
+  const readTools = (() => {
+    const t = input.tools;
+    if (typeof t === "function") return t;
+    const arr = t ?? [];
+    return () => arr;
+  })();
   const messages = input.messages.map(
     (m) => ({ role: m.role, content: partsToText(m.parts) })
   );
-  const opts = {
-    ...tools !== void 0 ? { tools } : {},
-    ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {}
-  };
+  const maxTokensOpt = input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {};
   const assistant = { id: createMessageId(), role: "assistant", parts: [] };
   const publish = () => input.onMessageUpdate?.(assistant);
   const MAX_TRUNCATION_STREAK = 3;
   let truncationStreak = 0;
   for (; ; ) {
+    const helperTools = readTools();
+    const helperByName = new Map(helperTools.map((t) => [t.name, t]));
+    const anthropicTools = helperTools.length > 0 ? helperTools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputJsonSchema
+    })) : void 0;
+    const opts = {
+      ...anthropicTools !== void 0 ? { tools: anthropicTools } : {},
+      ...maxTokensOpt
+    };
     const partByIndex = /* @__PURE__ */ new Map();
     const response = await callStream(messages, input.system, opts, input.signal, () => {
     }, {

package/dist/runtime/utils/cel-catalog.d.ts

@@ -0,0 +1 @@
+export declare function getCelCatalog(): string;

package/dist/runtime/utils/cel-catalog.js

@@ -0,0 +1,10 @@
+import rawCatalog from "./cel-catalog.md?raw";
+let catalog = rawCatalog;
+if (import.meta.hot) {
+  import.meta.hot.accept("./cel-catalog.md?raw", (mod) => {
+    if (typeof mod?.default === "string") catalog = mod.default;
+  });
+}
+export function getCelCatalog() {
+  return catalog;
+}

package/dist/runtime/utils/cel-catalog.md

@@ -0,0 +1,42 @@
+CEL（Common Expression Language）是一门小而安全的**单表达式**语言：没有语句、赋值、循环或函数定义，整段表达式求值为一个值。以下是本项目可用的操作符与函数速查（完整语义见字段级注解与实际类型检查报错）。
+
+## 类型
+
+`number`（任意精度小数，无 int/float 之分）、`string`（单双引号，`'''多行'''`，`r'原始'`）、`bool`、`bytes`、`null`、`list`、`map`、`Date`（`date('2023-01-15')` 或 `date(unixSeconds)`）。
+
+## 操作符
+
+- 算术：`+ - * / %`、一元 `-`（仅 `number`；`/` 保留 20 位有效数字，勿用 `==` 直接比较除法结果）。
+- 比较：`== != < <= > >=`（对 list/map 深比较）。
+- 逻辑：`&& || !`（短路）。
+- 三元：`cond ? a : b`。
+- 成员：`x in [列表]`、`key in {映射}`。
+- 拼接：字符串 / 列表用 `+`；`[...a, x]` / `{...a, "k": v}` 展开（后写覆盖先写）。
+- 字段访问：`obj.field`、`obj["field"]`；**可选访问** `obj.?field`、`obj[?0]`（返回 `optional`，字段可能缺失时优先用）。
+
+## Optional（可选值，`.?` 会产生）
+
+`optional.of(x)` / `optional.ofNullable(x)`（null→None）/ `optional.none()`；`o.orValue(默认值)`（取值或默认）、`o.or(其他optional)`、`o.hasValue()`、`o.value()`；`o.map(v, 表达式)`、`o.flatMap(v, optional)`、`o.filter(v, 布尔)`、`o.exists(v, 布尔)`。典型：`row.?amount.orValue(0)`。
+
+## 常用函数
+
+- 类型转换：`number(x)`、`string(x)`、`bool(x)`、`type(x)`、`dyn(x)`。无 `int()`，取整用 `math.trunc/floor/ceil/round`。
+- 数学：`math.trunc/floor/ceil/round/abs(n)`、`math.min/max(a, b)` 或 `math.min/max(list)`。
+- 字符串（方法）：`s.size()`、`s.contains(x)`、`s.startsWith/endsWith(x)`、`s.matches(正则)`、`s.substring(i[, j])`、`s.split(sep)`、`s.trim()`、`s.replace(from, to[, limit])`、`s.lowerAscii()/upperAscii()`。
+- 列表（宏 / 方法）：`l.size()`、`l.map(x, 表达式)`、`l.filter(x, 布尔)`、`l.all(x, 布尔)`、`l.exists(x, 布尔)`、`l.exists_one(x, 布尔)`、`l.enumerate()`（→ `{index, value}` 列表）、`l.slice(i[, j])`（支持负索引）。
+- 映射：`Map.fromList(pairs)` / `Map.toList(m)`（pair 为 `{key, value}`，是从数据构建 map 的唯一方式）。
+- JSON：`JSON.parse(s)`、`JSON.stringify(x)`。
+- 日期：`date(...)`、`d.get('year'|'month'(1基)|'day'|'hour'|...)`、`d.diff(other, unit)`（有符号，受者为被减数）、`d.offset(n, unit)`、`d.startOf/endOf(unit)`、`d.format(...)`、`Date.tz(...)`。
+- 区间：`range(a, b[, step])`、`range(startDate, endDate, unit)`（右开）。
+
+## HTTP（构建请求，不发起）
+
+CEL 只**构建** `HttpRequest`，由宿主发起。链式：
+```cel
+http.get(hostname + '/path')          // 或 .post / .put / .delete；端点须为绝对 URL，用 hostname 变量，勿写 {{env}}
+  .header('Content-Type', 'application/json')
+  .query(query)                        // query = 全部搜索条件；放在最前
+  .query('key', value)                 // 值可为 string | number | optional<...>（None 则不追加该参数）
+  .body({ ... })                       // POST/PUT 请求体
+```
+`form({...})` 构建 `FormData`（文件上传：`.body(form({"file": f, "name": "a"}))`）。

package/dist/runtime/utils/cel-context.d.ts

@@ -6,6 +6,21 @@ export type CELVar = {
     value: unknown;
 };
 export type CELContext = Record<string, CELVar>;
+/**
+ * A compact CEL scope entry for AI tool output — `name` + `type`, plus the
+ * designer-facing `label` / `description` when they add anything. Flattens a
+ * `CELContext` (whose `value` thunks are irrelevant to the model) into the
+ * variable table `describe_*_settings` hands the agent alongside the function
+ * catalog. Same probed source the ExpressionEditor advertises, so the two can't
+ * drift.
+ */
+export type CELScopeEntry = {
+    name: string;
+    type: string;
+    label?: string;
+    description?: string;
+};
+export declare function renderCelScope(context: CELContext): CELScopeEntry[];
 export declare const SCOPE_ADDRESS_VAR = "__scopes__";
 export declare const SELECTIONS_VAR = "selections";
 export declare const OPTIONS_VAR = "options";

package/dist/runtime/utils/cel-context.js

@@ -1,5 +1,13 @@
 import { computed, inject, provide, shallowRef } from "vue";
 import { injectLocal, provideLocal } from "@vueuse/core";
+export function renderCelScope(context) {
+  return Object.entries(context).map(([name, v]) => ({
+    name,
+    type: v.type,
+    ...v.label && v.label !== name ? { label: v.label } : {},
+    ...v.description ? { description: v.description } : {}
+  }));
+}
 export const SCOPE_ADDRESS_VAR = "__scopes__";
 export const SELECTIONS_VAR = "selections";
 export const OPTIONS_VAR = "options";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/config",
-  "version": "3.0.7",
+  "version": "3.0.8",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {

package/dist/runtime/components/table/ai-generate.d.vue.ts

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

package/dist/runtime/components/table/ai-generate.system.md

@@ -1,101 +0,0 @@
-帮助用户进行配置表格。你的回复可以使用 CommonMark。你应该按照：确认既存配置、变更新增配置、验证配置结果的循环进行。
-
-## 处理 API 接口
-
-用户可能发送给你 API 接口信息。根据 API 接口可以配置如下内容
-
-- 通用配置
-- 列
-- 搜索条件
-
-### 配置通用配置
-
-利用 API 接口名字等相关信息，配置表格 `displayName`。
-
-根据 API 接口，构造 `dataSource` 相关字段。对于 `request` 应当形如
-
-```cel
-http
-  .post('<construct full URL>') // use .get if request is in GET method
-  
-  // API doc might use env var surrounded by double brackets, these are NOT AVAILABLE in CEL, you should use the `hostname` var instead, e.g., `.get(hostname + '/foo/bar')`
-  
-  .header('<key>', '<value>') // use this to set request header
-  
-  .query(query) // `query` represents all the table search conditions, put it as the first query
-  .query('<key>', '<value>') // .query method signature: .query(string, string | number | optional<string> | optional<number> | dyn)
-  
-  // API doc might contain demonstration purpose query, DO NOT hardcode
-  // same name query will NOT overwrite, but form URL like `&foo=bar&foo=zoo`
-  
-  // if the API supports pagination, you might need to use `pageIndex` and `pageSize` to pass pagination info to the backend, like `.query('page_index', pageIndex + 1).query('page_size', pageSize)`, be aware the `pageIndex` var starts from 0
-  
-  // if the request is POST, you can set `.body`, it's signature is `.body(dyn)`
-  // if you're gonna sent JSON request, remember to set `.header('Content-Type', 'application/json')` where header name is case-insensitive following RFC.
-  .body({
-    // ...
-  })
-```
-
-对于 `data` 应当指向 Response 的列表，比如对于下面的这个响应，`data` 应当设置为 `json.?data.?list`
-
-```json
-{
-  "code": 0,
-  "data": {
-    "list": [
-      {
-        "foo": "bar",
-        "buz": {
-          "bao": "zoo"
-        }
-      }
-    ],
-    "total": 100,
-  }
-}
-```
-
-对于 `total`，应当指向 Response 中服务器查询到的**总数**，对于上述例子是 `json.?data.?total` 如果你没有找到对应的字段，这个字段可以不填写，并且调用工具将分页功能关闭。
-
-### 配置列
-
-你应该寻找到最外侧的列表。这个列表的每一个元素，通常代表了一行。而其中的每个字段，通常代表了一列。
-
-调用工具，选取合适的类型。你应该首要考虑文本、数值、日期类型。
-
-对于只读的字段，你需要配置 `accessor`，可以使用 `row` 变量，`row` 特指当前行。`accessor` 应该**相对于列表元素**来写，不需要再重复访问列表字段本身。使用 CEL 的 optional 语法，如 `row.?foo.?bar`。
-
-```json
-{
-  "code": 0,
-  "data": {
-    "list": [
-      {
-        "foo": "bar",
-        "buz": {
-          "bao": "zoo"
-        }
-      }
-    ]
-  }
-}
-```
-
-对于上述例子，如果需要展示 `bar` 这个值作为一列，其 `accessor` 应为 `row.?foo`；如果需要展示 `zoo` 这个值作为一列，其 `accessor` 应为 `row.?buz.?bao`。
-
-你应当选取至少一列，并且设置它的 `grow` 为 `true`。
-
-对于金额类型的字段：使用数字类型的列；将其 `align` 设置为 `right`；将其 `displayMode` 设置为 `monoThousand`；设置一个合理的宽度，如 200 或 `grow` 为 `true`。
-
-对于普通的数字：使用数字类型的列；将其 `align` 设置为 `center`。
-
-对于日期、时间类型的字段：使用日期类型的列；对于时间，设置列宽为 140；对于日期，设置列宽为 120；将其 `align` 设置为 `center`。
-
-对于用户名、ID、各种类型等较短字段，酌情将其 `align` 设置为 `center`。
-
-### 配置搜索条件
-
-你应该根据 API 文档配置其支持的搜索条件。搜索条件应该排除分页、排序相关信息，仅包含业务逻辑。
-
-你应该首要考虑文本输入、数字输入、数字范围输入、日期范围输入、日期时间范围输入。如果你遇到了从多个值中选取一个或多个，考虑单选或者多选。如果你不能确定单选和多选的选项，向用户提问。当你不确定选项时，向用户所要配置选项的相关信息。

package/dist/runtime/components/table/ai-generate.vue.d.ts

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