@shwfed/config 2.7.7 → 2.7.8

package/dist/runtime/components/ui/expression-editor/ExpressionEditor.vue

@@ -1,6 +1,7 @@
 <script setup>
 import { Icon } from "@iconify/vue";
 import { computed, ref, useSlots, useTemplateRef, watch } from "vue";
+import { buildCheckEnvironment, evaluateExpression } from "../../../share/expression";
 import { injectCELContext, useScopeAncestry } from "../../../utils/cel-context";
 import { Markdown } from "../markdown";
 import CodeMirrorInput from "./CodeMirrorInput.vue";
@@ -17,7 +18,8 @@ const props = defineProps({
   multiline: { type: Boolean, required: false },
   placeholder: { type: String, required: false },
   resultType: { type: [String, Array], required: false },
-  extraVars: { type: Object, required: false }
+  extraVars: { type: Object, required: false },
+  unlistedVarsAreDyn: { type: Boolean, required: false }
 });
 const emits = defineEmits(["update:modelValue"]);
 const celContext = injectCELContext();
@@ -26,6 +28,20 @@ const varEntries = computed(() => buildVarEntries(celContext, props.extraVars));
 const scopeEntries = computed(() => buildScopeEntries(scopeAncestry.value.slice(1)));
 const scopeLookup = computed(() => buildScopeLookup(scopeAncestry.value));
 const hasVars = computed(() => varEntries.value.length > 0 || scopeEntries.value.length > 0);
+const checkEnvironment = computed(() => {
+  const vars = /* @__PURE__ */ new Map();
+  for (const [name, entry] of Object.entries(celContext)) vars.set(name, entry.type);
+  for (const [name, spec] of Object.entries(props.extraVars ?? {})) vars.set(name, spec.type);
+  return buildCheckEnvironment(
+    [...vars].map(([name, type]) => ({ name, type })),
+    { unlistedVariablesAreDyn: props.unlistedVarsAreDyn }
+  );
+});
+const validationError = computed(() => {
+  const value = props.modelValue ?? props.defaultValue ?? "";
+  if (value.trim() === "") return null;
+  return evaluateExpression(checkEnvironment.value, value, props.resultType);
+});
 const open = ref(false);
 const entries = ref([]);
 const shownVars = computed(() => entries.value.filter((e) => e.group === "var"));
