@shwfed/config 2.7.7 → 2.8.0

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

@@ -0,0 +1,21 @@
+import { type Ref } from 'vue';
+import type { FormState } from '../components/form/utils/state.js';
+/**
+ * Mirrors a table's query form state into `sessionStorage` so filters survive
+ * a page reload — until the tab is closed / the user leaves the site.
+ *
+ * Modeled on `useActiveTabId`: storage is keyed on the table's stable
+ * `config.id`, every access is guarded against SSR and unavailable storage
+ * (privacy modes), and `restore()` is meant to run in `onMounted` after the
+ * form's CEL `initial` seed has landed so the stored value overrides it.
+ *
+ * - `restore()` applies a stored snapshot onto `queryState` (no-op when
+ *   disabled, when there is no `tableId`, or when nothing is stored).
+ * - `clear()` drops the stored snapshot (used by `reset-query`, so a reset is
+ *   authoritative and the stale query does not reappear on the next load).
+ * - A deep watch persists live changes while enabled.
+ */
+export declare function usePersistedQuery(tableId: string | undefined, queryState: Ref<FormState>, enabled: () => boolean): {
+    restore: () => void;
+    clear: () => void;
+};

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

@@ -0,0 +1,33 @@
+import { watch } from "vue";
+const STORAGE_PREFIX = "shwfed.table.query.";
+export function usePersistedQuery(tableId, queryState, enabled) {
+  const active = () => Boolean(tableId) && enabled() && typeof window !== "undefined";
+  const key = () => `${STORAGE_PREFIX}${tableId}`;
+  function restore() {
+    if (!active()) return;
+    try {
+      const raw = window.sessionStorage.getItem(key());
+      if (!raw) return;
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        queryState.value = parsed;
+      }
+    } catch {
+    }
+  }
+  function clear() {
+    if (!tableId || typeof window === "undefined") return;
+    try {
+      window.sessionStorage.removeItem(key());
+    } catch {
+    }
+  }
+  watch(queryState, (next) => {
+    if (!active()) return;
+    try {
+      window.sessionStorage.setItem(key(), JSON.stringify(next));
+    } catch {
+    }
+  }, { deep: true });
+  return { restore, clear };
+}

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

@@ -18,7 +18,7 @@ A `range()` built-in has been added (not from upstream) — `range(number, numbe
 
 The `homogeneousAggregateLiterals` and `enableOptionalTypes` environment options have been removed. Aggregate data structures (lists, maps) are always heterogeneous — mixed-type literals are inferred as `list<dyn>` or `map<dyn, dyn>`. Optional types (`.?`, `[?]`, `optional.*` helpers) are always enabled.
 
-The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access). The optional surface is `optional.of(A): optional<A>` (the lift / `pure`), `optional.none()`, `optional.hasValue()`, `optional.value()`, `optional.or(optional)`, `optional.orValue(value)`, plus `optional<A>.flatMap(var, body): optional<B>` — monadic bind, a local addition (not from upstream). `flatMap` is a variable-binding macro (registered with `(ast, ast)` arg types so its body stays unevaluated): on `Some` it binds the value and evaluates `body` (which must itself yield an `optional`); on `None` it short-circuits without touching `body`. Map (`fmap`) is the derived `o.flatMap(v, optional.of(f(v)))`.
+The custom `Optional` class has been replaced with Effect's `Option` type (`import { Option } from 'effect'`). Internal helpers `optionalOf(value)` and `optionalValue(opt)` in `optional.js` handle the CEL-specific semantics (treating `undefined` as `None`, throwing `EvaluationError` on missing value access). The optional surface is `optional.of(A): optional<A>` (the lift / `pure`), `optional.none()`, `optional.hasValue()`, `optional.value()`, `optional.or(optional)`, `optional.orValue(value)`, plus `optional<A>.flatMap(var, body): optional<B>` (monadic bind) and `optional<A>.map(var, body): optional<B>` (the Functor `fmap`) — all local additions (not from upstream). Both are variable-binding macros (registered with `(ast, ast)` arg types so the body stays unevaluated): on `Some` they bind the value and evaluate `body`; on `None` they short-circuit without touching `body`. `flatMap`'s body must itself yield an `optional`; `map`'s body is a plain value that gets re-wrapped in `Some`. `map` is the derived `o.flatMap(v, optional.of(body))` promoted to a first-class macro. NOTE: `map` is **registered in `macros.ts`**, not here — the parser resolves a macro by name before types are known, so the optional `map` and the list-comprehension `map` must share one expander that dispatches on the receiver type at type-check (an `optional` receiver → fmap; `list`/`map` → comprehension; a `dyn` receiver is deferred to a runtime `Option.isOption` check).
 
 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.
 
@@ -41,7 +41,7 @@ lib/
 ├── operators.ts      — Binary/unary operator implementations
 ├── overloads.ts      — Operator overload definitions
 ├── functions.ts      — Built-in functions + Date type (TZDate)
-├── macros.ts         — map, filter, all, exists, exists_one, find, has, cel.bind
+├── macros.ts         — map (list comprehension + optional fmap), 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)

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

@@ -316,18 +316,27 @@ o.orValue(default)                      // unwrap, or `default` when absent
 o.or(otherOptional)                     // first present optional wins
 ```
 
