@shwfed/config 2.2.3 → 2.2.5

package/dist/module.json

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

package/dist/runtime/components/form/fields/2026-05-13/com.shwfed.form.field.list/row.d.vue.ts

@@ -1,17 +1,16 @@
 import type { FormUnitValue } from '../../../schema.js';
-import { type FormState } from '../../../utils/state.js';
 type __VLS_Props = {
     unit: FormUnitValue;
     index: number;
 };
 type __VLS_ModelProps = {
-    modelValue: FormState;
+    modelValue: unknown;
 };
 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: FormState) => any;
+    "update:modelValue": (value: unknown) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: FormState) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/form/fields/2026-05-13/com.shwfed.form.field.list/row.vue

@@ -6,7 +6,7 @@ import FormUnitRenderer from "../../../FormUnitRenderer.vue";
 import { useDerived, useDerivedQuiescence } from "../../../utils/derived";
 import { provideFormState } from "../../../utils/state";
 defineOptions({ name: "ShwfedListFieldRow" });
-const state = defineModel({ type: Object, ...{ required: true } });
+const state = defineModel({ type: null, ...{ required: true } });
 const props = defineProps({
   unit: { type: Object, required: true },
   index: { type: Number, required: true }

package/dist/runtime/components/form/fields/2026-05-13/com.shwfed.form.field.list/row.vue.d.ts

@@ -1,17 +1,16 @@
 import type { FormUnitValue } from '../../../schema.js';
-import { type FormState } from '../../../utils/state.js';
 type __VLS_Props = {
     unit: FormUnitValue;
     index: number;
 };
 type __VLS_ModelProps = {
-    modelValue: FormState;
+    modelValue: unknown;
 };
 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: FormState) => any;
+    "update:modelValue": (value: unknown) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: FormState) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/form/fields/2026-05-13/com.shwfed.form.field.list/runtime.vue

@@ -14,7 +14,7 @@ import { Button } from "../../../../ui/button";
 import { Field, FieldLabel } from "../../../../ui/field";
 import { InputGroupButton } from "../../../../ui/input-group";
 import { Markdown } from "../../../../ui/markdown";
-import { useFormState } from "../../../utils/state";
+import { SELF_BINDING, useFormState } from "../../../utils/state";
 import Row from "./row.vue";
 defineOptions({ name: "ShwfedListFieldRuntime" });
 const props = defineProps({
@@ -45,6 +45,12 @@ function evalBool(expression, label) {
 }
 const isDisabled = computed(() => evalBool(props.config.disabled, "disabled"));
 const reorderable = computed(() => props.config.reorderable ?? true);
+const isScalarRow = computed(() => {
+  const fields = props.config.unit.fields;
+  if (fields.length !== 1) return false;
+  const only = fields[0];
+  return only.binding === SELF_BINDING;
+});
 const localItems = ref([]);
 const items = computed(() => {
   const path = props.config.binding;
@@ -120,7 +126,8 @@ const canRemove = computed(() => !isDisabled.value && !atMin.value);
 const canReorder = computed(() => !isDisabled.value && reorderable.value);
 function append() {
   if (!canAdd.value) return;
-  writeItems([...items.value, {}]);
+  const seed = isScalarRow.value ? null : {};
+  writeItems([...items.value, seed]);
   const id = makeId();
   rowKeys.value = [...rowKeys.value, id];
   const next = new Set(expandedKeys.value);

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

@@ -1,7 +1,15 @@
 import type { InjectionKey, Ref } from 'vue';
 export type FormState = Record<string, unknown>;
+/**
+ * Sentinel binding meaning "the bag's state itself", not a key inside it.
+ * Used by `list` rows that hold scalar items: the inner field's `binding: '.'`
+ * tells the bag to read/replace `state.value` wholesale instead of walking
+ * into it as a dot-prop path. dot-prop has no notion of a self-path, so the
+ * bag intercepts this before delegating.
+ */
+export declare const SELF_BINDING: ".";
 export type FormStateBag = {
-    state: Ref<FormState>;
+    state: Ref<unknown>;
     getAt: (path: string) => unknown;
     /**
      * Write a value at `path` on behalf of a **user interaction**. Besides
@@ -33,5 +41,5 @@ export type FormStateBag = {
     markDirty: (path: string) => void;
 };
 export declare const FORM_STATE_KEY: InjectionKey<FormStateBag>;
-export declare function provideFormState(state: Ref<FormState>): FormStateBag;
+export declare function provideFormState(state: Ref<unknown>): FormStateBag;
 export declare function useFormState(): FormStateBag;

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

@@ -1,18 +1,25 @@
 import { getProperty, setProperty } from "dot-prop";
 import { inject, provide, ref } from "vue";
+export const SELF_BINDING = ".";
 export const FORM_STATE_KEY = Symbol("shwfed-form-state");
 export function provideFormState(state) {
   const dirty = ref(/* @__PURE__ */ new Set());
   function write(path, value) {
-    setProperty(state.value, path, value === void 0 ? null : value);
-    state.value = { ...state.value };
+    const normalized = value === void 0 ? null : value;
+    if (path === SELF_BINDING) {
+      state.value = normalized;
+      return;
+    }
+    const current = state.value;
+    setProperty(current, path, normalized);
+    state.value = { ...current };
   }
   function markDirty(path) {
     if (!dirty.value.has(path)) dirty.value = new Set(dirty.value).add(path);
   }
   const bag = {
     state,
-    getAt: (path) => getProperty(state.value, path),
+    getAt: (path) => path === SELF_BINDING ? state.value : getProperty(state.value, path),
     setAt: (path, value) => {
       write(path, value);
       markDirty(path);

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.3",
+  "version": "2.2.5",
   "description": "Configurable UI for SHWFED",
   "type": "module",
   "publishConfig": {