@shwfed/config 2.2.2 → 2.2.4

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "shwfed",
   "configKey": "shwfed",
-  "version": "2.2.2",
+  "version": "2.2.4",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/config/blocks/2026-05-06/com.shwfed.block.form/schema.d.ts

@@ -80,10 +80,13 @@ export declare function schema(configure: (env: Environment) => void, _blockRef:
             }>;
         }>>>;
         kind: Schema.tag<"shwfed.component.form">;
-        initial: Schema.optional<Schema.Struct<{
+        initial: Schema.optional<Schema.transform<Schema.Union<[Schema.Schema<string, string, never>, Schema.Struct<{
             request: Schema.optional<Schema.Schema<string, string, never>>;
             data: Schema.Schema<string, string, never>;
-        }>>;
+        }>]>, Schema.Struct<{
+            request: Schema.optional<Schema.Schema<string, string, never>>;
+            data: Schema.Schema<string, string, never>;
+        }>>>;
         readonly: Schema.optional<Schema.Schema<string, string, never>>;
     }>>;
 }>;

package/dist/runtime/components/config/blocks/2026-05-06/com.shwfed.block.table/schema.d.ts

@@ -347,10 +347,13 @@ export declare function schema(configure: (env: Environment) => void, _blockRef:
                 }>;
             }>>>;
             kind: Schema.tag<"shwfed.component.form">;
-            initial: Schema.optional<Schema.Struct<{
+            initial: Schema.optional<Schema.transform<Schema.Union<[Schema.Schema<string, string, never>, Schema.Struct<{
                 request: Schema.optional<Schema.Schema<string, string, never>>;
                 data: Schema.Schema<string, string, never>;
-            }>>;
+            }>]>, Schema.Struct<{
+                request: Schema.optional<Schema.Schema<string, string, never>>;
+                data: Schema.Schema<string, string, never>;
+            }>>>;
             readonly: Schema.optional<Schema.Schema<string, string, never>>;
         }>>>;
         cellStyle: Schema.optional<Schema.Schema<string, string, never>>;

package/dist/runtime/components/form/schema.d.ts

@@ -138,10 +138,13 @@ export declare function FormConfig(configure: (env: Environment) => void): Schem
         }>;
     }>>>;
     kind: Schema.tag<"shwfed.component.form">;
-    initial: Schema.optional<Schema.Struct<{
+    initial: Schema.optional<Schema.transform<Schema.Union<[Schema.Schema<string, string, never>, Schema.Struct<{
         request: Schema.optional<Schema.Schema<string, string, never>>;
         data: Schema.Schema<string, string, never>;
-    }>>;
+    }>]>, Schema.Struct<{
+        request: Schema.optional<Schema.Schema<string, string, never>>;
+        data: Schema.Schema<string, string, never>;
+    }>>>;
     readonly: Schema.optional<Schema.Schema<string, string, never>>;
 }>>;
 export declare function createFormConfig(body: Omit<Schema.Schema.Type<ReturnType<typeof FormConfig>>, 'kind'>): {

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

@@ -58,30 +58,40 @@ export function FormConfig(configure) {
     resultType: "dyn"
   });
   const CelFormReadonly = Expression({ configure: formConfigure, resultType: "bool" });
