@nisli/core 0.56.0 → 0.57.1

package/dist/context.js

@@ -1,55 +0,0 @@
-/**
- * context.ts — Setup context for pure function DI
- *
- * The setup context lets pure functions (inject(), listen(), effect())
- * access the component they belong to without needing `this`.
- *
- * The context exists ONLY during component initialization (setup()).
- * It is NOT a runtime thing — it's a synchronous initialization-time concept.
- *
- * Same pattern as Angular's inject(), Solid's createSignal(), Vue's setup().
- */
-// ── Context state ───────────────────────────────────────────────────
-let currentComponent = null;
-// ── Public API ──────────────────────────────────────────────────────
-/**
- * Run a function with a component as the active context.
- * Pure functions called during `fn` can access the component via
- * `getCurrentComponent()`.
- *
- * Context is strictly synchronous — it does NOT survive across
- * await boundaries or microtasks.
- */
-export function runWithContext(component, fn) {
-    const prev = currentComponent;
-    currentComponent = component;
-    try {
-        fn();
-    }
-    finally {
-        currentComponent = prev;
-    }
-}
-/**
- * Get the currently active component host.
- * Throws if called outside a setup() context.
- *
- * This is framework-internal — component authors use inject(), effect(),
- * etc., which call this internally.
- */
-export function getCurrentComponent() {
-    if (!currentComponent) {
-        throw new Error('getCurrentComponent() called outside setup(). ' +
-            'inject(), effect(), and other context-dependent functions ' +
-            'can only be called during component initialization.');
-    }
-    return currentComponent;
-}
-/**
- * Check if there is an active setup context.
- * Returns true during component setup, false otherwise.
- */
-export function hasContext() {
-    return currentComponent !== null;
-}
-//# sourceMappingURL=context.js.map

package/dist/context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAeH,uEAAuE;AAEvE,IAAI,gBAAgB,GAAyB,IAAI,CAAC;AAElD,uEAAuE;AAEvE;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,SAAwB,EAAE,EAAc;IACrE,MAAM,IAAI,GAAG,gBAAgB,CAAC;IAC9B,gBAAgB,GAAG,SAAS,CAAC;IAC7B,IAAI,CAAC;QACH,EAAE,EAAE,CAAC;IACP,CAAC;YAAS,CAAC;QACT,gBAAgB,GAAG,IAAI,CAAC;IAC1B,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB;IACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CACb,gDAAgD;YAChD,4DAA4D;YAC5D,qDAAqD,CACtD,CAAC;IACJ,CAAC;IACD,OAAO,gBAAgB,CAAC;AAC1B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,gBAAgB,KAAK,IAAI,CAAC;AACnC,CAAC"}

package/dist/diagnostics.js