-### flatMap — chain a computation that may itself be absent
-`o.flatMap(v, body)` binds the present value to `v` and evaluates `body` — which
-must itself return an `optional` — only when `o` is present; an absent `o`
+### map — transform a present value
+`o.map(v, body)` binds the present value to `v`, evaluates `body` (a plain value),
+and re-wraps the result as present, only when `o` is present; an absent `o`
 short-circuits to `None` and `body` is never evaluated.
 ```cel
-loc.query("id").flatMap(v, optional.of("user-" + v)).orValue("anon")
+loc.query("id").map(v, "user-" + v).orValue("anon")
 // "user-42" when ?id=42 is present; "anon" when absent
+```
+
+### flatMap — chain a computation that may itself be absent
+`o.flatMap(v, body)` is like `map`, but `body` must itself return an `optional`
+(so it can decide the result is absent). Use `flatMap` when the next step can
+fail; use `map` when it always produces a value.
+```cel
+loc.query("id").flatMap(v, optional.of("user-" + v)).orValue("anon")
+// same as the map example above
 
 optional.of(2).flatMap(v, optional.none()).hasValue()   // false — body collapsed it
 ```
-Together with `optional.of` this is a lawful monad. A plain map (`fmap`) is the
-derived form `o.flatMap(v, optional.of(f(v)))`.
+Together with `optional.of`, `flatMap` is a lawful monad and `map` its derived
+Functor (`o.map(v, body)` == `o.flatMap(v, optional.of(body))`).
 
 ## Macros
 

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

@@ -7,27 +7,79 @@ function assertIdentifier(node, message) {
   if (node.op === "id") return node.args;
   throw parseError("invalid_macro_argument", message, node);
 }
+function buildMapComprehension(callAst, receiver, iterVar, predicate, transform, invalidMsg, label) {
+  let step = transform.clone(OPS.accuPush, transform);
+  if (predicate) {
+    const accuValue = predicate.clone(OPS.accuValue, void 0);
+    step = predicate.clone(OPS.ternary, [predicate.setMeta("label", label), step, accuValue]);
+  }
+  return callAst.clone(OPS.comprehension, {
+    errorsAreFatal: true,
+    iterable: receiver,
+    iterVarName: assertIdentifier(iterVar, invalidMsg),
+    init: callAst.clone(OPS.list, []),
+    step,
+    result: identity
+  });
+}
 function createMapExpander(hasFilter) {
   const functionDesc = hasFilter ? "map(var, filter, transform)" : "map(var, transform)";
   const invalidMsg = `${functionDesc} invalid predicate iteration variable`;
   const label = `${functionDesc} filter predicate must return bool`;
+  if (hasFilter) {
+    return (opts) => {
+      const { args, receiver, ast: callAst } = opts;
+      return { callAst: buildMapComprehension(callAst, receiver, args[0], args[1], args[2], invalidMsg, label) };
+    };
+  }
+  function functorMap(ev, macro, ctx, recv) {
+    return Effect.gen(function* () {
+      if (Option.isNone(recv)) return Option.none();
+      const iterCtx = macro.iterCtx.reuse(ctx);
+      const result = yield* ev.eval(macro.body, iterCtx.setIterValue(recv.value, ev));
+      return Option.some(result);
+    });
+  }
+  function typeCheck(chk, macro, ctx) {
+    const recvType = chk.check(macro.receiver, ctx);
+    if (recvType.kind === "optional") {
+      macro.mode = "optional";
+      const innerType = recvType.valueType ?? chk.getType("dyn");
+      macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, innerType);
+      const bodyType = chk.check(macro.body, macro.iterCtx);
+      return chk.registry.getOptionalType(bodyType);
+    }
+    if (recvType.kind === "dyn") {
+      macro.mode = "dyn";
+      macro.iterCtx = ctx.forkWithVariable(macro.iterVarName, chk.getType("dyn"));
+      chk.check(macro.comprehension, ctx);
+      return chk.getType("dyn");
+    }
+    macro.mode = "list";
+    return chk.check(macro.comprehension, ctx);
+  }
+  function evaluate(ev, macro, ctx) {
+    if (macro.mode === "list") return ev.eval(macro.comprehension, ctx);
+    if (macro.mode === "optional") {
+      return Effect.flatMap(ev.eval(macro.receiver, ctx), (recv) => functorMap(ev, macro, ctx, recv));
+    }
+    return Effect.flatMap(
+      ev.eval(macro.receiver, ctx),
+      (recv) => Option.isOption(recv) ? functorMap(ev, macro, ctx, recv) : ev.eval(macro.comprehension, ctx)
+    );
+  }
   return (opts) => {
     const { args, receiver, ast: callAst } = opts;
-    const [iterVar, predicate, transform] = hasFilter ? args : [args[0], null, args[1]];
-    let step = transform.clone(OPS.accuPush, transform);
-    if (predicate) {
-      const accuValue = predicate.clone(OPS.accuValue, void 0);
-      step = predicate.clone(OPS.ternary, [predicate.setMeta("label", label), step, accuValue]);
-    }
     return {
-      callAst: callAst.clone(OPS.comprehension, {
-        errorsAreFatal: true,
-        iterable: receiver,
-        iterVarName: assertIdentifier(iterVar, invalidMsg),
-        init: callAst.clone(OPS.list, []),
-        step,
-        result: identity
-      })
+      ast: callAst,
+      receiver,
+      iterVarName: assertIdentifier(args[0], invalidMsg),
+      body: args[1],
+      comprehension: buildMapComprehension(callAst, receiver, args[0], null, args[1], invalidMsg, label),
+      iterCtx: void 0,
+      mode: "list",
+      typeCheck,
+      evaluate
     };
   };
 }

package/package.json

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

package/dist/preview/assets/index-CSfKAdi7.js

@@ -1 +0,0 @@
-import{b2 as e}from"./index-CHzOsSTW.js";import{b3 as f,b4 as r,b5 as s}from"./index-CHzOsSTW.js";export{f as TableConfig,r as createTableConfig,e as default,s as getColumnTechnicalKey};