@shwfed/config 2.2.3 → 2.2.4

package/dist/module.json

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

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