@@ -1,118 +0,0 @@
-/**
- * diagnostics.ts — coded diagnostics leaf + the dev-mode gate (ADR 0030.2, Wave 1)
- *
- * The shared foundation every core layer reports through. Two rules keep it a
- * LEAF (ADR 0030.2 §7): zero imports from other core modules (so signal.ts,
- * template.ts, component.ts, injector.ts can all use it without cycles), and
- * codes + a minimal payload emitter only — no docs prose.
- *
- * Contract:
- * - Every diagnostic carries a stable machine code `N<range><nn>` and renders
- *   as ONE console.error line: `[nisli CODE] message` (+ structured detail as
- *   the second console argument when given). Thrown coded errors reuse the
- *   same `[nisli CODE]` prefix via {@link formatDiag} so `grep '\[nisli '`
- *   finds every framework-reported failure, logged or thrown.
- * - `diag()` itself is NOT dev-gated: gating is the CALL SITE's policy. Some
- *   diagnostics are production facts (T6 containment N401/N402 — parity with
- *   the pre-T6 unconditional console.error); others are dev-only attribution
- *   (N201/N202/N501) and their callers guard with {@link isDev}.
- *
- * The dev gate (a named Wave-1 deliverable — core had NO dev/prod mechanism):
- * a runtime probe, layered for the three environments core must serve without
- * a bundler assumption (ADR 0019):
- *   1. `import.meta.env.DEV` / `.PROD` when an injector (Vite serve/build,
- *      vitest) provides them — statically replaced in Vite builds, so a prod
- *      build resolves prod even in the browser where `process` is absent.
- *   2. `globalThis.process?.env?.NODE_ENV` — Node scripts, test runners, SSG.
- *   3. Neither present (raw buildless ESM in a browser): DEV — loud by
- *      default, matching the framework's no-build posture; `setDevMode(false)`
- *      is the explicit opt-out for buildless production pages.
- * The probe runs once at module load; `setDevMode()` overrides it (tests,
- * bundler-less prod), `setDevMode(null)` restores the probed default.
- */
-// ── Code registry ───────────────────────────────────────────────────
-//
-// The minimal central code table (0030.1 B2, landed as part of T6 per §8).
-// `Nxyz` = concrete code; `Nxxx` range keys document ownership so parallel
-// waves allocate without collision. Ranges owned by other Wave-1 worktrees
-// (template, reactivity, async) are seeded here as placeholders only — their
-// concrete codes land with their waves.
-export const codes = {
-    // Range placeholders — owner module in parentheses.
-    N1xx: 'template: parse/static-audit diagnostics (template.ts — template wave)',
-    N2xx: 'define/props: registration and prop-contract diagnostics (component.ts)',
-    N3xx: 'reactivity: scheduler/purity diagnostics (signal.ts — scheduler wave)',
-    N4xx: 'lifecycle: setup/mount containment (component.ts, lifecycle.ts)',
-    N5xx: 'dependency injection (injector.ts)',
-    N6xx: 'async: query/resource/settle diagnostics (query.ts, resource.ts — async wave)',
-    // Assigned codes.
-    N201: 'duplicate component definition — tag already defined; first definition stays live',
-    N202: 'unknown-prop echo — prop written after mount but never read by setup()',
-    N401: 'setup failed — scope contained, host stamped data-nisli-error="N401"',
-    N402: 'onMount failed — scope contained, host stamped data-nisli-error="N402"',
-    N501: 'provide() after the token was already instantiated — resetInjector() first',
-    N101: 'template audit — dash-tag never defined (misspelled or unimported component?)',
-    N102: 'template audit — unknown @event name',
-    N103: 'template audit — unknown event modifier',
-    N104: 'template audit — undeclared attribute on a component with declared attrs',
-    N105: 'template — remounting a live bound TemplateResult (shared-binding corruption)',
-    N106: 'template — html:inner requires a branded value: raw(), sanitized(), or TrustedHTML',
-    N107: 'template — html:inner sanitized() has no sink: no native Element.setHTML() and no setSanitizerFallback() hook',
-    N301: 'reactivity — effect exceeded the consecutive re-schedule cap (loop); disposed',
-    N302: 'reactivity — effect wrote a signal in its own dependency set (attribution)',
-    N303: 'reactivity — flush()/tick() iteration cap reached before quiescence',
-    N310: 'reactivity — effect callback returned a Promise; use resource() for async',
-    N602: 'query — invalid key element (flat primitives only; null is the optional sentinel)',
-    N603: 'settle() — no quiescence within the iteration cap; returning anyway',
-    // N601 (mixed QueryClients) was retired before release: N501 makes that
-    // state unrepresentable at its cause. The number is not reused.
-};
-// ── Dev gate ────────────────────────────────────────────────────────
-function probeDevMode() {
-    // 1) import.meta.env injectors (Vite, vitest). Read the OBJECT (not the
-    // dotted key) so Vite's define replacement works through the optional
-    // access, and a missing env is just `undefined` in Node/raw ESM.
-    const env = import.meta.env;
-    if (env && typeof env.DEV === 'boolean')
-        return env.DEV;
-    if (env && typeof env.PROD === 'boolean')
-        return !env.PROD;
-    // 2) Node / test runners / bundlers that define process.env.NODE_ENV.
-    const nodeEnv = globalThis.process?.env?.NODE_ENV;
-    if (typeof nodeEnv === 'string')
-        return nodeEnv !== 'production';
-    // 3) No signal at all (raw buildless ESM): loud by default.
-    return true;
-}
-const probed = probeDevMode();
-let override = null;
-/** Whether dev-only diagnostics are active. See the module doc for the probe. */
-export function isDev() {
-    return override ?? probed;
-}
-/**
- * Override the probed dev mode (`true`/`false`), or restore the probed
- * default (`null`). For tests and for buildless pages deployed to production.
- */
-export function setDevMode(on) {
-    override = on;
-}
-// ── Emission ────────────────────────────────────────────────────────
-/** The shared `[nisli CODE] message` line, for both logged and thrown paths. */
-export function formatDiag(code, message) {
-    return `[nisli ${code}] ${message}`;
-}
-/**
- * Emit one coded diagnostic: a single console.error line
- * `[nisli CODE] message`, with `detail` attached as structured payload.
- * NOT dev-gated here — the caller owns the policy (see module doc).
- */
-export function diag(code, message, detail) {
-    if (detail === undefined) {
-        console.error(formatDiag(code, message));
-    }
-    else {
-        console.error(formatDiag(code, message), detail);
-    }
-}
-//# sourceMappingURL=diagnostics.js.map

