effectweb 0.1.0

package/dist/tasks.d.ts

@@ -0,0 +1,69 @@
+import { Effect } from 'effect';
+import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
+import type { View } from './dom.js';
+import { type Send, type RunningProgram } from './program.js';
+import { type UiRuntime } from './runtime.js';
+export interface TaskDefinition<Model, Input, A, E, R = never> {
+    readonly policy: 'drop' | 'replace';
+    readonly run: (model: Model, input: Input) => Effect.Effect<A, E, R>;
+    /** Domain identity, compared after fields or props change. Resets this slot only. */
+    readonly identity?: (model: Model) => unknown;
+}
+type Definitions<Model, R> = Record<string, TaskDefinition<Model, never, unknown, unknown, R>>;
+type AnyDefinitions = Definitions<never, unknown>;
+type Input<T extends AnyDefinitions[string]> = Parameters<T['run']> extends [unknown, infer I, ...unknown[]] ? I : void;
+export type TaskResults<T extends AnyDefinitions> = {
+    readonly [K in keyof T]: AsyncResult.AsyncResult<Effect.Success<ReturnType<T[K]['run']>>, Effect.Error<ReturnType<T[K]['run']>>>;
+};
+export type TasksModel<Props, State, T extends AnyDefinitions> = State & {
+    readonly props: Props;
+    readonly tasks: TaskResults<T>;
+};
+export type TasksMessage<State, T extends AnyDefinitions> = {
+    readonly type: 'Fields';
+    readonly fields: Partial<State> & {
+        readonly props?: never;
+        readonly tasks?: never;
+    };
+} | {
+    readonly type: 'Cancel' | 'Reset';
+    readonly task: keyof T;
+} | {
+    [K in keyof T]: {
+        readonly type: 'Run';
+        readonly task: K;
+        readonly input: Input<T[K]>;
+    };
+}[keyof T];
+type Init<Props, State> = {
+    init: (props: Props) => State & {
+        readonly props?: never;
+        readonly tasks?: never;
+    };
+    /** Changing the component entity also resets editable fields and all its tasks. */
+    identity?: (props: Props) => unknown;
+    name?: string;
+};
+export declare function defineTasks<Props, State extends object, R>(definition: Init<Props, State> & {
+    runtime: UiRuntime<R>;
+}): ReturnType<typeof taskBuilder<Props, State, R>>;
+export declare function defineTasks<Props, State extends object>(definition: Init<Props, State>): ReturnType<typeof taskBuilder<Props, State, never>>;
+declare function taskBuilder<Props, State extends object, R>(definition: Init<Props, State>, runtime: UiRuntime<R>): {
+    tasks<T extends Definitions<State & {
+        readonly props: Props;
+    }, R>>(definitions: T): {
+        create: (props: Props) => RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>;
+        receive: (source: RunningProgram<TasksModel<Props, State, T>, TasksMessage<State, T>>, props: Props) => void;
+        controls: (send: Send<TasksMessage<State, T>>) => {
+            run: <K extends keyof T>(task: K, ...input: Input<T[K]> extends void ? [input?: Input<T[K]>] : [input: Input<T[K]>]) => void;
+            patch: (fields: Partial<State> & {
+                readonly props?: never;
+                readonly tasks?: never;
+            }) => void;
+            cancel: (task: keyof T) => void;
+            reset: (task: keyof T) => void;
+        };
+        view: (view: View<TasksModel<Props, State, T>, TasksMessage<State, T>>) => View<Props, never>;
+    };
+};
+export {};

package/dist/tasks.js

