sigmx 0.1.0

package/dist/core/types.d.ts

@@ -0,0 +1,101 @@
+import type { Compiler } from './expr.js';
+import type { Store } from './store.js';
+import type { CaseStyle } from '../utils/text.js';
+export type El = HTMLElement | SVGElement | MathMLElement;
+export type Mods = Map<string, string[]>;
+export interface Runtime {
+    /** Attribute prefixes being scanned; the first is primary. */
+    readonly prefixes: readonly string[];
+    /** Full attribute name under the primary prefix: attr('on') → 'data-on'. */
+    attr(name: string): string;
+    readonly store: Store;
+    readonly compiler: Compiler;
+    /** Dispatch a `sigmx-<type>` CustomEvent on `document`. */
+    emit(type: string, detail?: unknown): void;
+    /** Call a registered action by name. */
+    call(name: string, ctx: ActionCtx, args: any[]): any;
+    readonly attributes: Record<string, AttributePlugin>;
+    readonly actions: Record<string, ActionPlugin>;
+    readonly handlers: Record<string, HandlerPlugin>;
+}
+export interface Ctx {
+    el: El;
+    /** Plugin name, e.g. 'on'. */
+    plugin: string;
+    /** Full attribute name as written, e.g. 'data-on:click__debounce.300ms'. */
+    attr: string;
+    /** The `:key` part, if any. */
+    key: string | undefined;
+    /** Attribute value (the expression source). */
+    value: string;
+    mods: Mods;
+    /** The key recased per `__case.<style>`, defaulting to `style`. */
+    cased(style?: CaseStyle): string;
+    /** Evaluate the attribute expression. `evt` and any `args` are exposed to it by name. */
+    evaluate(evt?: Event, ...args: any[]): any;
+    /** Reactive effect disposed with the attribute. Errors are reported, not thrown. */
+    effect(fn: () => void): void;
+    /** addEventListener with automatic removal on cleanup. */
+    listen(target: EventTarget, type: string, fn: (e: any) => void, options?: AddEventListenerOptions): void;
+    cleanup(fn: () => void): void;
+    error(message: string, extra?: Record<string, unknown>): Error;
+    store: Store;
+    runtime: Runtime;
+}
+export interface ActionCtx {
+    el: El;
+    evt?: Event;
+    store: Store;
+    runtime: Runtime;
+    error(message: string, extra?: Record<string, unknown>): Error;
+}
+export interface AttributePlugin {
+    type: 'attribute';
+    name: string;
+    key?: 'required' | 'forbidden';
+    value?: 'required' | 'forbidden';
+    /** Whether the expression yields a value (default) or is a statement body. */
+    returns?: boolean;
+    /** Extra parameter names the expression can reference, in the order passed to `evaluate`. */
+    args?: string[];
+    mount(ctx: Ctx): void | (() => void);
+}
+export interface ActionPlugin {
+    type: 'action';
+    name: string;
+    call(ctx: ActionCtx, ...args: any[]): any;
+}
+/** Handles a named server event (for example a streamed patch). */
+export interface HandlerPlugin {
+    type: 'handler';
+    name: string;
+    handle(runtime: Runtime, data: Record<string, string>): void;
+}
+export type Plugin = AttributePlugin | ActionPlugin | HandlerPlugin;
+export interface SigmxOptions {
+    plugins?: Plugin[];
+    /** Attribute prefix or prefixes to scan. Default 'data-'. */
+    prefix?: string | string[];
+    compile?: Compiler;
+    /** Share a store between instances. */
+    store?: Store;
+    /** Called for any plugin or expression error. Default: console.error. */
+    onError?: (error: unknown, info: {
+        plugin?: string;
+        el?: Element;
+        attr?: string;
+    }) => void;
+    /** Scan `document.documentElement` on creation (after DOM ready). Default true. */
+    autoStart?: boolean;
+}
+export interface Sigmx {
+    runtime: Runtime;
+    store: Store;
+    /** Root namespace proxy for use from JavaScript: `sigmx.$.count++`. */
+    $: any;
+    /** Mount plugins under `root` and observe it for changes. */
+    apply(root?: El | ShadowRoot, observe?: boolean): void;
+    /** Register more plugins; attribute plugins are applied to observed roots immediately. */
+    use(...plugins: Plugin[]): void;
+    destroy(): void;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=types.js.map

package/dist/core/types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/kernel/compile.d.ts

@@ -0,0 +1,16 @@
+import type { ExpressionCompiler } from './contracts.js';
+export type Compiler = (params: string[], body: string) => (...args: any[]) => any;
+/** Default compiler: `new Function`. Not usable under a strict CSP; see `cspCompiler`. */
+export declare const functionCompiler: Compiler;
+/** Replace `@name(` with `__a.name(` outside strings and comments. */
+export declare const rewriteActions: (src: string) => string;
+/** Split on top-level semicolons. */
+export declare const splitStatements: (src: string) => string[];
+/**
+ * Compile an expression to `(store, actions, ...params) => any`: the body runs inside
+ * `with (store.scope)`, so `$name` resolves through the store. With `returns`, the value of the
+ * last statement is returned, so `$a = 1; $a * 2` works. Compiled functions are cached by source.
+ */
+export declare const compile: (compiler: Compiler, src: string, params: string[], returns: boolean) => ((...args: any[]) => any);
+/** The default pipeline: compile at runtime inside `with (scope)` using `compiler` (`new Function` or CSP). */
+export declare const runtimeExpressions: (compiler: Compiler) => ExpressionCompiler;

package/dist/kernel/compile.js

@@ -0,0 +1,96 @@
+const functionCompiler = (params, body) => Function(...params, body);
+const cache = /* @__PURE__ */ new Map();
+const isIdent = (c) => /[A-Za-z0-9_$]/.test(c);
+const scan = (src, onCode) => {
+  let i = 0;
+  const n = src.length;
+  while (i < n) {
+    const c = src[i];
+    const next = src[i + 1];
+    if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      while (j < n && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+      onCode(src.slice(i, j + 1), i);
+      i = j + 1;
+    } else if (c === "/" && next === "/") {
+      const j = src.indexOf("\n", i);
+      i = j < 0 ? n : j;
+    } else if (c === "/" && next === "*") {
+      const j = src.indexOf("*/", i + 2);
+      i = j < 0 ? n : j + 2;
+    } else {
+      const skip = onCode(c, i);
+      i += skip || 1;
+    }
+  }
+};
+const rewriteActions = (src) => {
+  let out = "";
+  scan(src, (c, i) => {
+    if (c === "@") {
+      let j = i + 1;
+      while (j < src.length && isIdent(src[j])) j++;
+      let k = j;
+      while (k < src.length && /\s/.test(src[k])) k++;
+      if (j > i + 1 && src[k] === "(") {
+        out += `__a.${src.slice(i + 1, j)}(`;
+        return k + 1 - i;
+      }
+    }
+    out += c;
+  });
+  return out;
+};
+const splitStatements = (src) => {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  scan(src, (c, i) => {
+    if (c.length > 1) return;
+    if ("([{".includes(c)) depth++;
+    else if (")]}".includes(c)) depth--;
+    else if (c === ";" && !depth) {
+      parts.push(src.slice(start, i));
+      start = i + 1;
+    }
+  });
+  parts.push(src.slice(start));
+  return parts.filter((p) => p.trim());
+};
+const compile = (compiler, src, params, returns) => {
+  const key = `${+returns}|${params.join()}|${src}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const code = rewriteActions(src.trim());
+  const make = (body) => compiler(["$", "__a", ...params], `with($.scope){${body}
+}`);
+  let fn;
+  if (!returns) {
+    fn = make(code);
+  } else {
+    try {
+      fn = make(`return(${code}
+)`);
+    } catch {
+      const parts = splitStatements(code);
+      const last = parts.pop() ?? "";
+      try {
+        fn = make(`${parts.join(";")};return(${last}
+)`);
+      } catch {
+        fn = make(code);
+      }
+    }
+  }
+  cache.set(key, fn);
+  return fn;
+};
+const runtimeExpressions = (compiler) => (src, params, returns) => compile(compiler, src, params, returns);
+export {
+  compile,
+  functionCompiler,
+  rewriteActions,
+  runtimeExpressions,
+  splitStatements
+};
+//# sourceMappingURL=compile.js.map

package/dist/kernel/compile.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/compile.ts"],
+  "sourcesContent": ["// Expression compiler. Signals need no rewriting: the body runs inside `with (scope)`, where\n// `$count`, `$user.name` and `$` resolve through the store's scope proxy. Only `@action(` is\n// rewritten, into a call on the per-evaluation actions object.\n\nimport type { ExpressionCompiler } from './contracts.js'\n\nexport type Compiler = (params: string[], body: string) => (...args: any[]) => any\n\n/** Default compiler: `new Function`. Not usable under a strict CSP; see `cspCompiler`. */\nexport const functionCompiler: Compiler = (params, body) => Function(...params, body) as (...args: any[]) => any\n\nconst cache = new Map<string, (...args: any[]) => any>()\n\nconst isIdent = (c: string): boolean => /[A-Za-z0-9_$]/.test(c)\n\n/** Walk source text, skipping string, template and comment contents; `emit` receives code chars. */\nconst scan = (src: string, onCode: (c: string, i: number) => number | void): void => {\n  let i = 0\n  const n = src.length\n  while (i < n) {\n    const c = src[i]\n    const next = src[i + 1]\n    if (c === '\"' || c === \"'\" || c === '`') {\n      let j = i + 1\n      while (j < n && src[j] !== c) j += src[j] === '\\\\' ? 2 : 1\n      onCode(src.slice(i, j + 1), i)\n      i = j + 1\n    } else if (c === '/' && next === '/') {\n      const j = src.indexOf('\\n', i)\n      i = j < 0 ? n : j\n    } else if (c === '/' && next === '*') {\n      const j = src.indexOf('*/', i + 2)\n      i = j < 0 ? n : j + 2\n    } else {\n      const skip = onCode(c, i)\n      i += skip || 1\n    }\n  }\n}\n\n/** Replace `@name(` with `__a.name(` outside strings and comments. */\nexport const rewriteActions = (src: string): string => {\n  let out = ''\n  scan(src, (c, i) => {\n    if (c === '@') {\n      let j = i + 1\n      while (j < src.length && isIdent(src[j])) j++\n      let k = j\n      while (k < src.length && /\\s/.test(src[k])) k++\n      if (j > i + 1 && src[k] === '(') {\n        out += `__a.${src.slice(i + 1, j)}(`\n        return k + 1 - i\n      }\n    }\n    out += c\n  })\n  return out\n}\n\n/** Split on top-level semicolons. */\nexport const splitStatements = (src: string): string[] => {\n  const parts: string[] = []\n  let depth = 0\n  let start = 0\n  scan(src, (c, i) => {\n    if (c.length > 1) return\n    if ('([{'.includes(c)) depth++\n    else if (')]}'.includes(c)) depth--\n    else if (c === ';' && !depth) {\n      parts.push(src.slice(start, i))\n      start = i + 1\n    }\n  })\n  parts.push(src.slice(start))\n  return parts.filter((p) => p.trim())\n}\n\n/**\n * Compile an expression to `(store, actions, ...params) => any`: the body runs inside\n * `with (store.scope)`, so `$name` resolves through the store. With `returns`, the value of the\n * last statement is returned, so `$a = 1; $a * 2` works. Compiled functions are cached by source.\n */\nexport const compile = (\n  compiler: Compiler,\n  src: string,\n  params: string[],\n  returns: boolean,\n): ((...args: any[]) => any) => {\n  const key = `${+returns}|${params.join()}|${src}`\n  const hit = cache.get(key)\n  if (hit) return hit\n  const code = rewriteActions(src.trim())\n  const make = (body: string) => compiler(['$', '__a', ...params], `with($.scope){${body}\\n}`)\n  let fn: (...args: any[]) => any\n  if (!returns) {\n    fn = make(code)\n  } else {\n    try {\n      fn = make(`return(${code}\\n)`)\n    } catch {\n      const parts = splitStatements(code)\n      const last = parts.pop() ?? ''\n      try {\n        fn = make(`${parts.join(';')};return(${last}\\n)`)\n      } catch {\n        fn = make(code)\n      }\n    }\n  }\n  cache.set(key, fn)\n  return fn\n}\n\n/** The default pipeline: compile at runtime inside `with (scope)` using `compiler` (`new Function` or CSP). */\nexport const runtimeExpressions =\n  (compiler: Compiler): ExpressionCompiler =>\n  (src, params, returns) =>\n    compile(compiler, src, params, returns)\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/kernel/contracts.d.ts

@@ -0,0 +1,121 @@
+import type { Compiler } from './compile.js';
+import type { Store } from './state.js';
+import type { CaseStyle } from '../lib/casing.js';
+export type El = HTMLElement | SVGElement | MathMLElement;
+export type Mods = Map<string, string[]>;
+/** A compiled attribute expression. `store` is the instance store; `actions` resolves `@name(...)`. */
+export type Evaluator = (store: Store, actions: any, el: El, evt: Event | undefined, ...args: any[]) => any;
+/** Turns expression source into an evaluator. The runtime compiler and the precompiled table both implement this. */
+export type ExpressionCompiler = (src: string, params: string[], returns: boolean) => Evaluator;
+export interface Runtime {
+    /** Attribute prefixes being scanned; the first is primary. */
+    readonly prefixes: readonly string[];
+    /** Full attribute name under the primary prefix: attr('on') → 'data-on'. */
+    attr(name: string): string;
+    readonly store: Store;
+    /** The low-level function compiler (`new Function` or the CSP compiler), for plugins that build code. */
+    readonly compiler: Compiler;
+    /** Dispatch a `sigmx-<type>` CustomEvent on `document`. */
+    emit(type: string, detail?: unknown): void;
+    /** Call a registered action by name. */
+    call(name: string, ctx: ActionCtx, args: any[]): any;
+    /** Event-name prefixes accepted from servers; the first is what sigmx itself uses. */
+    readonly eventPrefixes: readonly string[];
+    /** Route a named server event (with any accepted prefix) to its handler. Returns false if none. */
+    handle(event: string, data: Record<string, string>): boolean;
+    readonly attributes: Record<string, AttributePlugin>;
+    readonly actions: Record<string, ActionPlugin>;
+    readonly handlers: Record<string, HandlerPlugin>;
+}
+export interface Ctx {
+    el: El;
+    /** Plugin name, e.g. 'on'. */
+    plugin: string;
+    /** Full attribute name as written, e.g. 'data-on:click__debounce.300ms'. */
+    attr: string;
+    /** The `:key` part, if any. */
+    key: string | undefined;
+    /** Attribute value (the expression source). */
+    value: string;
+    mods: Mods;
+    /** The key recased per `__case.<style>`, defaulting to `style`. */
+    cased(style?: CaseStyle): string;
+    /** Evaluate the attribute expression. `evt` and any `args` are exposed to it by name. */
+    evaluate(evt?: Event, ...args: any[]): any;
+    /** Reactive effect disposed with the attribute. Errors are reported, not thrown. */
+    effect(fn: () => void): void;
+    /** addEventListener with automatic removal on cleanup. */
+    listen(target: EventTarget, type: string, fn: (e: any) => void, options?: AddEventListenerOptions): void;
+    cleanup(fn: () => void): void;
+    error(message: string, extra?: Record<string, unknown>): Error;
+    store: Store;
+    runtime: Runtime;
+}
+export interface ActionCtx {
+    el: El;
+    evt?: Event;
+    store: Store;
+    runtime: Runtime;
+    error(message: string, extra?: Record<string, unknown>): Error;
+    /** Run when the attribute that invoked the action is torn down. */
+    cleanup(fn: () => void): void;
+}
+export interface AttributePlugin {
+    type: 'attribute';
+    name: string;
+    key?: 'required' | 'forbidden';
+    value?: 'required' | 'forbidden';
+    /** Whether the expression yields a value (default) or is a statement body. */
+    returns?: boolean;
+    /** Extra parameter names the expression can reference, in the order passed to `evaluate`. */
+    args?: string[];
+    mount(ctx: Ctx): void | (() => void);
+}
+export interface ActionPlugin {
+    type: 'action';
+    name: string;
+    call(ctx: ActionCtx, ...args: any[]): any;
+}
+/** Handles a named server event (for example a streamed patch). */
+export interface HandlerPlugin {
+    type: 'handler';
+    name: string;
+    handle(runtime: Runtime, data: Record<string, string>): void;
+}
+export type Plugin = AttributePlugin | ActionPlugin | HandlerPlugin;
+export interface RuntimeOptions {
+    plugins?: Plugin[];
+    /** How attribute expressions become functions: `runtimeExpressions(compiler)` or `precompiled(table)`. */
+    expressions: ExpressionCompiler;
+    /** Low-level function compiler exposed to plugins (default `new Function`). */
+    compile?: Compiler;
+    /** Attribute prefix or prefixes to scan. Default 'data-'. */
+    prefix?: string | string[];
+    /** Server event-name prefixes to accept, add a second prefix while migrating from another library. Default 'sigmx-'. */
+    eventPrefix?: string | string[];
+    /** Share a store between instances. */
+    store?: Store;
+    /** Called for any plugin or expression error. Default: console.error. */
+    onError?: (error: unknown, info: {
+        plugin?: string;
+        el?: Element;
+        attr?: string;
+    }) => void;
+    /** Scan `document.documentElement` on creation (after DOM ready). Default true. */
+    autoStart?: boolean;
+}
+/** `createSigmx` options: `expressions` is optional and defaults to the runtime compiler. */
+export interface SigmxOptions extends Omit<RuntimeOptions, 'expressions'> {
+    expressions?: ExpressionCompiler;
+}
+export interface Sigmx {
+    runtime: Runtime;
+    store: Store;
+    /** Root namespace proxy for use from JavaScript: `sigmx.$.count++`. */
+    $: any;
+    /** Mount plugins under `root` and observe it for changes. */
+    apply(root?: El | ShadowRoot, observe?: boolean): void;
+    /** Register more plugins; attribute plugins are applied to observed roots immediately. */
+    use(...plugins: Plugin[]): void;
+    destroy(): void;
+}

package/dist/kernel/contracts.js

@@ -0,0 +1 @@
+//# sourceMappingURL=contracts.js.map

package/dist/kernel/contracts.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/kernel/index.d.ts

@@ -0,0 +1,20 @@
+export { createRuntime, parseAttr } from './runtime.js';
+export { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from './compile.js';
+export { expressionKey, precompiled } from './precompiled.js';
+export type { ExpressionTable } from './precompiled.js';
+export type { Compiler } from './compile.js';
+export { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from './reactive.js';
+export { createStore } from './state.js';
+export type { Patch, Store } from './state.js';
+export type * from './contracts.js';
+export { expand, isPlain, toPredicate } from '../lib/objects.js';
+export type { Filter } from '../lib/objects.js';
+export { camel, kebab, pascal, recase, snake } from '../lib/casing.js';
+export { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../lib/schedule.js';
+import type { ActionPlugin, AttributePlugin, HandlerPlugin, Sigmx, SigmxOptions } from './contracts.js';
+/** Create an instance. Expressions compile at runtime unless you pass `expressions` (see `precompiled`). */
+export declare const createSigmx: (options?: SigmxOptions) => Sigmx;
+/** Type a plugin definition. Pure: registration is `createSigmx({ plugins })` or `sigmx.use()`. */
+export declare const attribute: (p: Omit<AttributePlugin, "type">) => AttributePlugin;
+export declare const action: (p: Omit<ActionPlugin, "type">) => ActionPlugin;
+export declare const handler: (p: Omit<HandlerPlugin, "type">) => HandlerPlugin;

package/dist/kernel/index.js

@@ -0,0 +1,54 @@
+import { createRuntime, parseAttr } from "./runtime.js";
+import { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from "./compile.js";
+import { expressionKey, precompiled } from "./precompiled.js";
+import { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from "./reactive.js";
+import { createStore } from "./state.js";
+import { expand, isPlain, toPredicate } from "../lib/objects.js";
+import { camel, kebab, pascal, recase, snake } from "../lib/casing.js";
+import { debounce, delay, throttle, toMs, withTiming, withViewTransition } from "../lib/schedule.js";
+import { createRuntime as createRuntime2 } from "./runtime.js";
+import { functionCompiler as functionCompiler2, runtimeExpressions as runtimeExpressions2 } from "./compile.js";
+const createSigmx = (options = {}) => createRuntime2({ ...options, expressions: options.expressions ?? runtimeExpressions2(options.compile ?? functionCompiler2) });
+const attribute = (p) => ({ type: "attribute", ...p });
+const action = (p) => ({ type: "action", ...p });
+const handler = (p) => ({ type: "handler", ...p });
+export {
+  Computed,
+  Signal,
+  action,
+  attribute,
+  batch,
+  camel,
+  compile,
+  computed,
+  createRuntime,
+  createSigmx,
+  createStore,
+  debounce,
+  delay,
+  effect,
+  expand,
+  expressionKey,
+  flush,
+  functionCompiler,
+  handler,
+  isPlain,
+  kebab,
+  onSettled,
+  parseAttr,
+  pascal,
+  precompiled,
+  recase,
+  rewriteActions,
+  runtimeExpressions,
+  signal,
+  snake,
+  splitStatements,
+  throttle,
+  toMs,
+  toPredicate,
+  untracked,
+  withTiming,
+  withViewTransition
+};
+//# sourceMappingURL=index.js.map

package/dist/kernel/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/index.ts"],
+  "sourcesContent": ["export { createRuntime, parseAttr } from './runtime.js'\nexport { compile, functionCompiler, rewriteActions, runtimeExpressions, splitStatements } from './compile.js'\nexport { expressionKey, precompiled } from './precompiled.js'\nexport type { ExpressionTable } from './precompiled.js'\nexport type { Compiler } from './compile.js'\nexport { Computed, Signal, batch, computed, effect, flush, onSettled, signal, untracked } from './reactive.js'\nexport { createStore } from './state.js'\nexport type { Patch, Store } from './state.js'\nexport type * from './contracts.js'\nexport { expand, isPlain, toPredicate } from '../lib/objects.js'\nexport type { Filter } from '../lib/objects.js'\nexport { camel, kebab, pascal, recase, snake } from '../lib/casing.js'\nexport { debounce, delay, throttle, toMs, withTiming, withViewTransition } from '../lib/schedule.js'\n\nimport type { ActionPlugin, AttributePlugin, HandlerPlugin, Sigmx, SigmxOptions } from './contracts.js'\nimport { createRuntime } from './runtime.js'\nimport { functionCompiler, runtimeExpressions } from './compile.js'\n\n/** Create an instance. Expressions compile at runtime unless you pass `expressions` (see `precompiled`). */\nexport const createSigmx = (options: SigmxOptions = {}): Sigmx =>\n  createRuntime({ ...options, expressions: options.expressions ?? runtimeExpressions(options.compile ?? functionCompiler) })\n\n/** Type a plugin definition. Pure: registration is `createSigmx({ plugins })` or `sigmx.use()`. */\nexport const attribute = (p: Omit<AttributePlugin, 'type'>): AttributePlugin => ({ type: 'attribute', ...p })\nexport const action = (p: Omit<ActionPlugin, 'type'>): ActionPlugin => ({ type: 'action', ...p })\nexport const handler = (p: Omit<HandlerPlugin, 'type'>): HandlerPlugin => ({ type: 'handler', ...p })\n"],
+  "mappings": "AAAA,SAAS,eAAe,iBAAiB;AACzC,SAAS,SAAS,kBAAkB,gBAAgB,oBAAoB,uBAAuB;AAC/F,SAAS,eAAe,mBAAmB;AAG3C,SAAS,UAAU,QAAQ,OAAO,UAAU,QAAQ,OAAO,WAAW,QAAQ,iBAAiB;AAC/F,SAAS,mBAAmB;AAG5B,SAAS,QAAQ,SAAS,mBAAmB;AAE7C,SAAS,OAAO,OAAO,QAAQ,QAAQ,aAAa;AACpD,SAAS,UAAU,OAAO,UAAU,MAAM,YAAY,0BAA0B;AAGhF,SAAS,iBAAAA,sBAAqB;AAC9B,SAAS,oBAAAC,mBAAkB,sBAAAC,2BAA0B;AAG9C,MAAM,cAAc,CAAC,UAAwB,CAAC,MACnDF,eAAc,EAAE,GAAG,SAAS,aAAa,QAAQ,eAAeE,oBAAmB,QAAQ,WAAWD,iBAAgB,EAAE,CAAC;AAGpH,MAAM,YAAY,CAAC,OAAuD,EAAE,MAAM,aAAa,GAAG,EAAE;AACpG,MAAM,SAAS,CAAC,OAAiD,EAAE,MAAM,UAAU,GAAG,EAAE;AACxF,MAAM,UAAU,CAAC,OAAmD,EAAE,MAAM,WAAW,GAAG,EAAE;",
+  "names": ["createRuntime", "functionCompiler", "runtimeExpressions"]
+}

package/dist/kernel/precompile.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Rewrite `$name` and `$a.b` into `$.name` / `$.a.b` so the expression runs in strict mode without
+ * `with`. Skips strings and comments, recurses into template-literal interpolations, and leaves
+ * `$` alone, `$[...]` alone, and `obj.$prop` alone.
+ */
+export declare const rewriteSignals: (src: string) => string;
+/** The strict-mode function body for one expression: same semantics as the runtime compiler. */
+export declare const compileBody: (src: string, returns: boolean) => string;
+export type Extracted = {
+    src: string;
+    params: string[];
+    returns: boolean;
+};
+/** JavaScript source for a module exporting `table`, from a list of extracted expressions. */
+export declare const generateTable: (items: Extracted[]) => string;
+export type PluginMeta = {
+    name: string;
+    returns?: boolean;
+    args?: string[];
+};
+/**
+ * Find directive attributes with literal values in template source. Values must be plain quoted
+ * strings; anything interpolated at render time is left to the runtime fallback.
+ */
+export declare const extractExpressions: (source: string, plugins: PluginMeta[], prefixes?: string[]) => Extracted[];

package/dist/kernel/precompile.js

@@ -0,0 +1,111 @@
+import { rewriteActions, splitStatements } from "./compile.js";
+import { expressionKey } from "./precompiled.js";
+const ident = /[A-Za-z0-9_$]/;
+const rewriteSignals = (src) => {
+  let out = "";
+  let i = 0;
+  const n = src.length;
+  const prevCode = () => {
+    for (let j = out.length - 1; j >= 0; j--) if (!/\s/.test(out[j])) return out[j];
+    return "";
+  };
+  while (i < n) {
+    const c = src[i];
+    const next = src[i + 1];
+    if (c === '"' || c === "'") {
+      let j = i + 1;
+      while (j < n && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+      out += src.slice(i, j + 1);
+      i = j + 1;
+    } else if (c === "`") {
+      out += c;
+      i++;
+      while (i < n && src[i] !== "`") {
+        if (src[i] === "\\") {
+          out += src.slice(i, i + 2);
+          i += 2;
+        } else if (src[i] === "$" && src[i + 1] === "{") {
+          let depth = 1;
+          let j = i + 2;
+          while (j < n && depth) {
+            if (src[j] === "{") depth++;
+            else if (src[j] === "}") depth--;
+            if (depth) j++;
+          }
+          out += "${" + rewriteSignals(src.slice(i + 2, j)) + "}";
+          i = j + 1;
+        } else out += src[i++];
+      }
+      out += "`";
+      i++;
+    } else if (c === "/" && next === "/") {
+      const j = src.indexOf("\n", i);
+      i = j < 0 ? n : j;
+    } else if (c === "/" && next === "*") {
+      const j = src.indexOf("*/", i + 2);
+      i = j < 0 ? n : j + 2;
+    } else if (c === "$" && next !== void 0 && ident.test(next) && next !== "$" && prevCode() !== "." && !ident.test(out[out.length - 1] ?? "")) {
+      let j = i + 1;
+      while (j < n && ident.test(src[j])) j++;
+      out += "$." + src.slice(i + 1, j);
+      i = j;
+    } else {
+      out += c;
+      i++;
+    }
+  }
+  return out;
+};
+const compileBody = (src, returns) => {
+  const code = rewriteSignals(rewriteActions(src.trim()));
+  if (!returns) return code;
+  const parts = splitStatements(code);
+  const last = parts.pop() ?? "";
+  return `${parts.length ? parts.join(";") + ";" : ""}return (${last}
+)`;
+};
+const generateTable = (items) => {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const { src, params, returns } of items) {
+    const key = expressionKey(src, params, returns);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    let body;
+    try {
+      body = compileBody(src, returns);
+      Function("$", "__a", ...params, body);
+    } catch {
+      continue;
+    }
+    lines.push(`  ${JSON.stringify(key)}: function($, __a, ${params.join(", ")}) { ${body} },`);
+  }
+  return `export const table = {
+${lines.join("\n")}
+}
+`;
+};
+const entities = { "&quot;": '"', "&#39;": "'", "&apos;": "'", "&lt;": "<", "&gt;": ">", "&amp;": "&" };
+const decode = (s) => s.replace(/&(quot|#39|apos|lt|gt|amp);/g, (m) => entities[m]);
+const extractExpressions = (source, plugins, prefixes = ["data-"]) => {
+  const byName = new Map(plugins.map((p) => [p.name, p]));
+  const out = [];
+  const re = /([a-z][\w-]*(?::[^\s="'<>]+)?(?:__[^\s="'<>]+)*)=(?:"([^"]*)"|'([^']*)')/g;
+  for (const m of source.matchAll(re)) {
+    const attr = m[1];
+    const value = decode(m[2] ?? m[3] ?? "");
+    const prefix = prefixes.find((p) => attr.startsWith(p));
+    if (!prefix || !value.trim()) continue;
+    const plugin = byName.get(attr.slice(prefix.length).split("__")[0].split(":")[0]);
+    if (!plugin) continue;
+    out.push({ src: value, params: ["el", "evt", ...plugin.args ?? []], returns: plugin.returns ?? true });
+  }
+  return out;
+};
+export {
+  compileBody,
+  extractExpressions,
+  generateTable,
+  rewriteSignals
+};
+//# sourceMappingURL=precompile.js.map

package/dist/kernel/precompile.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/kernel/precompile.ts"],
+  "sourcesContent": ["// Build-time expression compiler. Not for the browser: import it from a Vite/Astro plugin.\nimport { rewriteActions, splitStatements } from './compile.js'\nimport { expressionKey } from './precompiled.js'\n\nconst ident = /[A-Za-z0-9_$]/\n\n/**\n * Rewrite `$name` and `$a.b` into `$.name` / `$.a.b` so the expression runs in strict mode without\n * `with`. Skips strings and comments, recurses into template-literal interpolations, and leaves\n * `$` alone, `$[...]` alone, and `obj.$prop` alone.\n */\nexport const rewriteSignals = (src: string): string => {\n  let out = ''\n  let i = 0\n  const n = src.length\n  const prevCode = () => {\n    for (let j = out.length - 1; j >= 0; j--) if (!/\\s/.test(out[j])) return out[j]\n    return ''\n  }\n  while (i < n) {\n    const c = src[i]\n    const next = src[i + 1]\n    if (c === '\"' || c === \"'\") {\n      let j = i + 1\n      while (j < n && src[j] !== c) j += src[j] === '\\\\' ? 2 : 1\n      out += src.slice(i, j + 1)\n      i = j + 1\n    } else if (c === '`') {\n      out += c\n      i++\n      while (i < n && src[i] !== '`') {\n        if (src[i] === '\\\\') {\n          out += src.slice(i, i + 2)\n          i += 2\n        } else if (src[i] === '$' && src[i + 1] === '{') {\n          let depth = 1\n          let j = i + 2\n          while (j < n && depth) {\n            if (src[j] === '{') depth++\n            else if (src[j] === '}') depth--\n            if (depth) j++\n          }\n          out += '${' + rewriteSignals(src.slice(i + 2, j)) + '}'\n          i = j + 1\n        } else out += src[i++]\n      }\n      out += '`'\n      i++\n    } else if (c === '/' && next === '/') {\n      const j = src.indexOf('\\n', i)\n      i = j < 0 ? n : j\n    } else if (c === '/' && next === '*') {\n      const j = src.indexOf('*/', i + 2)\n      i = j < 0 ? n : j + 2\n    } else if (c === '$' && next !== undefined && ident.test(next) && next !== '$' && prevCode() !== '.' && !ident.test(out[out.length - 1] ?? '')) {\n      let j = i + 1\n      while (j < n && ident.test(src[j])) j++\n      out += '$.' + src.slice(i + 1, j)\n      i = j\n    } else {\n      out += c\n      i++\n    }\n  }\n  return out\n}\n\n/** The strict-mode function body for one expression: same semantics as the runtime compiler. */\nexport const compileBody = (src: string, returns: boolean): string => {\n  const code = rewriteSignals(rewriteActions(src.trim()))\n  if (!returns) return code\n  const parts = splitStatements(code)\n  const last = parts.pop() ?? ''\n  return `${parts.length ? parts.join(';') + ';' : ''}return (${last}\\n)`\n}\n\nexport type Extracted = { src: string; params: string[]; returns: boolean }\n\n/** JavaScript source for a module exporting `table`, from a list of extracted expressions. */\nexport const generateTable = (items: Extracted[]): string => {\n  const seen = new Set<string>()\n  const lines: string[] = []\n  for (const { src, params, returns } of items) {\n    const key = expressionKey(src, params, returns)\n    if (seen.has(key)) continue\n    seen.add(key)\n    let body: string\n    try {\n      body = compileBody(src, returns)\n      Function('$', '__a', ...params, body) // syntax check at build time\n    } catch {\n      continue // leave it to the runtime fallback (or fail there)\n    }\n    lines.push(`  ${JSON.stringify(key)}: function($, __a, ${params.join(', ')}) { ${body} },`)\n  }\n  return `export const table = {\\n${lines.join('\\n')}\\n}\\n`\n}\n\nconst entities: Record<string, string> = { '&quot;': '\"', '&#39;': \"'\", '&apos;': \"'\", '&lt;': '<', '&gt;': '>', '&amp;': '&' }\nconst decode = (s: string) => s.replace(/&(quot|#39|apos|lt|gt|amp);/g, (m) => entities[m])\n\nexport type PluginMeta = { name: string; returns?: boolean; args?: string[] }\n\n/**\n * Find directive attributes with literal values in template source. Values must be plain quoted\n * strings; anything interpolated at render time is left to the runtime fallback.\n */\nexport const extractExpressions = (source: string, plugins: PluginMeta[], prefixes: string[] = ['data-']): Extracted[] => {\n  const byName = new Map(plugins.map((p) => [p.name, p]))\n  const out: Extracted[] = []\n  const re = /([a-z][\\w-]*(?::[^\\s=\"'<>]+)?(?:__[^\\s=\"'<>]+)*)=(?:\"([^\"]*)\"|'([^']*)')/g\n  for (const m of source.matchAll(re)) {\n    const attr = m[1]\n    const value = decode(m[2] ?? m[3] ?? '')\n    const prefix = prefixes.find((p) => attr.startsWith(p))\n    if (!prefix || !value.trim()) continue\n    const plugin = byName.get(attr.slice(prefix.length).split('__')[0].split(':')[0])\n    if (!plugin) continue\n    out.push({ src: value, params: ['el', 'evt', ...(plugin.args ?? [])], returns: plugin.returns ?? true })\n  }\n  return out\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/kernel/precompiled.d.ts

@@ -0,0 +1,11 @@
+import type { ExpressionCompiler } from './contracts.js';
+export type ExpressionTable = Record<string, (root: any, actions: any, el: any, evt: any, ...args: any[]) => any>;
+/** Key used by the build plugin and the lookup: returns flag, parameter names, trimmed source. */
+export declare const expressionKey: (src: string, params: string[], returns: boolean) => string;
+/**
+ * Look expressions up in a table generated at build time (see `sigmx/precompile`). Precompiled functions
+ * receive the root store proxy as `$` instead of a `with` scope. Pass a `fallback` (for example
+ * `runtimeExpressions(functionCompiler)`) for markup assembled at runtime; omit it and the runtime
+ * compiler is not bundled at all.
+ */
+export declare const precompiled: (table: ExpressionTable, fallback?: ExpressionCompiler, onMiss?: (src: string) => void) => ExpressionCompiler;

package/dist/kernel/precompiled.js

@@ -0,0 +1,13 @@
+const expressionKey = (src, params, returns) => `${+returns}|${params.join()}|${src.trim()}`;
+const precompiled = (table, fallback, onMiss) => (src, params, returns) => {
+  const fn = table[expressionKey(src, params, returns)];
+  if (fn) return ((store, actions, el, evt, ...args) => fn(store.$, actions, el, evt, ...args));
+  onMiss?.(src);
+  if (!fallback) throw new Error(`expression not precompiled: ${src}`);
+  return fallback(src, params, returns);
+};
+export {
+  expressionKey,
+  precompiled
+};
+//# sourceMappingURL=precompiled.js.map