package/dist/diagnostics.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostics.js","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,uEAAuE;AACvE,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,2EAA2E;AAC3E,6EAA6E;AAC7E,wCAAwC;AACxC,MAAM,CAAC,MAAM,KAAK,GAA2B;IAC3C,oDAAoD;IACpD,IAAI,EAAE,wEAAwE;IAC9E,IAAI,EAAE,yEAAyE;IAC/E,IAAI,EAAE,uEAAuE;IAC7E,IAAI,EAAE,iEAAiE;IACvE,IAAI,EAAE,oCAAoC;IAC1C,IAAI,EAAE,+EAA+E;IACrF,kBAAkB;IAClB,IAAI,EAAE,mFAAmF;IACzF,IAAI,EAAE,wEAAwE;IAC9E,IAAI,EAAE,sEAAsE;IAC5E,IAAI,EAAE,wEAAwE;IAC9E,IAAI,EAAE,4EAA4E;IAClF,IAAI,EAAE,+EAA+E;IACrF,IAAI,EAAE,sCAAsC;IAC5C,IAAI,EAAE,yCAAyC;IAC/C,IAAI,EAAE,0EAA0E;IAChF,IAAI,EAAE,+EAA+E;IACrF,IAAI,EAAE,oFAAoF;IAC1F,IAAI,EAAE,+GAA+G;IACrH,IAAI,EAAE,+EAA+E;IACrF,IAAI,EAAE,4EAA4E;IAClF,IAAI,EAAE,qEAAqE;IAC3E,IAAI,EAAE,2EAA2E;IACjF,IAAI,EAAE,mFAAmF;IACzF,IAAI,EAAE,qEAAqE;IAC3E,wEAAwE;IACxE,gEAAgE;CACjE,CAAC;AAEF,uEAAuE;AAEvE,SAAS,YAAY;IACnB,wEAAwE;IACxE,sEAAsE;IACtE,iEAAiE;IACjE,MAAM,GAAG,GAAI,MAAM,CAAC,IAElB,CAAC,GAAG,CAAC;IACP,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,GAAG,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,GAAG,CAAC;IACxD,IAAI,GAAG,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;IAC3D,sEAAsE;IACtE,MAAM,OAAO,GAAI,UAEf,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC;IAC1B,IAAI,OAAO,OAAO,KAAK,QAAQ;QAAE,OAAO,OAAO,KAAK,YAAY,CAAC;IACjE,4DAA4D;IAC5D,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,MAAM,GAAG,YAAY,EAAE,CAAC;AAC9B,IAAI,QAAQ,GAAmB,IAAI,CAAC;AAEpC,iFAAiF;AACjF,MAAM,UAAU,KAAK;IACnB,OAAO,QAAQ,IAAI,MAAM,CAAC;AAC5B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,EAAkB;IAC3C,QAAQ,GAAG,EAAE,CAAC;AAChB,CAAC;AAED,uEAAuE;AAEvE,gFAAgF;AAChF,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,OAAe;IACtD,OAAO,UAAU,IAAI,KAAK,OAAO,EAAE,CAAC;AACtC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,IAAI,CAAC,IAAY,EAAE,OAAe,EAAE,MAAgC;IAClF,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC3C,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;AACH,CAAC"}

package/dist/disposable.js

@@ -1,8 +0,0 @@
-const DISPOSE = Symbol.dispose;
-/** Attach a guarded Symbol.dispose alias without polyfilling the platform. */
-export function disposable(value, dispose) {
-    if (DISPOSE)
-        value[DISPOSE] = dispose;
-    return value;
-}
-//# sourceMappingURL=disposable.js.map

package/dist/disposable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"disposable.js","sourceRoot":"","sources":["../src/disposable.ts"],"names":[],"mappings":"AAcA,MAAM,OAAO,GAAG,MAAM,CAAC,OAA4C,CAAC;AAEpE,8EAA8E;AAC9E,MAAM,UAAU,UAAU,CACxB,KAAQ,EACR,OAAmB;IAEnB,IAAI,OAAO;QAAG,KAAoC,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IACtE,OAAO,KAA+B,CAAC;AACzC,CAAC"}

