@shwfed/config 1.1.4 → 2.0.0

package/dist/runtime/utils/markdown-tooltip.js

@@ -1,55 +0,0 @@
-const OPEN = 123;
-const CLOSE = 125;
-const BACKSLASH = 92;
-const TRIGGER_CLASS = "decoration-dashed underline decoration-(--primary) underline-offset-4 cursor-help";
-function readSegment(src, start, max) {
-  if (start >= max || src.charCodeAt(start) !== OPEN) return null;
-  let pos = start + 1;
-  let out = "";
-  while (pos < max) {
-    const code = src.charCodeAt(pos);
-    if (code === BACKSLASH && pos + 1 < max) {
-      const next = src.charCodeAt(pos + 1);
-      if (next === OPEN || next === CLOSE || next === BACKSLASH) {
-        out += src[pos + 1];
-        pos += 2;
-        continue;
-      }
-      out += src[pos];
-      pos += 1;
-      continue;
-    }
-    if (code === OPEN) return null;
-    if (code === CLOSE) return { end: pos + 1, value: out };
-    out += src[pos];
-    pos += 1;
-  }
-  return null;
-}
-function tooltipRule(state, silent) {
-  const start = state.pos;
-  if (state.src.charCodeAt(start) !== OPEN) return false;
-  const trigger = readSegment(state.src, start, state.posMax);
-  if (!trigger) return false;
-  const content = readSegment(state.src, trigger.end, state.posMax);
-  if (!content) return false;
-  if (!silent) {
-    const token = state.push("tooltip", "", 0);
-    token.markup = "{}{}";
-    token.meta = { trigger: trigger.value, content: content.value };
-  }
-  state.pos = content.end;
-  return true;
-}
-export default function tooltipPlugin(md) {
-  md.inline.ruler.before("emphasis", "tooltip", tooltipRule);
-  md.renderer.rules.tooltip = (tokens, idx) => {
-    const token = tokens[idx];
-    const meta = token?.meta;
-    if (!meta) return "";
-    const trigger = md.renderInline(meta.trigger);
-    const title = md.utils.escapeHtml(meta.content);
-    return `<span class="${TRIGGER_CLASS}" title="${title}">${trigger}</span>`;
-  };
-}
-export { TRIGGER_CLASS };

package/dist/runtime/utils/markdown.d.ts

@@ -1,5 +0,0 @@
-import MarkdownIt from 'markdown-it';
-export declare const md: MarkdownIt;
-export declare function renderMarkdown(source: string, options?: {
-    block?: boolean;
-}): string;

package/dist/runtime/utils/markdown.js

@@ -1,6 +0,0 @@
-import MarkdownIt from "markdown-it";
-import tooltipPlugin from "./markdown-tooltip.js";
-export const md = new MarkdownIt({ html: true, linkify: false, breaks: true }).use(tooltipPlugin);
-export function renderMarkdown(source, options) {
-  return options?.block ? md.render(source) : md.renderInline(source);
-}

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

