@nisli/core 0.43.0

package/README.md

@@ -0,0 +1,100 @@
+# nisli
+
+A reactive web component framework. Signals, templates, dependency injection — no build step, no virtual DOM, no dependencies.
+
+## Install
+
+```bash
+npm install @nisli/core
+```
+
+## Quick Start
+
+```typescript
+import { signal, component, html } from '@nisli/core';
+
+const Counter = component('x-counter', () => {
+  const count = signal(0);
+  return html`
+    <button @click=${() => count.set(count() + 1)}>
+      Count: ${count}
+    </button>
+  `;
+});
+```
+
+## Features
+
+- **Signals** — Fine-grained reactivity with `signal`, `computed`, `effect`
+- **Components** — Web Components with a composition-style setup function
+- **Templates** — Tagged template literals with automatic signal binding
+- **Dependency Injection** — `inject` any class as a singleton, `provide` overrides for testing
+- **Queries** — Declarative async data loading with caching and auto-refetch
+- **Event Emitters** — Typed event bus with auto-disposal in component context
+- **Lifecycle** — `onMount`, `onCleanup`, `useHostEvent`
+- **Refs** — Direct element access via `ref()`
+- **Control Flow** — `when()` for toggles, `each()` for keyed list rendering
+
+## API
+
+```typescript
+// Reactivity
+signal(value)           // Reactive signal
+computed(() => expr)    // Derived signal (lazy, cached)
+effect(() => { ... })   // Side effect that tracks dependencies
+
+// Components
+component('tag-name', (props, host) => html`...`)
+component<Props>('tag-name', { props: [...] }, (props, host) => html`...`)
+
+// Templates — signals are implicit, no .value needed
+html`<div>${count}</div>`
+html`<button @click=${handler}>Go</button>`
+html`<div class:active=${isActive}>...</div>`
+
+// Control flow
+when(condition, () => html`...`)
+each(items, item => item.id, (item) => html`...`)
+
+// Dependency injection — class IS the token
+inject(MyService)                    // Auto-creates singleton
+provide(MyService, () => mock)       // Override (testing)
+
+// Queries
+const { data, loading, error } = query(
+  () => ['tasks', id.value],         // Cache key (tracked)
+  () => api.getTasks(id.value),      // Fetcher
+)
+
+// Lifecycle
+onMount(() => { ... })
+onCleanup(() => { ... })
+useHostEvent('click', handler)
+
+// Refs
+const el = ref<HTMLDivElement>()
+html`<div ${el}>...</div>`
+
+// Events
+class Nav extends Emitter<{ select: { id: string } }> {}
+inject(Nav).emit('select', { id })
+inject(Nav).on('select', ({ id }) => { ... })
+```
+
+## Size
+
+~2,600 lines of TypeScript. Zero dependencies.
+
+## Inspiration
+
+nisli stands on the shoulders of giants:
+
+- [React](https://react.dev) — Component model, declarative UI
+- [Solid](https://www.solidjs.com) — Signals, fine-grained reactivity, no virtual DOM
+- [Lit](https://lit.dev) — Web Components, tagged template literals
+- [Angular](https://angular.dev) — Dependency injection, typed tokens
+- [Vue](https://vuejs.org) — Composition-style setup functions, reactive system design
+
+## License
+
+MIT

package/dist/component.d.ts

@@ -0,0 +1,75 @@
+/**
+ * component.ts — Web component shell with typed props and factory composition
+ *
+ * `component()` is the single entry point for defining components.
+ * It registers a custom element and returns a typed factory function.
+ *
+ * Component authors write a setup function that receives typed props
+ * (each wrapped as a Signal) and optionally the host element.
+ * The setup function returns a TemplateResult from html`...`.
+ *
+ * The class internals (connectedCallback, etc.) are completely hidden.
+ */
+import { type Signal, type ReadonlySignal } from './signal.js';
+import type { TemplateResult } from './template.js';
+/**
+ * Maps a props interface to reactive signals.
+ * Each prop `P[K]` becomes `Signal<P[K]>`.
+ */
+export type ReactiveProps<P> = {
+    readonly [K in keyof P]: Signal<P[K]>;
+};
+/**
+ * The setup function signature. Receives reactive props and host element.
+ * Returns a TemplateResult to be mounted into the component.
+ */
+export type SetupFunction<P> = (props: ReactiveProps<P>, host: HTMLElement) => TemplateResult;
+/**
+ * Accepts either a Signal<T> (reactive) or a plain T (static, auto-wrapped).
+ * This eliminates the need to wrap static values in `signal()` at call sites.
+ * See ADR 0009 Gap 4.
+ */
+export type PropInput<T> = T | Signal<T> | ReadonlySignal<T>;
+/**
+ * Host-level attributes that every factory accepts, independent of component props.
+ * `class` is applied to the host element via classList — it does not collide with
+ * the component's own class attribute or class:name directives.
+ * See ADR 0009 Gap 3.
+ */
+export interface HostAttrs {
+    class?: PropInput<string>;
+}
+/**
+ * A factory function for type-safe component composition.
+ * Props accept both Signal<T> (reactive) and plain T (static, auto-wrapped).
+ * An optional second argument provides host-level attributes (class).
+ */
+export type ComponentFactory<P> = (props: {
+    [K in keyof P]: PropInput<P[K]>;
+}, hostAttrs?: HostAttrs) => TemplateResult;
+/** Options for component() registration */
+export interface ComponentOptions {
+    /** Custom error fallback renderer */
+    onError?: (error: Error, host: HTMLElement) => TemplateResult | string;
+}
+/**
+ * Define a web component with typed props and a setup function.
+ *
+ * Returns a typed factory function for compile-time-safe composition.
+ *
+ * ```ts
+ * interface TaskItemProps {
+ *   task: Task;
+ *   selected: boolean;
+ * }
+ *
+ * const TaskItem = component<TaskItemProps>('task-item', (props, host) => {
+ *   const title = computed(() => props.task.value.title);
+ *   return html`<div>${title}</div>`;
+ * });
+ *
+ * // Factory usage:
+ * TaskItem({ task: taskSignal, selected: isSelected })
+ * ```
+ */
+export declare function component<P extends Record<string, unknown> = Record<string, never>>(tagName: string, setup: SetupFunction<P>, options?: ComponentOptions): ComponentFactory<P>;

package/dist/component.js

@@ -0,0 +1,260 @@
+/**
+ * component.ts — Web component shell with typed props and factory composition
+ *
+ * `component()` is the single entry point for defining components.
+ * It registers a custom element and returns a typed factory function.
+ *
+ * Component authors write a setup function that receives typed props
+ * (each wrapped as a Signal) and optionally the host element.
+ * The setup function returns a TemplateResult from html`...`.
+ *
+ * The class internals (connectedCallback, etc.) are completely hidden.
+ */
+import { signal, effect, setContextHook, isSignal, untrack } from './signal.js';
+import { runWithContext, hasContext, getCurrentComponent } from './context.js';
+import { runMountCallbacks } from './lifecycle.js';
+// Wire up effect auto-disposal: when effect() is called during component setup,
+// auto-register the dispose function with the component host.
+setContextHook(() => {
+    if (hasContext()) {
+        const comp = getCurrentComponent();
+        return (disposer) => comp.addDisposer(disposer);
+    }
+    return null;
+});
+// ── Internal component host ─────────────────────────────────────────
+class ComponentHostImpl {
+    element;
+    disposers = [];
+    setupComplete = false;
+    constructor(element) {
+        this.element = element;
+    }
+    addDisposer(fn) {
+        this.disposers.push(fn);
+    }
+    dispose() {
+        for (const fn of this.disposers) {
+            try {
+                fn();
+            }
+            catch (_) { /* swallow disposal errors */ }
+        }
+        this.disposers.length = 0;
+    }
+}
+// ── Prop signal management via Proxy ────────────────────────────────
+/**
+ * Creates a Proxy-based props object that lazily creates signals
+ * for each property on first access. When a parent sets a property
+ * on the element, the Proxy intercepts it and updates (or creates)
+ * the backing signal.
+ */
+function createPropsProxy() {
+    const signals = new Map();
+    const getOrCreate = (key, initialValue) => {
+        let s = signals.get(key);
+        if (!s) {
+            s = signal(initialValue);
+            signals.set(key, s);
+        }
+        return s;
+    };
+    const props = new Proxy({}, {
+        get(_target, key) {
+            return getOrCreate(key);
+        },
+    });
+    const setProperty = (key, value) => {
+        const s = getOrCreate(key, value);
+        s.value = value;
+    };
+    return { props, setProperty };
+}
+// ── component() — the main entry point ──────────────────────────────
+/**
+ * Define a web component with typed props and a setup function.
+ *
+ * Returns a typed factory function for compile-time-safe composition.
+ *
+ * ```ts
+ * interface TaskItemProps {
+ *   task: Task;
+ *   selected: boolean;
+ * }
+ *
+ * const TaskItem = component<TaskItemProps>('task-item', (props, host) => {
+ *   const title = computed(() => props.task.value.title);
+ *   return html`<div>${title}</div>`;
+ * });
+ *
+ * // Factory usage:
+ * TaskItem({ task: taskSignal, selected: isSelected })
+ * ```
+ */
+export function component(tagName, setup, options) {
+    // The custom element class
+    class FrameworkComponent extends HTMLElement {
+        _host = null;
+        _propsProxy = null;
+        _mounted = false;
+        _templateResult = null;
+        constructor() {
+            super();
+            this._propsProxy = createPropsProxy();
+        }
+        connectedCallback() {
+            if (this._mounted)
+                return; // guard against re-connection
+            this._mounted = true;
+            // Isolate activeObserver: child component setup signal reads must NOT
+            // leak into a parent effect's dependency set. Without this, a parent
+            // effect running replaceChildren/appendChild triggers child
+            // connectedCallback synchronously, and child signal reads would be
+            // tracked as parent dependencies — causing infinite re-render loops.
+            // See ADR 0008 Gap 1 / ADR 0009.
+            untrack(() => {
+                const host = new ComponentHostImpl(this);
+                this._host = host;
+                try {
+                    runWithContext(host, () => {
+                        this._templateResult = setup(this._propsProxy.props, this);
+                    });
+                    // Mount the template result
+                    if (this._templateResult) {
+                        mountTemplate(this, this._templateResult, host);
+                    }
+                    // Run onMount() callbacks — DOM is now committed
+                    runMountCallbacks(host);
+                }
+                catch (err) {
+                    const error = err instanceof Error ? err : new Error(String(err));
+                    console.error(`Component <${tagName}> setup error:`, error);
+                    if (options?.onError) {
+                        try {
+                            const fallback = options.onError(error, this);
+                            if (typeof fallback === 'string') {
+                                this.innerHTML = fallback;
+                            }
+                            else {
+                                mountTemplate(this, fallback);
+                            }
+                        }
+                        catch (_) {
+                            this.innerHTML = `<div style="color:red;padding:4px">Error in &lt;${tagName}&gt;</div>`;
+                        }
+                    }
+                    else {
+                        this.innerHTML = `<div style="color:red;padding:4px">Error in &lt;${tagName}&gt;</div>`;
+                    }
+                }
+            });
+        }
+        disconnectedCallback() {
+            this._mounted = false;
+            if (this._templateResult?.dispose) {
+                this._templateResult.dispose();
+            }
+            if (this._host) {
+                this._host.dispose();
+                this._host = null;
+            }
+        }
+        /**
+         * Set a prop value. Called by the factory and by direct property assignment.
+         * The Proxy intercepts and creates/updates backing signals.
+         */
+        _setProp(key, value) {
+            this._propsProxy?.setProperty(key, value);
+        }
+    }
+    // Register the custom element (if not already registered)
+    if (!customElements.get(tagName)) {
+        customElements.define(tagName, FrameworkComponent);
+    }
+    // Return the typed factory function
+    const factory = (props, hostAttrs) => {
+        return {
+            __type: 'factory',
+            tagName,
+            props: props,
+            hostAttrs,
+        };
+    };
+    return factory;
+}
+/**
+ * Ensure a value is a signal. If it already is, return as-is.
+ * If it's a plain value, wrap it in signal().
+ * Used by factory mount to support PropInput<T> = T | Signal<T>.
+ */
+function ensureSignal(value) {
+    if (isSignal(value))
+        return value;
+    return signal(value);
+}
+/**
+ * Mount a TemplateResult into a host element.
+ * This is the bridge between component.ts and template.ts.
+ * Template.ts will provide the actual implementation via the
+ * TemplateResult.mount() method.
+ *
+ * @param hostImpl — optional ComponentHostImpl for registering disposers
+ */
+function mountTemplate(host, result, hostImpl) {
+    if (result && typeof result === 'object' && 'mount' in result && typeof result.mount === 'function') {
+        result.mount(host);
+    }
+    else if (result && typeof result === 'object' && '__type' in result) {
+        // Factory result — create the child element
+        const factoryResult = result;
+        const el = document.createElement(factoryResult.tagName);
+        // Forward props as signals (auto-wrap plain values)
+        for (const [key, raw] of Object.entries(factoryResult.props)) {
+            const sig = ensureSignal(raw);
+            el._setProp(key, sig.value);
+            // Subscribe to signal changes to update the child's props
+            const unsub = sig.subscribe((newVal) => {
+                el._setProp(key, newVal);
+            });
+            // Register unsub for cleanup on disconnect
+            if (hostImpl) {
+                hostImpl.addDisposer(unsub);
+            }
+        }
+        // Apply host-level attributes (class)
+        if (factoryResult.hostAttrs?.class != null) {
+            const classSig = ensureSignal(factoryResult.hostAttrs.class);
+            // Apply initial value
+            applyHostClass(el, '', classSig.value);
+            // Subscribe to reactive changes
+            let prevClass = classSig.value;
+            const unsub = classSig.subscribe((newClass) => {
+                applyHostClass(el, prevClass, newClass);
+                prevClass = newClass;
+            });
+            if (hostImpl) {
+                hostImpl.addDisposer(unsub);
+            }
+        }
+        host.appendChild(el);
+    }
+}
+/**
+ * Apply a class string to an element via classList, replacing the previous
+ * class string's classes. Uses add/remove to avoid interfering with classes
+ * set by the component's own template (class:name directives, etc.).
+ */
+function applyHostClass(el, prev, next) {
+    const prevClasses = prev ? prev.split(/\s+/).filter(Boolean) : [];
+    const nextClasses = next ? next.split(/\s+/).filter(Boolean) : [];
+    for (const cls of prevClasses) {
+        if (!nextClasses.includes(cls))
+            el.classList.remove(cls);
+    }
+    for (const cls of nextClasses) {
+        if (!prevClasses.includes(cls))
+            el.classList.add(cls);
+    }
+}
+//# sourceMappingURL=component.js.map

package/dist/component.js.map

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

package/dist/context.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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().
+ */
+/**
+ * Minimal interface for a component host. component.ts provides the
+ * full implementation; this file only needs the disposal hook.
+ */
+export interface ComponentHost {
+    /** Register a cleanup function to run on disconnectedCallback */
+    addDisposer(fn: () => void): void;
+    /** The raw HTMLElement */
+    element: HTMLElement;
+}
+/**
+ * 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 declare function runWithContext(component: ComponentHost, fn: () => void): void;
+/**
+ * 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 declare function getCurrentComponent(): ComponentHost;
+/**
+ * Check if there is an active setup context.
+ * Returns true during component setup, false otherwise.
+ */
+export declare function hasContext(): boolean;

package/dist/context.js

@@ -0,0 +1,55 @@
+/**
+ * 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

@@ -0,0 +1 @@
+{"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/emitter.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { type Signal } from './signal.js';
+type EventMap = Record<string, unknown>;
+type Listener<T> = (payload: T) => void;
+export declare class Emitter<Events extends EventMap> {
+    private listeners;
+    /**
+     * Emit a typed event. All subscribers for this event name are called
+     * synchronously. If a subscriber throws, other subscribers still fire.
+     */
+    emit<K extends keyof Events>(event: K, payload: Events[K]): void;
+    /**
+     * Subscribe to a typed event. Returns an unsubscribe function.
+     *
+     * If called during component setup, the subscription is automatically
+     * disposed on disconnectedCallback.
+     */
+    on<K extends keyof Events>(event: K, fn: Listener<Events[K]>): () => void;
+    /**
+     * 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<K extends keyof Events, V>(event: K, selector: (payload: Events[K]) => V, initial: V): Signal<V>;
+    /**
+     * Remove all subscribers. Useful for testing cleanup.
+     */
+    clear(): void;
+}
+export {};