package/dist/element-context.js

@@ -1,108 +0,0 @@
-/**
- * element-context.ts — subtree-scoped context (provide / inject).
- *
- * The DOM-native equivalent of React/Radix context: a provider publishes a
- * typed value on its host element, and descendant components `inject()` it by
- * walking up the element tree. It replaces the userland `host.__uiX = state` +
- * `host.closest('ui-x')` convention (stringly-typed, invisible to TypeScript,
- * re-implemented per family) with an identity-keyed, end-to-end-typed primitive.
- *
- * ```ts
- * interface TabsState { value: ReadonlySignal<string>; setValue(v: string): void }
- * const TabsContext = createContext<TabsState>('Tabs');
- *
- * // provider setup:
- * TabsContext.provide(host, state);
- *
- * // descendant setup:
- * const tabs = TabsContext.inject();          // throws (error boundary) if absent
- * const maybe = TabsContext.inject.optional(); // TabsState | undefined
- * ```
- *
- * Design (see ADR 0025 §2):
- *
- * - **Typed, no string keys.** Each `createContext` mints a private `Symbol`
- *   used as the storage key; consumers reference the context object, never a
- *   string. Two contexts never collide even with the same `name` (name is for
- *   diagnostics only).
- *
- * - **Capture at setup, not at lookup.** `inject()` resolves during component
- *   setup, while the injecting host is still a DOM descendant of its provider.
- *   It returns the value *once*; because provider values carry signals,
- *   reactivity flows through them with no further tree-walks. This is what makes
- *   it **portal-safe**: after a subtree is reparented to `<body>` (dialog, menu,
- *   …) the injected value is already held, so the component keeps resolving its
- *   ORIGINAL provider — a later walk from the portaled host would find nothing.
- *   `inject()` therefore requires an active setup context when no host is passed.
- *
- * - **Zero cost for non-users.** Providing sets one symbol property on the host;
- *   injecting is a `parentElement` walk. Components that use neither pay nothing,
- *   and there is no global registry to maintain.
- */
-import { getCurrentComponent, hasContext } from './context.js';
-// ── Public API ──────────────────────────────────────────────────────
-/**
- * Create a subtree-scoped context. `name` is used only in diagnostics; the
- * context's identity (a private symbol) is what keys storage and lookup.
- *
- * Pass `{ providerTag }` to name the provider element so a missing-provider
- * `inject()` produces an ACTIONABLE, element-language error —
- * `<injecting-tag> must be used inside <provider-tag>.` — instead of naming the
- * private context object. Set it whenever consumers are DOM elements (the whole
- * registry): it's the difference between a message a plain-HTML user can act on
- * and one they can't.
- */
-export function createContext(name, options = {}) {
-    const { providerTag } = options;
-    // Private per-context storage key. Not derived from `name`, so same-named
-    // contexts stay distinct, and it never appears in userland.
-    const KEY = Symbol(`nisli.context:${name}`);
-    const store = (el) => el;
-    const provide = (host, value) => {
-        store(host)[KEY] = value;
-    };
-    const peek = (host) => KEY in host ? store(host)[KEY] : undefined;
-    // Walk up the element tree (inclusive of `start`) to the nearest provider.
-    // `parentElement` transparently crosses `display: contents` hosts.
-    const find = (start) => {
-        let el = start;
-        while (el) {
-            if (KEY in el)
-                return store(el)[KEY];
-            el = el.parentElement;
-        }
-        return undefined;
-    };
-    const startHost = (host, caller) => {
-        if (host)
-            return host;
-        if (!hasContext()) {
-            throw new Error(`${caller} for context "${name}" was called without a host and outside component ` +
-                `setup. Call it during setup (so the provider is resolved before any portal move), ` +
-                `or pass an explicit host.`);
-        }
-        return getCurrentComponent().element;
-    };
-    const inject = ((host) => {
-        const start = startHost(host, 'inject()');
-        const found = find(start);
-        if (found === undefined) {
-            const injectingTag = start.tagName.toLowerCase();
-            // With a declared provider tag, speak element-language the consumer can
-            // act on; otherwise fall back to the generic (provider named by API).
-            throw new Error(providerTag
-                ? `Context "${name}": <${injectingTag}> must be used inside <${providerTag}>.`
-                : `Context "${name}" not found: <${injectingTag}> must be rendered ` +
-                    `inside a provider that calls ${name}Context.provide(host, …).`);
-        }
-        return found;
-    });
-    inject.optional = (host) => {
-        // Outside setup with no host: there is nothing to resolve from — undefined.
-        if (!host && !hasContext())
-            return undefined;
-        return find(startHost(host, 'inject.optional()'));
-    };
-    return { name, provide, inject, peek };
-}
-//# sourceMappingURL=element-context.js.map