@@ -1,74 +0,0 @@
-# Vendored cel-js
-
-Vendored from `@marcbachmann/cel-js` — a JavaScript implementation of Google's Common Expression Language (CEL).
-
-See `VENDORED` for commit hash and date.
-
-When modifying this library, keep both `CLAUDE.md` and `PROMPT.md` in sync with your changes. `CLAUDE.md` is the developer reference for future agents working on the code; `PROMPT.md` is the user-facing guide for agents writing CEL expressions.
-
-## Key Modifications
-
-`int` and `uint` types have been removed in favor of a unified `number` type backed by `Decimal` (arbitrary-precision arithmetic via BigInt). All numeric literals, arithmetic results, and size/index returns are `Decimal` instances. The `int()`, `uint()`, and `double()` conversion functions still exist as aliases but all return `number`.
-
-`google.protobuf.Timestamp` and `google.protobuf.Duration` have been removed. Replaced with a `Date` type backed by `TZDate` from `@date-fns/tz`, constructed via `date(string)`. Date manipulation uses date-fns functions (`startOf`, `endOf`, `offset`, `set`, `format`).
-
-`evaluate` now returns `Effect<T, ParseError | EvaluationError | TypeError>` instead of a plain value. The entire evaluation pipeline is Effect-based — every AST node's `evaluate` function returns an Effect, and sub-expressions are composed via `Effect.gen` / `yield*`. Promise-based async handling has been removed. User-registered functions may return `Effect` values, which are automatically flatMapped into the evaluation pipeline. Import `Effect` from `effect` and use `Effect.runSync` or `Effect.runPromise` to execute the returned Effect.
-
-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).
-
-## Architecture
-
-```
-lib/
-├── index.ts          — Public exports
-├── parser.ts         — Lexer + recursive descent parser
-├── evaluator.ts      — Expression evaluation engine + Environment class
-├── type-checker.ts   — Static type analysis
-├── registry.ts       — Type system, operator/function registration
-├── 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
-├── decimal.ts        — Decimal class (arbitrary precision)
-├── optional.ts       — Optional type support (uses Effect Option)
-├── serialize.ts      — AST back to CEL string
-├── errors.ts         — ParseError, TypeError, EvaluationError
-├── globals.ts        — Shared utilities
-├── types.ts          — Type definitions
-└── options.ts        — Configuration management
-```
-
-## Public API
-
-```js
-import { Environment, ParseError, TypeError, EvaluationError } from './lib/index.js'
-```
-
-- `new Environment(options?)` — Create a configured environment
-  - `.check(expr)` — Returns `Either<string, ParseError | TypeError>` (success = type name string)
-  - `.evaluate<T>(expr, ctx?)` — Returns `Effect<T, ParseError | TypeError | EvaluationError>`
-  - `.registerVariable(name, type, options?)`
-  - `.registerConstant(name, type, value)`
-  - `.registerFunction(signature, handler, options?)`
-  - `.registerOperator(signature, handler)`
-  - `.registerType(typename, definition)`
-  - `.clone(options?)` — Copy with overrides
-
-Internal-only (not re-exported from `index.js`): `parse`, standalone `evaluate`/`check`, `serialize`, `Decimal`, `CelError`.
-
-## Type System
-
-Primitives: `string`, `bool`, `number`, `bytes`, `null_type`, `type`
-Composites: `list<T>`, `map<K, V>`, `optional<T>`, `dyn`, `message`
-Custom: `Date` (backed by `TZDate` from `@date-fns/tz`)
-
-## Function Signature Format
-
-```
-name(argType1, argType2): returnType     — global function
-Type.method(argTypes): returnType        — method on type
-```
-
-Handler receives `(arg1, arg2, ..., ast, evaluator, context)`. Macros receive AST nodes instead of evaluated values.

package/dist/runtime/vendor/cel-js/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Marc Bachmann
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

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