@@ -60,120 +76,128 @@ const addonAlign = computed(
 </script>
 
 <template>
-  <InputGroup>
-    <InputGroupAddon
-      v-if="$slots.leading"
-      align="inline-start"
-    >
-      <slot name="leading" />
-    </InputGroupAddon>
-    <CodeMirrorInput
-      ref="editor"
-      :model-value="props.modelValue"
-      :default-value="props.defaultValue"
-      :placeholder="props.placeholder"
-      :multiline="props.multiline"
-      :scope-lookup="scopeLookup"
-      :class="props.class"
-      @update:model-value="(v) => emits('update:modelValue', v)"
-    />
-    <InputGroupAddon
-      v-if="showAddon"
-      :align="addonAlign"
-      class="justify-end gap-1.5"
-    >
-      <Popover
-        v-if="hasVars"
-        v-model:open="open"
+  <div class="flex flex-col gap-1.5">
+    <InputGroup>
+      <InputGroupAddon
+        v-if="$slots.leading"
+        align="inline-start"
       >
-        <PopoverTrigger as-child>
-          <InputGroupButton
-            size="icon-xs"
-            aria-label="Inspect available variables"
-          >
-            <Icon icon="fluent:braces-variable-20-regular" />
-          </InputGroupButton>
-        </PopoverTrigger>
-        <PopoverContent
-          align="end"
-          :side-offset="6"
-          class="group/popover w-80 p-0 data-[side=top]:**:data-[slot=command-input-wrapper]:border-t data-[side=top]:**:data-[slot=command-input-wrapper]:border-b-0"
+        <slot name="leading" />
+      </InputGroupAddon>
+      <CodeMirrorInput
+        ref="editor"
+        :model-value="props.modelValue"
+        :default-value="props.defaultValue"
+        :placeholder="props.placeholder"
+        :multiline="props.multiline"
+        :scope-lookup="scopeLookup"
+        :class="props.class"
+        @update:model-value="(v) => emits('update:modelValue', v)"
+      />
+      <InputGroupAddon
+        v-if="showAddon"
+        :align="addonAlign"
+        class="justify-end gap-1.5"
+      >
+        <Popover
+          v-if="hasVars"
+          v-model:open="open"
         >
-          <Command class="rounded group-data-[side=top]/popover:flex-col-reverse">
-            <CommandInput placeholder="搜索可用变量" />
-            <CommandList class="max-h-48 overflow-y-auto">
-              <CommandEmpty>No variables.</CommandEmpty>
-              <CommandGroup>
-                <CommandItem
-                  v-for="entry in shownVars"
-                  :key="entry.id"
-                  :value="entry.display"
-                  class="cursor-pointer gap-2"
-                  @select="insertVariable(entry.insert)"
-                  @mouseenter="hoveredName = entry.id"
-                  @focus="hoveredName = entry.id"
+          <PopoverTrigger as-child>
+            <InputGroupButton
+              size="icon-xs"
+              aria-label="Inspect available variables"
+            >
+              <Icon icon="fluent:braces-variable-20-regular" />
+            </InputGroupButton>
+          </PopoverTrigger>
+          <PopoverContent
+            align="end"
+            :side-offset="6"
+            class="group/popover w-80 p-0 data-[side=top]:**:data-[slot=command-input-wrapper]:border-t data-[side=top]:**:data-[slot=command-input-wrapper]:border-b-0"
+          >
+            <Command class="rounded group-data-[side=top]/popover:flex-col-reverse">
+              <CommandInput placeholder="搜索可用变量" />
+              <CommandList class="max-h-48 overflow-y-auto">
+                <CommandEmpty>No variables.</CommandEmpty>
+                <CommandGroup>
+                  <CommandItem
+                    v-for="entry in shownVars"
+                    :key="entry.id"
+                    :value="entry.display"
+                    class="cursor-pointer gap-2"
+                    @select="insertVariable(entry.insert)"
+                    @mouseenter="hoveredName = entry.id"
+                    @focus="hoveredName = entry.id"
+                  >
+                    <Icon
+                      icon="fluent:braces-variable-20-regular"
+                      class="size-3.5 shrink-0 text-zinc-400"
+                    />
+                    <span class="font-mono text-xs text-zinc-800">{{ entry.display }}</span>
+                    <span class="flex-1 truncate text-xs text-zinc-500">{{ entry.label }}</span>
+                    <span class="rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none">
+                      {{ entry.type }}
+                    </span>
+                  </CommandItem>
+                </CommandGroup>
+                <CommandGroup
+                  v-if="shownScopes.length > 0"
+                  heading="跨层引用"
                 >
-                  <Icon
-                    icon="fluent:braces-variable-20-regular"
-                    class="size-3.5 shrink-0 text-zinc-400"
-                  />
-                  <span class="font-mono text-xs text-zinc-800">{{ entry.display }}</span>
-                  <span class="flex-1 truncate text-xs text-zinc-500">{{ entry.label }}</span>
-                  <span class="rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none">
-                    {{ entry.type }}
-                  </span>
-                </CommandItem>
-              </CommandGroup>
-              <CommandGroup
-                v-if="shownScopes.length > 0"
-                heading="跨层引用"
+                  <CommandItem
+                    v-for="entry in shownScopes"
+                    :key="entry.id"
+                    :value="`${entry.display} ${entry.id}`"
+                    class="cursor-pointer gap-2"
+                    @select="insertVariable(entry.insert)"
+                    @mouseenter="hoveredName = entry.id"
+                    @focus="hoveredName = entry.id"
+                  >
+                    <Icon
+                      icon="fluent:link-20-regular"
+                      class="size-3.5 shrink-0 text-zinc-400"
+                    />
+                    <span class="flex-1 truncate text-xs text-zinc-700">{{ entry.display }}</span>
+                    <span class="rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none">
+                      {{ entry.type }}
+                    </span>
+                  </CommandItem>
+                </CommandGroup>
+              </CommandList>
+              <div
+                v-if="hoveredEntry"
+                class="border-t border-zinc-200 px-3 py-2 group-data-[side=top]/popover:border-t-0 group-data-[side=top]/popover:border-b"
               >
-                <CommandItem
-                  v-for="entry in shownScopes"
-                  :key="entry.id"
-                  :value="`${entry.display} ${entry.id}`"
-                  class="cursor-pointer gap-2"
-                  @select="insertVariable(entry.insert)"
-                  @mouseenter="hoveredName = entry.id"
-                  @focus="hoveredName = entry.id"
-                >
-                  <Icon
-                    icon="fluent:link-20-regular"
-                    class="size-3.5 shrink-0 text-zinc-400"
-                  />
-                  <span class="flex-1 truncate text-xs text-zinc-700">{{ entry.display }}</span>
-                  <span class="rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none">
-                    {{ entry.type }}
+                <div class="flex items-center gap-2">
+                  <span class="text-xs font-medium text-zinc-700">{{ hoveredEntry.label }}</span>
+                  <span class="ml-auto shrink-0 rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none">
+                    {{ hoveredEntry.type }}
                   </span>
-                </CommandItem>
-              </CommandGroup>
-            </CommandList>
-            <div
-              v-if="hoveredEntry"
-              class="border-t border-zinc-200 px-3 py-2 group-data-[side=top]/popover:border-t-0 group-data-[side=top]/popover:border-b"
-            >
-              <div class="flex items-center gap-2">
-                <span class="text-xs font-medium text-zinc-700">{{ hoveredEntry.label }}</span>
-                <span class="ml-auto shrink-0 rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none">
-                  {{ hoveredEntry.type }}
-                </span>
+                </div>
+                <Markdown
+                  v-if="hoveredDescription"
+                  :source="hoveredDescription"
+                  class="prose prose-zinc prose-sm mt-1 text-xs"
+                />
               </div>
-              <Markdown
-                v-if="hoveredDescription"
-                :source="hoveredDescription"
-                class="prose prose-zinc prose-sm mt-1 text-xs"
-              />
-            </div>
-          </Command>
-        </PopoverContent>
-      </Popover>
-      <span
-        v-if="resultTypeLabel"
-        class="rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none"
-      >
-        {{ resultTypeLabel }}
-      </span>
-      <slot name="trailing" />
-    </InputGroupAddon>
-  </InputGroup>
+            </Command>
+          </PopoverContent>
+        </Popover>
+        <span
+          v-if="resultTypeLabel"
+          class="rounded bg-purple-100 px-1.5 py-0.5 font-mono text-[10px] leading-none text-purple-700 select-none"
+        >
+          {{ resultTypeLabel }}
+        </span>
+        <slot name="trailing" />
+      </InputGroupAddon>
+    </InputGroup>
+    <p
+      v-if="validationError"
+      class="text-xs text-red-500"
+    >
+      {{ validationError }}
+    </p>
+  </div>
 </template>

package/dist/runtime/components/ui/expression-editor/ExpressionEditor.vue.d.ts

@@ -12,12 +12,13 @@ type __VLS_Props = {
     placeholder?: string;
     resultType?: string | string[];
     extraVars?: Record<string, VarSpec>;
+    unlistedVarsAreDyn?: boolean;
 };
-declare var __VLS_14: {}, __VLS_130: {};
+declare var __VLS_13: {}, __VLS_129: {};
 type __VLS_Slots = {} & {
-    leading?: (props: typeof __VLS_14) => any;
+    leading?: (props: typeof __VLS_13) => any;
 } & {
-    trailing?: (props: typeof __VLS_130) => any;
+    trailing?: (props: typeof __VLS_129) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     "update:modelValue": (payload: string) => any;

package/dist/runtime/share/expression.d.ts

@@ -15,6 +15,29 @@ export type ResultType = string | string[] | ((type: string) => boolean);
  * type-checker infers as `optional<HttpRequest>`.
  */
 export declare const HttpRequestResult: ResultType;
+/**
+ * Type-check `expression` against `env` and, if `resultType` is given, verify the
+ * inferred type satisfies it. Returns a Chinese error message, or `null` when the
+ * expression is valid. This is the single chokepoint both the schema validator
+ * (`Expression`'s filter) and the live `ExpressionEditor` call, so an inline
+ * verdict can never disagree with the save-time decode.
+ */
+export declare function evaluateExpression(env: Environment, expression: string, resultType?: ResultType): string | null;
+/**
+ * Build a checking `Environment` from a flat list of `{ name, type }` variable
+ * specs — the projection an `ExpressionEditor` already holds via its injected CEL
+ * context plus `extraVars`. Functions/operators come free from the cloned
+ * `globalRegistry`; only variables are host-scoped, so this is all the editor
+ * needs to reproduce the schema's validation env. `__scopes__` is registered
+ * canonically here (and skipped from `vars`) exactly as `Expression` does, so
+ * cross-layer addressing type-checks in the editor too.
+ */
+export declare function buildCheckEnvironment(vars: Iterable<{
+    name: string;
+    type: string;
+}>, options?: {
+    unlistedVariablesAreDyn?: boolean;
+}): Environment;
 export declare function Expression(options: {
     configure: (env: Environment) => void;
     resultType?: ResultType;

package/dist/runtime/share/expression.js

@@ -3,9 +3,17 @@ import { Environment } from "../vendor/cel-js/lib/index.js";
 import { CelError } from "../vendor/cel-js/lib/errors.js";
 import { Locale } from "./locale.js";
 export const HttpRequestResult = (t) => t === "HttpRequest" || t === "optional<HttpRequest>" || t === "optional<dyn>" || t === "dyn";
+function matchesScalarType(actual, expected) {
+  if (expected === "dyn" || actual === "dyn") return true;
+  if (actual === expected) return true;
+  if (actual.startsWith(`${expected}<`)) return true;
+  if (actual === `optional<${expected}>` || actual === "optional<dyn>") return true;
+  if (actual.startsWith(`optional<${expected}<`)) return true;
+  return false;
+}
 function matchesResultType(actual, expected) {
-  if (typeof expected === "string") return expected === "dyn" || actual === expected;
-  if (Array.isArray(expected)) return expected.includes("dyn") || expected.includes(actual);
+  if (typeof expected === "string") return matchesScalarType(actual, expected);
+  if (Array.isArray(expected)) return expected.some((e) => matchesScalarType(actual, e));
   return expected(actual);
 }
 function formatExpectedType(expected) {
@@ -19,6 +27,32 @@ function registerScopeAddressVar(env) {
     description: "\u6309 UUID \u5BFB\u5740\u88AB\u906E\u853D\u7684\u7956\u5148\u4F5C\u7528\u57DF"
   });
 }
+export function evaluateExpression(env, expression, resultType) {
+  const result = env.check(expression);
+  if (Either.isLeft(result)) {
+    const error = result.left;
+    const summary = error instanceof CelError ? error.summary : String(error);
+    return `\u8868\u8FBE\u5F0F\u65E0\u6548\uFF1A${summary}`;
+  }
+  if (resultType) {
+    const actualType = result.right;
+    if (!matchesResultType(actualType, resultType)) {
+      return `\u8868\u8FBE\u5F0F\u8FD4\u56DE\u7C7B\u578B\u4E0D\u5339\u914D\uFF0C\u671F\u671B ${formatExpectedType(resultType)}\uFF0C\u5B9E\u9645\u4E3A ${actualType}`;
+    }
+  }
+  return null;
+}
+export function buildCheckEnvironment(vars, options) {
+  const env = new Environment({
+    unlistedVariablesAreDyn: options?.unlistedVariablesAreDyn ?? false
+  });
+  registerScopeAddressVar(env);
+  for (const { name, type } of vars) {
+    if (name === "__scopes__") continue;
+    env.registerVariable(name, type);
+  }
+  return env;
+}
 function buildDescription(baseline, env, resultType) {
   const defs = env.getDefinitions();
   const baselineVarNames = new Set(baseline.variables.map((v) => v.name));
@@ -52,21 +86,7 @@ export function Expression(options) {
   const description = buildDescription(baseline, env, options.resultType);
   return Schema.String.pipe(
     Schema.filter(
-      (expression) => {
-        const result = env.check(expression);
-        if (Either.isLeft(result)) {
-          const error = result.left;
-          const summary = error instanceof CelError ? error.summary : String(error);
-          return `\u8868\u8FBE\u5F0F\u65E0\u6548\uFF1A${summary}`;
-        }
-        if (options.resultType) {
-          const actualType = result.right;
-          if (!matchesResultType(actualType, options.resultType)) {
-            return `\u8868\u8FBE\u5F0F\u8FD4\u56DE\u7C7B\u578B\u4E0D\u5339\u914D\uFF0C\u671F\u671B ${formatExpectedType(options.resultType)}\uFF0C\u5B9E\u9645\u4E3A ${actualType}`;
-          }
-        }
-        return true;
-      },
+      (expression) => evaluateExpression(env, expression, options.resultType) ?? true,
       {
         title: "CEL Expression",
         description

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.7.8",
   "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};