package/dist/element-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"element-context.js","sourceRoot":"","sources":["../src/element-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAgC/D,uEAAuE;AAEvE;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAC3B,IAAY,EACZ,UAAoC,EAAE;IAEtC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC;IAChC,0EAA0E;IAC1E,4DAA4D;IAC5D,MAAM,GAAG,GAAG,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC;IAE5C,MAAM,KAAK,GAAG,CAAC,EAAW,EAA2B,EAAE,CACrD,EAAwC,CAAC;IAE3C,MAAM,OAAO,GAAG,CAAC,IAAiB,EAAE,KAAQ,EAAQ,EAAE;QACpD,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IAC3B,CAAC,CAAC;IAEF,MAAM,IAAI,GAAG,CAAC,IAAiB,EAAiB,EAAE,CAChD,GAAG,IAAI,IAAI,CAAC,CAAC,CAAE,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IAEpD,2EAA2E;IAC3E,mEAAmE;IACnE,MAAM,IAAI,GAAG,CAAC,KAAkB,EAAiB,EAAE;QACjD,IAAI,EAAE,GAAmB,KAAK,CAAC;QAC/B,OAAO,EAAE,EAAE,CAAC;YACV,IAAI,GAAG,IAAI,EAAE;gBAAE,OAAO,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,CAAM,CAAC;YAC1C,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC;QACxB,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,CAAC,IAA6B,EAAE,MAAc,EAAsB,EAAE;QACtF,IAAI,IAAI;YAAE,OAAO,IAAI,CAAC;QACtB,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CACb,GAAG,MAAM,iBAAiB,IAAI,oDAAoD;gBAChF,oFAAoF;gBACpF,2BAA2B,CAC9B,CAAC;QACJ,CAAC;QACD,OAAO,mBAAmB,EAAE,CAAC,OAAO,CAAC;IACvC,CAAC,CAAC;IAEF,MAAM,MAAM,GAAG,CAAC,CAAC,IAAkB,EAAK,EAAE;QACxC,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,EAAE,UAAU,CAAE,CAAC;QAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YACjD,wEAAwE;YACxE,sEAAsE;YACtE,MAAM,IAAI,KAAK,CACb,WAAW;gBACT,CAAC,CAAC,YAAY,IAAI,OAAO,YAAY,0BAA0B,WAAW,IAAI;gBAC9E,CAAC,CAAC,YAAY,IAAI,iBAAiB,YAAY,qBAAqB;oBAChE,gCAAgC,IAAI,2BAA2B,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAc,CAAC;IAEhB,MAAM,CAAC,QAAQ,GAAG,CAAC,IAAkB,EAAiB,EAAE;QACtD,4EAA4E;QAC5E,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE;YAAE,OAAO,SAAS,CAAC;QAC7C,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,mBAAmB,CAAE,CAAC,CAAC;IACrD,CAAC,CAAC;IAEF,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AACzC,CAAC"}

package/dist/emitter.js

