effectweb 0.3.0 → 0.4.0

package/dist/component.js

@@ -1,10 +1,14 @@
-import { compiled, Scope } from './dom.js';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+import { compiled, Scope, viewRegion } from './dom.js';
 import { mapCommand, program } from './program.js';
 import { patchModel } from './state.js';
+import { reportSafely } from './errors.js';
 import { defaultUiRuntime } from './runtime.js';
 /** Local fields with no command lifecycle. Sends are shallow patches, never updater callbacks. */
 export function localComponent(definition) {
     return component({
+        ...(definition.identity ? { identity: definition.identity } : {}),
         init: (props) => ({ ...definition.init(props), props }),
         update: (model, patch) => {
             const next = patchModel(model, patch);
@@ -16,7 +20,7 @@ export function localComponent(definition) {
 /** A child model receives immutable parent inputs and owns its own message/command loop. */
 export function component(definition) {
     const runtime = definition.runtime ?? defaultUiRuntime;
-    return compiled((scope, parent, before) => {
+    return identify(compiled((scope, parent, before) => {
         const wrap = (next) => ({
             model: next.model,
             ...(next.cancel ? { cancel: next.cancel } : {}),
@@ -37,22 +41,81 @@ export function component(definition) {
                 })
                 : definition.update(model, envelope.message)),
         });
-        const child = new Scope(source.model(), (message) => source.send({ type: 'Message', message }), scope.report);
-        scope.cleanups.push(() => source.dispose(), () => child.dispose(), () => unsubscribe());
-        const unsubscribe = source.subscribe((model) => child.set(model));
+        if (scope.disposed) {
+            closeProgram(scope, source);
+            return;
+        }
+        const child = new Scope(source.model(), (message) => source.send({ type: 'Message', message }), scope.report, scope.settlement);
+        let unsubscribe = () => { };
+        scope.cleanups.push(() => closeProgram(scope, source), () => child.dispose(), () => unsubscribe());
+        const release = source.subscribe((model) => child.set(model));
+        if (scope.disposed) {
+            release();
+            return;
+        }
+        unsubscribe = release;
         definition.view.build(child, parent, before);
         scope.jobs.push(() => source.send({ type: 'Input', props: scope.value }));
         source.send({ type: 'Input', props: scope.value });
-    });
+    }), definition.identity);
 }
 /** Mount an existing program without introducing a second state owner. */
 export function programView(definition) {
-    return compiled((scope, parent, before) => {
+    return identify(compiled((scope, parent, before) => {
         const source = definition.create(scope.value);
-        const child = new Scope(source.model(), source.send, scope.report);
-        const unsubscribe = source.subscribe((model) => child.set(model));
-        scope.cleanups.push(() => source.dispose(), () => child.dispose(), () => unsubscribe());
+        if (scope.disposed) {
+            closeProgram(scope, source);
+            return;
+        }
+        const child = new Scope(source.model(), source.send, scope.report, scope.settlement);
+        let unsubscribe = () => { };
+        scope.cleanups.push(() => closeProgram(scope, source), () => child.dispose(), () => unsubscribe());
+        const release = source.subscribe((model) => child.set(model));
+        if (scope.disposed) {
+            release();
+            return;
+        }
+        unsubscribe = release;
         definition.view.build(child, parent, before);
         scope.jobs.push(() => definition.receive(source, scope.value));
+    }), definition.identity);
+}
+function closeProgram(scope, source) {
+    const finish = scope.settlement.begin();
+    try {
+        if (source.close) {
+            Effect.runFork(source.close()).addObserver((exit) => {
+                finish();
+                if (exit._tag === 'Failure')
+                    reportSafely(scope.report, Cause.squash(exit.cause));
+            });
+        }
+        else {
+            source.dispose();
+            finish();
+        }
+    }
+    catch (error) {
+        finish();
+        throw error;
+    }
+}
+function identify(definition, identity) {
+    if (!identity)
+        return definition;
+    return compiled((scope, parent, before) => {
+        const render = viewRegion(scope, parent, before, { manual: true });
+        let current;
+        let active;
+        const update = () => {
+            const next = identity(scope.value);
+            if (!active || !Object.is(current, next)) {
+                current = next;
+                active = compiled(definition.build);
+            }
+            render(active);
+        };
+        scope.jobs.push(update);
+        update();
     });
 }

package/dist/dom.d.ts

@@ -1,11 +1,14 @@
+import * as Effect from 'effect/Effect';
 import type { Snapshot } from './snapshot.js';
 import { type ReportError } from './errors.js';
 import { type BindingSource } from './diagnostics.js';
 import type { Rows } from './index.js';
 import { jsxComponent, type JSX } from './jsx.js';
 import type { DomMount } from './mount.js';
+import { Settlement } from './settlement.js';
 import type { Program, Send } from './program.js';
 type Dependencies = () => readonly unknown[];
+type BindingLocation = BindingSource | (() => BindingSource | undefined);
 type Cleanup = () => void;
 type Build<M, E> = (scope: Scope<M, E>, parent: Node, before: Node | null) => void;
 /** Compiler implementation. No implicit tracking, proxies, or per-binding subscriptions. */
@@ -13,13 +16,12 @@ export declare class Scope<M, E> {
     value: M;
     readonly send: Send<E>;
     readonly report: ReportError;
+    readonly settlement: Settlement;
     readonly jobs: Cleanup[];
     readonly cleanups: Cleanup[];
     disposed: boolean;
-    private revision;
-    constructor(value: M, send: Send<E>, report?: ReportError);
-    derive<A>(dependencies: Dependencies, compute: () => A, source?: BindingSource): () => A;
-    watch(dependencies: Dependencies, apply: () => void, source?: BindingSource): void;
+    constructor(value: M, send: Send<E>, report?: ReportError, settlement?: Settlement);
+    watch(dependencies: Dependencies, apply: () => void, source?: BindingLocation): void;
     set(value: M): void;
     dispose(): void;
 }
@@ -27,8 +29,8 @@ export interface View<M, E> extends JSX.ComponentType {
     (this: never, props: [E] extends [never] ? M | Snapshot<M> : never): JSX.Element;
     readonly build: Build<M, E>;
 }
-/** Compiler marker for mounting a view with an explicit model and message dispatcher. */
-export declare const ViewBinding: (<M, E>(this: never, _props: {
+/** Mount a view with an explicit model and message dispatcher. */
+export declare const ViewBinding: (<M, E>(this: never, props: {
     view: View<M, E>;
     model: NoInfer<M> | Snapshot<NoInfer<M>>;
     send: Send<NoInfer<E>>;
@@ -42,18 +44,22 @@ declare const contentBrand: unique symbol;
 export interface CompiledContent {
     readonly [contentBrand]: true;
 }
-/** A compiled template with a typed placement value, captured in its declaring view. */
+/** An ordinary render callback with a typed input. Invoke it to produce content. */
 export interface Slot<A = void> {
     (value: A | Snapshot<A>): JSX.Element;
-    readonly [contentBrand]: [A] extends [void] ? true : false;
 }
-/** Compiler marker: declare inside view(), or directly in a compiled component prop. */
-export declare function slot<A = void>(_render: (value: Snapshot<A>) => JSX.Element): Slot<A>;
-/** Compiler output. Captures follow their declaring scope; placements own independent scopes. */
-export declare function compiledSlot<M, E, A>(owner: Scope<M, E>, build: Build<A, E>): Slot<A>;
-/** This declaration is a compiler marker, never a component setup callback. */
-export declare function view<M, E = never>(_render: (model: Snapshot<M>, send: Send<E>) => JSX.Element): View<M, E>;
+export declare function slot<A = void>(render: (value: Snapshot<A>) => JSX.Element): Slot<A>;
+/** Evaluate ordinary synchronous JavaScript for each immutable model publication. */
+export declare function view<M, E = never>(render: (model: Snapshot<M>, send: Send<E>) => JSX.Element): View<M, E>;
 export declare function compiled<M, E>(build: Build<M, E>): View<M, E>;
+type MarkupProps = Readonly<Record<string, unknown>> & {
+    readonly children?: JSX.Element;
+};
+/** JSX factories preserve host identity by element type; source locations are metadata only. */
+export declare function markup(tag: string, sources?: Readonly<Record<string, BindingSource>>): (props: MarkupProps) => JSX.Element;
+export declare function renderComponent(component: (props: never) => JSX.Element, props: Readonly<Record<string, unknown>>): JSX.Element;
+/** Preserve collection identity (or array reference identity) while rendering rows. */
+export declare function list<A>(rows: Rows<A> | readonly A[], render: (item: A, index: number) => JSX.Element): JSX.Element;
 export interface PortalProps {
     readonly children?: JSX.Element;
     readonly mount?: Element | undefined;
@@ -62,25 +68,30 @@ export interface PortalProps {
 export declare const Portal: View<PortalProps, never>;
 export declare function mountView<M, E>(parent: Node, definition: View<M, E>, source: Program<M, E>, options?: {
     onError?: ReportError;
-}): () => void;
+}): (() => void) & {
+    dispose: () => void;
+    close: () => Effect.Effect<void, never, never>;
+};
 export declare function element(parent: Node, before: Node | null, tag: string): Element;
 export declare function attribute(element: Element, name: string, value: unknown): void;
 /** Compiler output for attributes whose unchanged value needs no DOM refresh. */
-export declare function bindAttribute<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
+export declare function bindAttribute<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingLocation): void;
 /** Handled edits can change a control even when dispatch publishes no new model. */
-export declare function bindControl<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
-export declare function text<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => unknown, source?: BindingSource): void;
-export declare function event<M, E>(scope: Scope<M, E>, element: Element, name: string, handler: (event: Event) => unknown): void;
-/** One handler identity owns its requests, regardless of the JSX attribute spelling. */
-export declare function bindEvent<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown): void;
+export declare function bindControl<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => unknown, source?: BindingLocation): void;
+export declare function text<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => JSX.Element, source?: BindingLocation): void;
+export declare function event<M, E>(scope: Scope<M, E>, element: Element, name: string, handler: (event: Event) => JSX.EventResult): void;
+/** The event binding owns its requests; snapshot renders may replace its callback. */
+export declare function bindEvent<M, E>(scope: Scope<M, E>, element: Element, name: string, dependencies: Dependencies, read: () => ((event: Event) => JSX.EventResult) | undefined): void;
 /** Reconcile merged JSX attributes. Each host, event and control owns its cleanup. */
-export declare function bindAttributes<M, E>(scope: Scope<M, E>, element: Element, dependencies: Dependencies, read: () => Readonly<Record<string, unknown>>): void;
+export declare function bindAttributes<M, E>(scope: Scope<M, E>, element: Element, dependencies: Dependencies, read: () => Readonly<Record<string, unknown>>, sources?: () => Readonly<Record<string, BindingSource>> | undefined): void;
 export declare function branch<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, choose: () => boolean, yes: Build<M, E>, no: Build<M, E>): void;
 export declare function each<M, E, A>(scope: Scope<M, E>, parent: Node, before: Node | null, read: () => Rows<A> | readonly A[], outer: Dependencies, indexUsed: boolean, build: Build<readonly [A, number], E>): void;
-export declare function invoke<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, dependencies: Dependencies, read: () => readonly unknown[], build: Build<readonly unknown[], E>): void;
 export declare function child<M, E, C, F>(scope: Scope<M, E>, parent: Node, before: Node | null, definition: View<C, F>, dependencies: Dependencies, model: () => C, send: Send<F>): void;
 /** A late-bound compiled definition owns one replaceable DOM region. */
-export declare function viewRegion<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null): (next: View<M, E> | undefined) => void;
+export declare function viewRegion<M, E>(scope: Scope<M, E>, parent: Node, before: Node | null, options?: {
+    manual?: boolean;
+    report?: ReportError;
+}): (next: View<M, E> | undefined) => void;
 export declare function attach<M, E, T extends Element>(scope: Scope<M, E>, element: T, dependencies: Dependencies, read: () => DomMount<NoInfer<T>> | undefined): void;
 export declare function portal<M, E>(scope: Scope<M, E>, build: Build<M, E>, mount?: () => Element | undefined): void;
 /** Build static markup once per document/namespace, then clone native nodes at each use. */