-  return Schema.Struct({
-    kind: Schema.tag(KIND),
-    initial: Schema.optional(Schema.Struct({
-      request: Schema.optional(CelInitialRequest.annotations({
-        title: "\u8BF7\u6C42",
-        description: md`
-          可选的 HTTP 请求表达式：返回 \`HttpRequest\`，运行时由宿主发起，并把响应体作为 \`json\` 传给「数据」表达式。
+  const InitialStruct = Schema.Struct({
+    request: Schema.optional(CelInitialRequest.annotations({
+      title: "\u8BF7\u6C42",
+      description: md`
+        可选的 HTTP 请求表达式：返回 \`HttpRequest\`，运行时由宿主发起，并把响应体作为 \`json\` 传给「数据」表达式。
 
-          留空时「数据」直接对 CEL 上下文求值（静态默认值，或引用 \`form\` 的表达式）。
-        `
-      })),
-      data: CelInitialData.annotations({
-        title: "\u6570\u636E",
-        description: md`
-          返回整个表单初始值的 CEL 表达式（应为一个对象）：
+        留空时「数据」直接对 CEL 上下文求值（静态默认值，或引用 \`form\` 的表达式）。
+      `
+    })),
+    data: CelInitialData.annotations({
+      title: "\u6570\u636E",
+      description: md`
+        返回整个表单初始值的 CEL 表达式（应为一个对象）：
 
-          - 可以互相依赖，但应避免循环引用。考虑一个含「用户名」与「用户角色」的表单：可默认填入当前登入人的用户名，再以此为依据填入其默认角色。
+        - 可以互相依赖，但应避免循环引用。考虑一个含「用户名」与「用户角色」的表单：可默认填入当前登入人的用户名，再以此为依据填入其默认角色。
 
-          - 配置了「请求」时，可通过 \`json\` 引用响应体，例如 \`json.?data\`。
+        - 配置了「请求」时，可通过 \`json\` 引用响应体，例如 \`json.?data\`。
 
-          - 如果配置了初始值，重置这个表单将**重置为其初始值，而非空**。
-        `
-      })
-    }).annotations({
+        - 如果配置了初始值，重置这个表单将**重置为其初始值，而非空**。
+      `
+    })
+  });
+  const Initial = Schema.transform(
+    Schema.Union(CelInitialData, InitialStruct),
+    InitialStruct,
+    {
+      strict: true,
+      decode: (input) => typeof input === "string" ? { data: input } : input,
+      encode: (output) => output
+    }
+  );
+  return Schema.Struct({
+    kind: Schema.tag(KIND),
+    initial: Schema.optional(Initial.annotations({
       title: "\u521D\u59CB\u503C",
       description: "\u8868\u5355\u521D\u59CB\u503C\u7684\u6765\u6E90\uFF1A\u53EF\u9009\u7684 HTTP \u8BF7\u6C42\uFF0C\u52A0\u4E00\u4E2A\u8FD4\u56DE\u521D\u59CB\u503C\u5BF9\u8C61\u7684 CEL \u8868\u8FBE\u5F0F"
     })),

package/dist/runtime/components/table/schema.d.ts

@@ -432,10 +432,13 @@ export declare function TableConfig(configure: (env: Environment) => void): Sche
             }>;
         }>>>;
         kind: Schema.tag<"shwfed.component.form">;
-        initial: Schema.optional<Schema.Struct<{
+        initial: Schema.optional<Schema.transform<Schema.Union<[Schema.Schema<string, string, never>, Schema.Struct<{
             request: Schema.optional<Schema.Schema<string, string, never>>;
             data: Schema.Schema<string, string, never>;
-        }>>;
+        }>]>, Schema.Struct<{
+            request: Schema.optional<Schema.Schema<string, string, never>>;
+            data: Schema.Schema<string, string, never>;
+        }>>>;
         readonly: Schema.optional<Schema.Schema<string, string, never>>;
     }>>>;
     cellStyle: Schema.optional<Schema.Schema<string, string, never>>;

package/dist/runtime/components/ui/date-picker/DatePicker.vue

@@ -214,7 +214,6 @@ function applyShortcut(index) {
       <PopoverContent
         align="start"
         :class="cn('w-auto p-0', props.popoverClass)"
-        :style="{ minWidth: 'var(--reka-popover-trigger-width)' }"
         @open-auto-focus="(event) => event.preventDefault()"
         @interact-outside="onInteractOutside"
       >

package/dist/runtime/vendor/cel-js/CLAUDE.md

@@ -22,6 +22,8 @@ The custom `Optional` class has been replaced with Effect's `Option` type (`impo
 
 An `http` built-in has been added (`http-builtins.ts`, `http-builder.ts`) — not from upstream. It registers the `http` constant and the `http` / `HttpRequest` types on `globalRegistry`, so `http.get(url).header(...).body(...)` expressions type-check and evaluate in every `Environment`. A CEL expression only builds an `HttpRequestBuilder` — a pure description of a request; it never issues one. Both terminal methods, `.json()` and `.file()`, are dispatched by the host on the returned builder (neither is a CEL method), so expression evaluation stays free of IO. Endpoints must be absolute URLs — there is no base-URL resolution. Depends on `fx-fetch`. The host can register process-wide default headers via `HttpRequestBuilder.setDefaultHeader(name, valueOrGetter)` / `clearDefaultHeader(name)`; they are merged in at `#buildRequest()` time, with case-insensitive precedence to an explicit `.header(...)` on the builder. A getter that returns `null` / `undefined` / `''` skips the header for that request, so the host can source values from live refs (e.g. the active i18n locale for `Accept-Language`) without baking in stale snapshots.
 
+A `JSON` built-in namespace has been added (`json-builtins.ts`) — not from upstream. It registers a `JSON` brand class and a same-named constant on `globalRegistry`, so `JSON.parse(string): dyn` and `JSON.stringify(dyn): string` resolve in every `Environment`. The CEL-side surface mirrors the JS globals deliberately. `JSON.parse` is a thin wrapper over `globalThis.JSON.parse` — numbers come back as plain JS `number` (the evaluator coerces via `Decimal.from` at use time). `JSON.stringify` pre-walks the value via `normalizeForJSON` before handing it to `globalThis.JSON.stringify`: `Decimal` → JS number (via `.toNumber()` — loses precision past safe-integer range, deliberate trade-off for idiomatic JSON output), `Option.Some(x)` → `x`, `Option.None` → `null`, `Map` → plain object, `Date`/`TZDate` passes through so its built-in `toJSON` emits ISO 8601. The pre-walk is required because Effect's `Option` defines its own `toJSON()` that runs before any replacer would see it.
+
 Spread syntax (`...expr`) inside list and map literals — not from upstream. A new `ELLIPSIS` token (3-char lookahead in the lexer) and a `spread` AST op let `[1, ...a, 4]` and `{...a, "x": 1, ...b}` desugar inside the parent literal. The spread node's own `check`/`evaluate` are defensive stubs — `parsePrimary` never produces one, so `...` outside a list/map is an "unexpected token" parse error. List `args` shape is unchanged (`IASTNode[]`, with spread elements detected via `op === 'spread'`); map `args` becomes `([IASTNode, IASTNode] | [IASTNode])[]` — a length-1 tuple represents a spread entry, preserving positional ordering for override semantics (later writes win). The fast path is preserved: the `list`/`map` `check` swaps `evaluate` meta to `evaluateSpreadList`/`evaluateSpreadMap` only when a spread child is present; literals without spreads run the original `resolveAstArray`/`safeFromEntries` paths byte-for-byte. Spread map sources may be plain objects, `Map` instances, or registered message types (typed as `map<string, dyn>`); the `__proto__`/`constructor`/`prototype` skip from `safeFromEntries` is applied to spread sources too. Runtime errors fire on non-list/non-map sources (including `null`). `maxListElements` / `maxMapEntries` count a spread as one entry — runtime expansion bypasses those caps (deliberate trade-off). Call-argument spread (`f(...args)`) is **not** supported.
 
 ## Architecture
@@ -39,6 +41,7 @@ lib/
 ├── macros.ts         — map, filter, all, exists, exists_one, find, has, cel.bind
 ├── http-builtins.ts  — `http` constant + http/HttpRequest types (local addition)
 ├── http-builder.ts   — `HttpRequestBuilder` — what an http.* expression returns
+├── json-builtins.ts  — `JSON` constant + `JSON.parse` / `JSON.stringify` (local addition)
 ├── decimal.ts        — Decimal class (arbitrary precision)
 ├── optional.ts       — Optional type support (uses Effect Option)
 ├── serialize.ts      — AST back to CEL string

package/dist/runtime/vendor/cel-js/PROMPT.md

@@ -160,6 +160,20 @@ b"hello".at(0)                       // 104
 size(b"hello")                       // 5
 ```
 
+### JSON
+```cel
+JSON.parse('{"a":1,"b":[2,3]}')      // dyn value: {"a": 1, "b": [2, 3]}
+JSON.parse("42")                     // 42
+JSON.stringify({"a": 1, "b": [2,3]}) // '{"a":1,"b":[2,3]}'
+JSON.stringify(1 + 2)                // "3"
+```
+`JSON` is a built-in namespace — you don't import it, it's always available.
+`JSON.parse` accepts any JSON string and returns a `dyn` value.
+`JSON.stringify` takes any value and serializes it; CEL-internal shapes are
+unwrapped first so the output is plain JSON — numbers (CEL's `Decimal`) become
+JS numbers, optionals become their value (or `null` when empty), and `Date`
+values become ISO 8601 strings.
+
 ### Dates
 ```cel
 date("2023-06-15")                   // create a Date

package/dist/runtime/vendor/cel-js/lib/evaluator.js

@@ -3,6 +3,7 @@ import { createRegistry, RootContext } from "./registry.js";
 import { evaluationError } from "./errors.js";
 import { registerFunctions } from "./functions.js";
 import { registerHttpBuiltins } from "./http-builtins.js";
+import { registerJSONBuiltins } from "./json-builtins.js";
 import { registerMacros } from "./macros.js";
 import { registerOverloads } from "./overloads.js";
 import { TypeChecker } from "./type-checker.js";
@@ -14,6 +15,7 @@ registerFunctions(globalRegistry);
 registerOverloads(globalRegistry);
 registerMacros(globalRegistry);
 registerHttpBuiltins(globalRegistry);
+registerJSONBuiltins(globalRegistry);
 class Environment {
   #registry;
   #evaluator;

package/dist/runtime/vendor/cel-js/lib/json-builtins.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from './registry.js.js';
+export declare function registerJSONBuiltins(registry: Registry): void;

package/dist/runtime/vendor/cel-js/lib/json-builtins.js

@@ -0,0 +1,51 @@
+import { Option } from "effect";
+import { evaluationError } from "./errors.js";
+import { Decimal } from "./decimal.js";
+class JSONNamespace {
+  brand = "JSON";
+}
+const JSON_INSTANCE = new JSONNamespace();
+function normalizeForJSON(value) {
+  if (value === null || value === void 0) return value;
+  if (value instanceof Decimal) return value.toNumber();
+  if (Option.isOption(value)) {
+    return Option.isSome(value) ? normalizeForJSON(value.value) : null;
+  }
+  if (value instanceof Date) return value;
+  if (value instanceof Map) {
+    const out = {};
+    for (const [k, v] of value) out[String(k)] = normalizeForJSON(v);
+    return out;
+  }
+  if (Array.isArray(value)) return value.map(normalizeForJSON);
+  if (typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== Object.prototype && proto !== null) return value;
+    const out = {};
+    for (const key of Object.keys(value)) {
+      out[key] = normalizeForJSON(value[key]);
+    }
+    return out;
+  }
+  return value;
+}
+export function registerJSONBuiltins(registry) {
+  registry.registerType("JSON", JSONNamespace);
+  registry.registerVariable({
+    name: "JSON",
+    type: "JSON",
+    value: JSON_INSTANCE,
+    description: "JSON \u7F16\u89E3\u7801"
+  });
+  registry.registerFunctionOverload("JSON.parse(string): dyn", (_r, s) => {
+    try {
+      return globalThis.JSON.parse(s);
+    } catch (e) {
+      throw evaluationError("invalid_json", `JSON.parse(): ${e.message}`);
+    }
+  });
+  registry.registerFunctionOverload(
+    "JSON.stringify(dyn): string",
+    (_r, v) => globalThis.JSON.stringify(normalizeForJSON(v))
+  );
+}

package/package.json

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