@@ -1,91 +0,0 @@
-/**
- * emitter.ts — Typed pub/sub base class for services.
- *
- * Replaces `document.dispatchEvent(new CustomEvent(...))` with typed,
- * scoped event emitters. Services extend Emitter<T> where T defines
- * the event contract as a record of event names → payload types.
- *
- * ```ts
- * class NavigationEvents extends Emitter<{
- *   select: { id: string };
- *   filter: { filter: string };
- * }> {}
- *
- * const nav = inject(NavigationEvents);
- * nav.emit('select', { id: 'TASK-1' });           // typed
- * nav.on('select', ({ id }) => console.log(id));   // typed
- * const selectedId = nav.toSignal('select', e => e.id, null);
- * ```
- */
-import { signal } from './signal.js';
-import { hasContext, getCurrentComponent } from './context.js';
-import { disposable } from './disposable.js';
-// ── Emitter base class ──────────────────────────────────────────────
-export class Emitter {
-    listeners = new Map();
-    /**
-     * Emit a typed event. All subscribers for this event name are called
-     * synchronously. If a subscriber throws, other subscribers still fire.
-     */
-    emit(event, payload) {
-        const set = this.listeners.get(event);
-        if (!set)
-            return;
-        // Iterate a copy to allow unsubscribe during callback
-        for (const fn of [...set]) {
-            try {
-                fn(payload);
-            }
-            catch (err) {
-                console.error(`Emitter: subscriber for '${String(event)}' threw:`, err);
-            }
-        }
-    }
-    /**
-     * Subscribe to a typed event. Returns an unsubscribe function.
-     *
-     * If called during component setup, the subscription is automatically
-     * disposed on disconnectedCallback.
-     */
-    on(event, fn) {
-        let set = this.listeners.get(event);
-        if (!set) {
-            set = new Set();
-            this.listeners.set(event, set);
-        }
-        set.add(fn);
-        const unsubscribe = () => {
-            set.delete(fn);
-            if (set.size === 0) {
-                this.listeners.delete(event);
-            }
-        };
-        // Auto-dispose if inside component setup context
-        if (hasContext()) {
-            getCurrentComponent().addDisposer(unsubscribe);
-        }
-        return disposable(unsubscribe, unsubscribe);
-    }
-    /**
-     * Bridge an event into the signal system.
-     * Returns a signal that updates whenever the event fires.
-     *
-     * @param event - Event name to subscribe to
-     * @param selector - Transform the payload into the signal value
-     * @param initial - Initial signal value before any event fires
-     */
-    toSignal(event, selector, initial) {
-        const s = signal(initial);
-        this.on(event, (payload) => {
-            s.value = selector(payload);
-        });
-        return s;
-    }
-    /**
-     * Remove all subscribers. Useful for testing cleanup.
-     */
-    clear() {
-        this.listeners.clear();
-    }
-}
-//# sourceMappingURL=emitter.js.map

package/dist/emitter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"emitter.js","sourceRoot":"","sources":["../src/emitter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,EAAe,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,UAAU,EAAiB,MAAM,iBAAiB,CAAC;AAO5D,uEAAuE;AAEvE,MAAM,OAAO,OAAO;IACV,SAAS,GAAG,IAAI,GAAG,EAAoC,CAAC;IAEhE;;;OAGG;IACH,IAAI,CAAyB,KAAQ,EAAE,OAAkB;QACvD,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,GAAG;YAAE,OAAO;QAEjB,sDAAsD;QACtD,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC;gBACH,EAAE,CAAC,OAAO,CAAC,CAAC;YACd,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,4BAA4B,MAAM,CAAC,KAAK,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC;YAC1E,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,EAAE,CAAyB,KAAQ,EAAE,EAAuB;QAC1D,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,GAAG,GAAG,IAAI,GAAG,EAAE,CAAC;YAChB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QACjC,CAAC;QACD,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEZ,MAAM,WAAW,GAAG,GAAG,EAAE;YACvB,GAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YAChB,IAAI,GAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;gBACpB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;QACH,CAAC,CAAC;QAEF,iDAAiD;QACjD,IAAI,UAAU,EAAE,EAAE,CAAC;YACjB,mBAAmB,EAAE,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,UAAU,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;;;OAOG;IACH,QAAQ,CACN,KAAQ,EACR,QAAmC,EACnC,OAAU;QAEV,MAAM,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;QAC1B,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,EAAE;YACzB,CAAC,CAAC,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAC;QACH,OAAO,CAAC,CAAC;IACX,CAAC;IAED;;OAEG;IACH,KAAK;QACH,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;IACzB,CAAC;CACF"}

package/dist/hmr/registry.js