@@ -1,319 +0,0 @@
-# Writing CEL Expressions
-
-You are writing expressions in CEL (Common Expression Language). CEL is a small, safe expression language designed for evaluating single expressions — it is NOT a general-purpose programming language. There are no statements, assignments, loops, or function definitions. Every CEL program is a single expression that evaluates to a value.
-
-## Types
-
-CEL has these types:
-
-| Type | Examples | Notes |
-|------|----------|-------|
-| `number` | `42`, `3.14`, `0xFF` | All numbers are arbitrary-precision decimals. There is no `int`, `uint`, or `float` distinction — just `number`. `0.1 + 0.2 == 0.3` is `true`. |
-| `string` | `"hello"`, `'world'` | Single or double quotes. Triple-quoted for multiline: `"""text"""`. Raw strings: `r"no\escapes"`. |
-| `bool` | `true`, `false` | |
-| `bytes` | `b"data"`, `b'\xff'` | Binary data. |
-| `null` | `null` | |
-| `list` | `[1, 2, 3]` | Ordered collection. |
-| `map` | `{"key": "value"}` | Key-value pairs. |
-| `Date` | `date("2023-01-15")` | Backed by TZDate. Supports any parseable date string. |
-
-## Operators
-
-### Arithmetic (number only)
-```cel
-1 + 2          // 3
-10 - 3         // 7
-4 * 5          // 20
-10 / 3         // 3.333...
-10 % 3         // 1
--x             // negation
-```
-
-### Comparison
-```cel
-a == b         // equality (works on all types, deep comparison for lists/maps)
-a != b         // inequality
-a < b          // less than
-a <= b         // less or equal
-a > b          // greater than
-a >= b         // greater or equal
-```
-
-### Logical
-```cel
-a && b         // AND (short-circuits)
-a || b         // OR (short-circuits)
-!a             // NOT
-```
-
-### Ternary
-```cel
-condition ? value_if_true : value_if_false
-```
-
-### Membership
-```cel
-"a" in ["a", "b", "c"]       // true — element in list
-"key" in {"key": "value"}    // true — key in map
-```
-
-### String concatenation
-```cel
-"hello" + " " + "world"    // "hello world"
-```
-
-### List concatenation
-```cel
-[1, 2] + [3, 4]            // [1, 2, 3, 4]
-```
-
-### Field access
-```cel
-obj.field                   // access field on map/object
-obj["field"]                // bracket access (equivalent)
-obj.?field                  // optional field access (returns optional)
-obj[?0]                     // optional index access (returns optional)
-```
-
-## Built-in Functions
-
-### Type conversions
-```cel
-number("42")               // parse string to number
-number(true)               // 1 (false gives 0)
-string(42)                 // "42"
-string(true)               // "true"
-bool("true")               // true (also accepts "t", "1", "TRUE", "True")
-bool("false")              // false (also accepts "f", "0", "FALSE", "False")
-bytes("text")              // UTF-8 encode to bytes
-int(3.7)                   // 3 (truncates to integer)
-double("3.14")             // alias for number()
-type(x)                    // returns the type of x
-dyn(x)                     // identity, marks as dynamic type
-```
-
-### Size
-```cel
-size("hello")              // 5 (Unicode-aware character count)
-size([1, 2, 3])            // 3
-size({"a": 1})             // 1
-size(b"data")              // 4
-// Also available as method:
-"hello".size()             // 5
-[1, 2].size()              // 2
-```
-
-### List aggregations
-```cel
-[1, 2, 3].sum()                       // 6
-[1.5, 2.5].sum()                      // 4
-items.map(i, i.price).sum()           // total of mapped prices
-```
-Receiver must be statically typed `list<number>`. Works on number literals and `.map(...)` results; an unlisted variable typed as `dyn` will not match — wrap or type it first.
-
-### String methods
-```cel
-"hello".contains("ell")              // true
-"hello".startsWith("hel")            // true
-"hello".endsWith("llo")              // true
-"HELLO".lowerAscii()                 // "hello"
-"hello".upperAscii()                 // "HELLO"
-"  hi  ".trim()                      // "hi"
-"hello".substring(1)                 // "ello"
-"hello".substring(1, 3)              // "el"
-"hello".indexOf("l")                 // 2
-"hello".lastIndexOf("l")             // 3
-"hello".matches("[a-z]+")            // true (regex)
-"a,b,c".split(",")                   // ["a", "b", "c"]
-"a,b,c".split(",", 2)               // ["a", "b,c"]
-["a", "b"].join()                    // "ab"
-["a", "b"].join(", ")               // "a, b"
-```
-
-### Bytes methods
-```cel
-b"hello".string()                    // "hello" (UTF-8 decode)
-b"\xff".hex()                        // "ff"
-b"data".base64()                     // "ZGF0YQ=="
-b'{"a":1}'.json()                    // {"a": 1}
-b"hello".at(0)                       // 104
-size(b"hello")                       // 5
-```
-
-### Dates
-```cel
-date("2023-06-15")                   // create a Date
-date("2023-06-15T10:30:00Z")        // with time component
-
-// Comparisons:
-date("2023-01-01") < date("2024-01-01")   // true
-date("2023-01-01") == date("2023-01-01")  // true
-
-// Start/end of period:
-d.startOf("day")                     // start of day
-d.startOf("week")                    // start of week
-d.startOf("month")                   // start of month
-d.startOf("year")                    // start of year
-d.endOf("month")                     // end of month
-
-// Offset (positive or negative):
-d.offset(3, "days")                  // 3 days later
-d.offset(-1, "month")               // 1 month earlier
-d.offset(2, "weeks")                // 2 weeks later
-d.offset(1, "year")                 // 1 year later
-
-// Set specific fields:
-d.set("day", 15)                     // set day of month to 15
-d.set("month", 6)                    // set to June (1-based)
-d.set("year", 2025)                  // set year to 2025
-
-// Format:
-d.format("yyyy-MM-dd")              // "2023-06-15"
-d.format("MMMM d, yyyy")           // "June 15, 2023"
-```
-
-## HTTP
-
-Build HTTP requests using the `http` builder. CEL expressions only *describe* a request — the host dispatches it. There is no way to send a request or read a response from CEL.
-
-### Creating requests
-```cel
-http.get("/api/users")           // GET request
-http.post("/api/users")          // POST request
-http.put("/api/users/1")         // PUT request
-http.patch("/api/users/1")       // PATCH request
-http.delete("/api/users/1")      // DELETE request
-```
-
-### Builder methods (chainable)
-```cel
-// Add headers:
-http.get("/api/users")
-  .header("Authorization", "Bearer token")
-  .header("Accept", "application/json")
-
-// Add query parameters:
-http.get("/api/users")
-  .query("page", "1")
-  .query("limit", "10")
-
-// Splat a record (e.g. a form) into query parameters.
-// null, undefined and "" values are skipped; arrays append one entry per item;
-// nested objects throw.
-http.get("/api/users")
-  .query(form)
-  .query("page", string(pageIndex))
-
-// Set request body (auto-serializes to JSON):
-http.post("/api/users")
-  .body({"name": "Alice", "email": "alice@example.com"})
-
-// Full example — the expression returns an HttpRequest; the host sends it:
-http.post("/api/users")
-  .header("Authorization", "Bearer " + token)
-  .body({"name": "Alice"})
-```
-
-## Macros
-
-Macros are special forms — they look like method calls but have special evaluation semantics.
-
-### map — Transform each element
-```cel
-[1, 2, 3].map(x, x * 2)                    // [2, 4, 6]
-[1, 2, 3, 4].map(x, x > 2, x * 10)         // [30, 40] (filter then transform)
-```
-
-### filter — Keep elements matching predicate
-```cel
-[1, 2, 3, 4, 5].filter(x, x > 3)           // [4, 5]
-```
-
-### all — True if ALL elements match
-```cel
-[1, 2, 3].all(x, x > 0)                    // true
-[1, -1, 3].all(x, x > 0)                   // false (short-circuits)
-```
-
-### exists — True if ANY element matches
-```cel
-[1, 2, 3].exists(x, x > 2)                 // true
-[1, 2, 3].exists(x, x > 5)                 // false
-```
-
-### exists_one — True if EXACTLY one element matches
-```cel
-[1, 2, 3].exists_one(x, x > 2)             // true (only 3)
-[1, 2, 3].exists_one(x, x > 1)             // false (2 and 3 both match)
-```
-
-### find — Return first element matching predicate as optional
-```cel
-[1, 2, 3].find(x, x > 1)                   // optional.of(2)
-[1, 2, 3].find(x, x > 5)                   // optional.none()
-[1, 2, 3].find(x, x > 1).orValue(0)        // 2
-[1, 2, 3].find(x, x > 5).orValue(0)        // 0
-```
-
-### has — Check if a field exists
-```cel
-has(obj.field)                               // true if field exists
-has(obj.nested.deep)                         // safe nested check
-```
-
-### cel.bind — Bind a variable to avoid repeated computation
-```cel
-cel.bind(total, price * quantity, total > 100 && total < 1000)
-```
-
-## Common Patterns
-
-### Conditional logic
-```cel
-age >= 18 ? "adult" : "minor"
-```
-
-### Null-safe access
-```cel
-has(user.address) && user.address.city == "NYC"
-```
-
-### List searching
-```cel
-items.exists(item, item.status == "active")
-items.filter(item, item.price > 100).size() > 0
-```
-
-### String matching
-```cel
-email.matches("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")
-```
-
-### Numeric comparisons
-```cel
-price * quantity >= 100.0
-values.all(v, v >= 0 && v <= 100)
-```
-
-### Map membership
-```cel
-"admin" in user.roles
-```
-
-## Things You Cannot Do
-
-- **No variables or assignments** — `x = 5` is invalid. CEL is a single expression.
-- **No loops** — Use `map`, `filter`, `all`, `exists` instead.
-- **No function definitions** — You can only call built-in or registered functions.
-- **No statements** — No `if`/`else` blocks, `for`, `while`, `return`. Use the ternary `? :` for conditionals.
-- **No mutation** — You cannot modify values. Every operation produces a new value.
-- **No `int` or `uint` type** — All numbers are just `number`. Write `42`, not `int(42)`. You do not need to worry about integer vs float precision — `0.1 + 0.2 == 0.3` works correctly.
-- **No imports or modules** — Everything available is already in scope.
-
-## Error Cases to Avoid
-
-- **Division/modulo by zero** — `10 / 0` and `10 % 0` throw errors.
-- **Index out of bounds** — `[1,2,3][5]` throws. Use `has()` or check `size()` first.
-- **Missing fields** — `obj.nonexistent` throws. Use `has(obj.nonexistent)` to check first.
-- **Type mismatches** — `1 + "2"` throws. Types must match for operators.
-- **Invalid regex** — `"x".matches("[invalid")` throws. Ensure regex is valid.