@@ -0,0 +1,126 @@
+import { Effect, Option } from 'effect';
+import * as AsyncResult from 'effect/unstable/reactivity/AsyncResult';
+import { programView } from './component.js';
+import { effectCommand, program } from './program.js';
+import { defaultUiRuntime } from './runtime.js';
+import { patchModel } from './state.js';
+export function defineTasks(definition) {
+    return taskBuilder(definition, definition.runtime ?? defaultUiRuntime);
+}
+function stopWaiting(result) {
+    if (!result.waiting)
+        return result;
+    if (AsyncResult.isInitial(result))
+        return AsyncResult.initial();
+    if (AsyncResult.isSuccess(result))
+        return AsyncResult.success(result.value);
+    return AsyncResult.failureWithPrevious(result.cause, { previous: Option.some(result) });
+}
+function taskBuilder(definition, runtime) {
+    return {
+        tasks(definitions) {
+            const names = Object.keys(definitions);
+            const slot = (name) => `task:${String(name)}`;
+            const initialResults = () => Object.fromEntries(names.map((name) => [name, AsyncResult.initial()]));
+            const init = (props) => ({
+                ...definition.init(props),
+                props,
+                tasks: initialResults(),
+            });
+            const withResult = (model, task, result) => ({ ...model, tasks: { ...model.tasks, [task]: result } });
+            const resetIdentities = (before, model) => {
+                const cancel = [];
+                for (const name of names) {
+                    const identity = definitions[name].identity;
+                    if (identity && !Object.is(identity(before), identity(model))) {
+                        model = withResult(model, name, AsyncResult.initial());
+                        cancel.push(slot(name));
+                    }
+                }
+                return { model, cancel };
+            };
+            const owners = new WeakMap();
+            const create = (props) => {
+                const source = program({
+                    initial: init(props),
+                    ...(definition.name ? { name: definition.name } : {}),
+                    update: (model, message) => {
+                        switch (message.type) {
+                            case 'Input':
+                                if (definition.identity &&
+                                    !Object.is(definition.identity(model.props), definition.identity(message.props)))
+                                    return { model: init(message.props), cancel: names.map(slot) };
+                                return resetIdentities(model, { ...model, props: message.props });
+                            case 'Fields': {
+                                const next = patchModel(model, message.fields);
+                                return resetIdentities(model, next === model ? model : { ...next, props: model.props, tasks: model.tasks });
+                            }
+                            case 'Run': {
+                                const task = definitions[message.task];
+                                const previous = model.tasks[message.task];
+                                if (task.policy === 'drop' && previous.waiting)
+                                    return { model };
+                                return {
+                                    model: withResult(model, message.task, AsyncResult.waiting(previous)),
+                                    commands: [
+                                        effectCommand(slot(message.task), () => runtime.provide(task.run(model, message.input)), {
+                                            onSuccess: (value) => ({
+                                                type: 'Settled',
+                                                task: message.task,
+                                                result: AsyncResult.success(value),
+                                            }),
+                                            onFailure: (cause) => ({
+                                                type: 'Settled',
+                                                task: message.task,
+                                                result: AsyncResult.failureWithPrevious(cause, {
+                                                    previous: Option.some(previous),
+                                                }),
+                                            }),
+                                        }),
+                                    ],
+                                };
+                            }
+                            case 'Cancel':
+                                return {
+                                    model: withResult(model, message.task, stopWaiting(model.tasks[message.task])),
+                                    cancel: [slot(message.task)],
+                                };
+                            case 'Reset':
+                                return {
+                                    model: withResult(model, message.task, AsyncResult.initial()),
+                                    cancel: [slot(message.task)],
+                                };
+                            case 'Settled':
+                                return { model: withResult(model, message.task, message.result) };
+                        }
+                    },
+                });
+                const exposed = { ...source, send: source.send };
+                owners.set(exposed, source);
+                return exposed;
+            };
+            const receive = (source, props) => {
+                const owner = owners.get(source);
+                if (!owner)
+                    throw new Error('Task source belongs to a different definition');
+                owner.send({ type: 'Input', props });
+            };
+            const controls = (send) => ({
+                run: (task, ...input) => send({ type: 'Run', task, input: input[0] }),
+                patch: (fields) => send({ type: 'Fields', fields }),
+                cancel: (task) => send({ type: 'Cancel', task }),
+                reset: (task) => send({ type: 'Reset', task }),
+            });
+            return {
+                create,
+                receive,
+                controls,
+                view: (view) => programView({
+                    create,
+                    receive: (source, props) => receive(source, props),
+                    view,
+                }),
+            };
+        },
+    };
+}

package/dist/testing.d.ts

@@ -0,0 +1,26 @@
+import { Effect } from 'effect';
+import type { RunningProgram } from './program.js';
+import { type UiRuntime } from './runtime.js';
+/** Drive the real queue. Test services and TestClock effects use the same supplied context. */
+export declare function programDriver<M, Msg>(source: RunningProgram<M, Msg>): ReturnType<typeof makeDriver<M, Msg, never>>;
+export declare function programDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): ReturnType<typeof makeDriver<M, Msg, R>>;
+declare function makeDriver<M, Msg, R>(source: RunningProgram<M, Msg>, runtime: UiRuntime<R>): {
+    model: () => M;
+    send: import("./program.js").Send<Msg>;
+    subscribe: (listener: (model: M) => void) => () => void;
+    dispose: () => void;
+    activeSlots: () => readonly string[];
+    awaitSlot: (slot: string) => Promise<void>;
+    awaitIdle: () => Promise<void>;
+    run: <A, E>(effect: Effect.Effect<A, E, R>) => Promise<A>;
+};
+/** A reusable controlled request, with cancellation visible to tests. No renderer or private messages. */
+export declare function controlledEffect<A, E = never>(): {
+    effect: Effect.Effect<A, E, never>;
+    pending: () => number;
+    canceled: () => number;
+    succeed: (value: A) => void;
+    fail: (error: E) => void;
+    die: (defect: unknown) => void;
+};
+export {};