@@ -1,136 +0,0 @@
-/**
- * hmr/registry.ts — Transport-agnostic HMR core for Nisli (ADR 0021, ADR 0110).
- *
- * The tag→setup registry, the stable indirection thunk, and the in-place
- * re-mount through the custom-element lifecycle. This is the part that is
- * IDENTICAL regardless of how change notifications arrive — change
- * (`../esbuild-hmr/*`) or Vite `import.meta.hot` (`../vite-hmr/*`) both drive
- * the same registry. Keeping it here means one implementation, one set of
- * correctness guarantees (ADR 0008.1 disposal), and no duplication.
- *
- * DEV-ONLY: reachable only via the dev subpaths, never from the `@nisli/core`
- * `.` entry, so it contributes zero production bytes.
- */
-// ── Tag → setup registry (Ruling 2) ─────────────────────────────────
-const registry = new Map();
-/** Tags whose setup changed since the last drain — pending a re-mount. */
-const pendingRemounts = new Set();
-let remountScheduled = false;
-/**
- * When true, `__register` accumulates pending tags but does NOT auto-schedule a
- * microtask drain — the caller owns the drain so it can wait for a full module
- * re-eval to register ALL changed tags first.
- * The Vite path leaves this false and drains explicitly from its accept hook.
- */
-let suppressAutoDrain = false;
-/**
- * Begin a caller-owned drain window: suppress auto-scheduling AND cancel any
- * pending microtask drain, so the caller can re-evaluate a whole bundle and
- * register ALL changed tags before a single explicit `drainRemounts()`. Used by
- * the Vite path drains per-module.
- */
-export function beginManualDrain() {
-    suppressAutoDrain = true;
-    remountScheduled = false;
-}
-/** End a caller-owned drain window (re-enable auto-scheduling). */
-export function endManualDrain() {
-    suppressAutoDrain = false;
-}
-/**
- * Register (or update) the setup for a tag and return a STABLE indirection
- * thunk that always reads the *current* setup from the registry.
- *
- * First registration for a tag (initial load) schedules no re-mount. A
- * subsequent registration with a *different* setup reference (a rebuild
- * re-evaluating the module) queues the tag for re-mount.
- *
- * The returned thunk is what `component()` hands to the real
- * `FrameworkComponent`; because it reads `registry.get(tag)` lazily, the live
- * element picks up new setup with no class swap or tag re-definition.
- */
-export function __register(tag, setup) {
-    const prev = registry.get(tag);
-    registry.set(tag, setup);
-    if (prev !== undefined && prev !== setup) {
-        pendingRemounts.add(tag);
-        if (!suppressAutoDrain)
-            scheduleRemount();
-    }
-    const thunk = (props, host) => {
-        const current = registry.get(tag);
-        if (!current)
-            throw new Error(`[nisli-hmr] no setup registered for <${tag}>`);
-        return current(props, host);
-    };
-    // N201 exemption marker (ADR 0030.2 §3/§8): component() throws a coded dev
-    // error on duplicate `define`, EXCEPT when the incoming setup is a registry
-    // thunk — an HMR re-evaluation of the same module re-calling component() is
-    // the swap mechanism working, not a second definer. The marker rides the
-    // thunk itself so component.ts needs no import from this dev-only module.
-    thunk.__nisliHmr = true;
-    return thunk;
-}
-/** Number of tags awaiting a re-mount (for orchestration/tests). */
-export function pendingRemountCount() {
-    return pendingRemounts.size;
-}
-/** Drain and re-mount every pending tag. Returns the tags that were remounted. */
-export function drainRemounts() {
-    const tags = [...pendingRemounts];
-    pendingRemounts.clear();
-    remountScheduled = false;
-    for (const tag of tags)
-        remount(tag);
-    return tags;
-}
-function scheduleRemount() {
-    if (remountScheduled)
-        return;
-    remountScheduled = true;
-    // Defer so a full module re-eval can register *all* changed tags first.
-    queueMicrotask(() => {
-        if (remountScheduled)
-            drainRemounts();
-    });
-}
-// ── Re-mount through the existing lifecycle (Ruling 3) ──────────────
-/**
- * Re-mount every live element of `tag` in place, on the SAME instance:
- *
- *   disconnectedCallback()  — resets `_mounted`, disposes effects + template
- *                             (the ADR 0008.1 disposal contract)
- *   replaceChildren()       — clears old DOM, firing nested custom elements'
- *                             disconnectedCallback so their disposers run too
- *   connectedCallback()     — re-runs the NEW setup (via the registry thunk)
- *                             inside the same `untrack(...)` mount path
- *
- * Props survive because `_propsProxy` is constructor-owned (component.ts), and
- * the element node identity is preserved — siblings, scroll, route, and global
- * stores are untouched.
- */
-export function remount(tag) {
-    const elements = document.querySelectorAll(tag);
-    elements.forEach((node) => {
-        const el = node;
-        if (el._remount) {
-            el._remount();
-            return;
-        }
-        // Dispose first: must run BEFORE clearing DOM or effects/subscriptions
-        // leak across reloads (ADR 0008.1 hazard).
-        el.disconnectedCallback?.();
-        // Clear old DOM — removal fires nested children's disconnectedCallback.
-        el.replaceChildren();
-        // Re-run setup + re-mount on the same instance.
-        el.connectedCallback?.();
-    });
-}
-/** Test-only: clear the registry and pending state between cases. */
-export function __resetRegistry() {
-    registry.clear();
-    pendingRemounts.clear();
-    remountScheduled = false;
-    suppressAutoDrain = false;
-}
-//# sourceMappingURL=registry.js.map