package/dist/runtime/vendor/cel-js/VENDORED

@@ -1,3 +0,0 @@
-Source: https://github.com/marcbachmann/cel-js
-Commit: d600a93110f1bfc63833e39a84de3086b382879b
-Date: 2026-03-31

package/dist/runtime/vendor/cel-js/__tests__/helpers.d.ts

@@ -1,8 +0,0 @@
-import { Environment } from '../lib/evaluator.js.js';
-import { Decimal } from '../lib/decimal.js.js';
-export declare class TestEnvironment extends Environment {
-    evalSync(expr: string, ctx?: Record<string, unknown>): unknown;
-}
-export declare function evalSync(expr: string, ctx?: Record<string, unknown>): unknown;
-export declare function expectDecimal(result: unknown, expected: number | bigint | string | Decimal): void;
-export declare const env: TestEnvironment;

package/dist/runtime/vendor/cel-js/__tests__/helpers.js

@@ -1,18 +0,0 @@
-import { Effect } from "effect";
-import { expect } from "vitest";
-import { Environment, evaluate } from "../lib/evaluator.js";
-import { Decimal } from "../lib/decimal.js";
-export class TestEnvironment extends Environment {
-  evalSync(expr, ctx) {
-    return Effect.runSync(this.evaluate(expr, ctx));
-  }
-}
-export function evalSync(expr, ctx) {
-  return Effect.runSync(evaluate(expr, ctx));
-}
-export function expectDecimal(result, expected) {
-  expect(result).toBeInstanceOf(Decimal);
-  const exp = Decimal.from(expected);
-  expect(result.eq(exp)).toBe(true);
-}
-export const env = new TestEnvironment({ unlistedVariablesAreDyn: true });

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