package/dist/testing.js

@@ -0,0 +1,44 @@
+import { Cause, Effect } from 'effect';
+import { defaultUiRuntime } from './runtime.js';
+export function programDriver(source, runtime) {
+    return makeDriver(source, runtime ?? defaultUiRuntime);
+}
+function makeDriver(source, runtime) {
+    return {
+        model: source.model,
+        send: source.send,
+        subscribe: source.subscribe,
+        dispose: source.dispose,
+        activeSlots: source.activeSlots,
+        awaitSlot: (slot) => source.awaitIdle(slot),
+        awaitIdle: () => source.awaitIdle(),
+        run: (effect) => Effect.runPromise(runtime.provide(effect)),
+    };
+}
+/** A reusable controlled request, with cancellation visible to tests. No renderer or private messages. */
+export function controlledEffect() {
+    const pending = new Set();
+    let canceled = 0;
+    const effect = Effect.callback((resume) => {
+        pending.add(resume);
+        return Effect.sync(() => {
+            pending.delete(resume);
+            canceled++;
+        });
+    });
+    const settle = (result) => {
+        const resume = pending.values().next().value;
+        if (!resume)
+            throw new Error('No controlled request is pending');
+        pending.delete(resume);
+        resume(result);
+    };
+    return {
+        effect,
+        pending: () => pending.size,
+        canceled: () => canceled,
+        succeed: (value) => settle(Effect.succeed(value)),
+        fail: (error) => settle(Effect.fail(error)),
+        die: (defect) => settle(Effect.failCause(Cause.die(defect))),
+    };
+}

package/package.json

@@ -0,0 +1,137 @@
+{
+  "name": "effectweb",
+  "version": "0.1.0",
+  "description": "Immutable Effect models and compiled JSX with direct DOM rendering",
+  "homepage": "https://github.com/DerpyCrabs/EffectWeb",
+  "bugs": {
+    "url": "https://github.com/DerpyCrabs/EffectWeb/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DerpyCrabs/EffectWeb.git",
+    "directory": "packages/runtime"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.js"
+    },
+    "./collection": {
+      "types": "./dist/collection.d.ts",
+      "import": "./dist/collection.js"
+    },
+    "./program": {
+      "types": "./dist/program.d.ts",
+      "import": "./dist/program.js"
+    },
+    "./dom": {
+      "types": "./dist/dom.d.ts",
+      "import": "./dist/dom.js"
+    },
+    "./jsx": {
+      "types": "./dist/jsx.d.ts",
+      "import": "./dist/jsx.js"
+    },
+    "./component": {
+      "types": "./dist/component.d.ts",
+      "import": "./dist/component.js"
+    },
+    "./mount": {
+      "types": "./dist/mount.d.ts",
+      "import": "./dist/mount.js"
+    },
+    "./pages": {
+      "types": "./dist/pages.d.ts",
+      "import": "./dist/pages.js"
+    },
+    "./share": {
+      "types": "./dist/share.d.ts",
+      "import": "./dist/share.js"
+    },
+    "./load": {
+      "types": "./dist/load.d.ts",
+      "import": "./dist/load.js"
+    },
+    "./errors": {
+      "types": "./dist/errors.d.ts",
+      "import": "./dist/errors.js"
+    },
+    "./diagnostics": {
+      "types": "./dist/diagnostics.d.ts",
+      "import": "./dist/diagnostics.js"
+    },
+    "./state": {
+      "types": "./dist/state.d.ts",
+      "import": "./dist/state.js"
+    },
+    "./actions": {
+      "types": "./dist/actions.d.ts",
+      "import": "./dist/actions.js"
+    },
+    "./task": {
+      "types": "./dist/task.d.ts",
+      "import": "./dist/task.js"
+    },
+    "./effectEvent": {
+      "types": "./dist/effectEvent.d.ts",
+      "import": "./dist/effectEvent.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./form": {
+      "types": "./dist/form.d.ts",
+      "import": "./dist/form.js"
+    },
+    "./query": {
+      "types": "./dist/query.d.ts",
+      "import": "./dist/query.js"
+    },
+    "./tasks": {
+      "types": "./dist/tasks.d.ts",
+      "import": "./dist/tasks.js"
+    },
+    "./resource": {
+      "types": "./dist/resource.d.ts",
+      "import": "./dist/resource.js"
+    },
+    "./cache": {
+      "types": "./dist/cache.d.ts",
+      "import": "./dist/cache.js"
+    },
+    "./session": {
+      "types": "./dist/session.d.ts",
+      "import": "./dist/session.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-rc.112"
+  },
+  "engines": {
+    "node": ">=22.14"
+  }
+}