package/dist/hmr/registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/hmr/registry.ts"],"names":[],"mappings":"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"}

package/dist/hmr/transform.js

@@ -1,52 +0,0 @@
-/**
- * hmr/transform.ts — Shared source rewrite for Nisli HMR (ADR 0021, ADR 0110).
- *
- * Wraps the `component` a module imports from `@nisli/core` with the registry
- * indirection so a rebuilt module's `component()` calls re-register their setup
- * and trigger an in-place re-mount. Transport-agnostic and pure — used by both
- * the Vite `transform` hook.
- */
-function escapeRegExp(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Rewrite a module's source so the `component` it imports from `coreSpecifier`
- * is wrapped by the registry indirection from `runtimeSpecifier`.
- *
- * Strategy: alias the real import, then shadow `component` with a wrapper that
- * registers the setup and passes a STABLE thunk to the real `component`. Cost:
- * one Map write + one thunk allocation per `component()` call.
- *
- * Returns the original source unchanged if it does not import `component` from
- * the core specifier (nothing to wrap) — the caller uses identity to decide
- * whether the module is HMR-relevant.
- */
-export function transformSource(code, coreSpecifier, runtimeSpecifier) {
-    const spec = escapeRegExp(coreSpecifier);
-    // Match a named import of `component` (alone or among others) from core.
-    const importRe = new RegExp(`import\\s*\\{([^}]*)\\}\\s*from\\s*['"]${spec}['"]`, 'g');
-    let importsComponent = false;
-    const rewritten = code.replace(importRe, (_full, names) => {
-        const parts = names.split(',').map((s) => s.trim()).filter(Boolean);
-        const next = parts.map((p) => {
-            // Handle `component` and `component as X` — we only wrap the bare name.
-            if (p === 'component') {
-                importsComponent = true;
-                return 'component as __nisliRealComponent';
-            }
-            return p;
-        });
-        return `import { ${next.join(', ')} } from '${coreSpecifier}'`;
-    });
-    if (!importsComponent)
-        return code;
-    // Prepend the registry-import + wrapper. `__register` returns the STABLE
-    // thunk the real component captures; the wrapper preserves the factory's
-    // return value and signature.
-    const preamble = `import { __register as __nisliRegister } from '${runtimeSpecifier}';\n` +
-        `function component(tag, setup, opts) {\n` +
-        `  return __nisliRealComponent(tag, __nisliRegister(tag, setup), opts);\n` +
-        `}\n`;
-    return preamble + rewritten;
-}
-//# sourceMappingURL=transform.js.map

package/dist/hmr/transform.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transform.js","sourceRoot":"","sources":["../../src/hmr/transform.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,SAAS,YAAY,CAAC,CAAS;IAC7B,OAAO,CAAC,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,aAAqB,EAAE,gBAAwB;IAC3F,MAAM,IAAI,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;IACzC,yEAAyE;IACzE,MAAM,QAAQ,GAAG,IAAI,MAAM,CAAC,0CAA0C,IAAI,MAAM,EAAE,GAAG,CAAC,CAAC;IAEvF,IAAI,gBAAgB,GAAG,KAAK,CAAC;IAC7B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAa,EAAE,KAAa,EAAE,EAAE;QACxE,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACpE,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC3B,wEAAwE;YACxE,IAAI,CAAC,KAAK,WAAW,EAAE,CAAC;gBACtB,gBAAgB,GAAG,IAAI,CAAC;gBACxB,OAAO,mCAAmC,CAAC;YAC7C,CAAC;YACD,OAAO,CAAC,CAAC;QACX,CAAC,CAAC,CAAC;QACH,OAAO,YAAY,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,aAAa,GAAG,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,gBAAgB;QAAE,OAAO,IAAI,CAAC;IAEnC,yEAAyE;IACzE,yEAAyE;IACzE,8BAA8B;IAC9B,MAAM,QAAQ,GACZ,kDAAkD,gBAAgB,MAAM;QACxE,0CAA0C;QAC1C,0EAA0E;QAC1E,KAAK,CAAC;IAER,OAAO,QAAQ,GAAG,SAAS,CAAC;AAC9B,CAAC"}