@@ -1,31 +0,0 @@
-type DecimalInput = number | bigint | string | Decimal;
-export declare class Decimal {
-    readonly sign: 1 | -1;
-    readonly coeff: bigint;
-    readonly exp: number;
-    constructor(sign: 1 | -1, coeff: bigint, exp: number);
-    static from(v: DecimalInput): Decimal;
-    isZero(): boolean;
-    isInteger(): boolean;
-    neg(): Decimal;
-    abs(): Decimal;
-    add(other: DecimalInput): Decimal;
-    sub(other: DecimalInput): Decimal;
-    mul(other: DecimalInput): Decimal;
-    div(other: DecimalInput, precision?: number): Decimal;
-    mod(other: DecimalInput): Decimal;
-    _digits(): number;
-    cmp(other: DecimalInput): -1 | 0 | 1;
-    eq(other: DecimalInput): boolean;
-    lt(other: DecimalInput): boolean;
-    lte(other: DecimalInput): boolean;
-    gt(other: DecimalInput): boolean;
-    gte(other: DecimalInput): boolean;
-    toNumber(): number;
-    valueOf(): number;
-    toString(): string;
-    toJSON(): number;
-    get [Symbol.toStringTag](): string;
-    [Symbol.toPrimitive](hint: string): string | number;
-}
-export {};