@reactivescript/runtime 0.0.0-stage → 0.1.0

package/dist/types/rt-web.d.ts

@@ -0,0 +1,186 @@
+import { createContext, flush, getOwner } from "solid-js";
+export { flush };
+export type Acc = () => unknown;
+export type Writer = {
+    set: (v: unknown) => void;
+    path: (keys: (string | number)[], v: unknown) => void;
+    guess: (v: unknown, keys?: (string | number)[]) => void;
+};
+export type Entry = {
+    get?: Acc;
+    w?: Writer;
+    value?: unknown;
+};
+export declare const ERR: {
+    toString: () => string;
+};
+export declare const PENDING_MARK: {
+    toString: () => string;
+};
+export declare const fmt: (v: unknown) => string;
+type ErrorClass = ((...args: unknown[]) => Error) & {
+    cls: new (...args: unknown[]) => Error;
+    errorClass: string;
+};
+/** `e catch (x: C) => alt`, reactive: an error boundary around the read whose fallback is the value (Solid: an errored read
+ *  reaches the nearest boundary even inside a JS `try`). The fallback is decided when read, so a change of class re-decides it. */
+declare function catchAcc(f: () => unknown, match: (err: unknown) => boolean, alt: (err: unknown) => unknown): () => unknown;
+/** Imperative scope: an ordinary try. */
+declare function tryCatch(f: () => unknown, match: (err: unknown) => boolean, alt: (err: unknown) => unknown): unknown;
+/** A controllable flight: an async iterable (a stream — each resolve is a landing) that actions await through `first`. */
+export declare class Flight {
+    key: string;
+    first: Promise<unknown>;
+    private settleFirst;
+    private rejectFirst;
+    private queue;
+    private waiters;
+    private started;
+    constructor(key: string);
+    private push;
+    resolve(v: unknown): void;
+    reject(e: unknown): void;
+    [Symbol.asyncIterator](): {
+        next: () => Promise<IteratorResult<unknown>>;
+        return: () => Promise<{
+            value: undefined;
+            done: true;
+        }>;
+    };
+}
+export declare function createApp(opts: {
+    root: any;
+    api?: Record<string, (...a: any[]) => unknown>;
+}): {
+    root: any;
+    log: string[];
+    flights: Map<string, Flight>;
+    lastKey: Map<string, string>;
+    asyncError: unknown;
+    /** Mount `view` on the root: build it, or (SV-3) adopt the page the server streamed into it. */
+    mount(view: () => unknown, hydrating?: boolean): any;
+    B: Record<string, any>;
+    /** `import pure { f } from "./api"`: every function is a flight keyed by its name and formatted arguments. */
+    /** MO-8: a class `api.d.rx` declares as an error: the real module's, or (in the harness) a stand-in `C(message)`. */
+    jsError: (name: string) => unknown;
+    api: (name: string) => (...a: any[]) => unknown;
+    reg(name: string, e: Entry): void;
+    lookup(name: string): Entry;
+    dget(name: string, live?: boolean): any;
+    dset(name: string, keys: (string | number)[], v: unknown, guess?: boolean): void;
+    /** `source x := e`: atomic → a signal; structured → a store behind a signal slot, so the root can be replaced (ST-1, ST-2a). */
+    source(name: string, init: unknown): [Acc, Writer];
+    /** `source x = e` (ST-5): createSignal(fn); with a guess written to it, a createOptimistic layer over that truth (AC-3);
+     *  written or probed by path, createStore(fn, {}) whose derive writes its draft. */
+    question(name: string, compute: (prev: unknown) => unknown, opts: {
+        loadingValue?: unknown;
+    } | undefined, mode: {
+        optimistic: boolean;
+        structured: boolean;
+    }, key?: string): [Acc, Writer];
+    memo: (name: string | null, fn: (prev: unknown) => unknown, opts?: {
+        loadingValue?: unknown;
+    }) => Acc;
+    deferred: (name: string, fn: (prev: unknown) => unknown, opts?: {
+        loadingValue?: unknown;
+    }) => Acc;
+    /** `x key k = e` (ST-4): a keyed projection. */
+    keyed: (name: string, key: string, fn: () => unknown) => Acc;
+    /** `x = draft(pre x -> seed) { … }` (ST-3). */
+    draft: (seed: unknown, body: (d: any) => void) => Acc;
+    /** `pre y` of another node (C-2): a companion memo carrying (current, previous), owned where `y` is declared. */
+    pre: (get: Acc) => Acc;
+    firstPaint: (f: () => unknown) => {
+        loadingValue: any;
+    };
+    /** `effect (…) { … }`: compute, then apply; an error is an answer the apply receives (E-12); fires on a differing value (EF-2); a store enters whole, as a snapshot. */
+    effect(n: number, inputs: () => unknown[], apply: (p: unknown[]) => unknown): void;
+    /** `action f(…) { … }` (AC-1): a generator; a statement-level `await` is a hold-safe yield. */
+    action(gen: (...a: unknown[]) => Generator<unknown, unknown, unknown>): (...a: unknown[]) => Promise<unknown>;
+    awaited: (v: unknown) => unknown;
+    /** RG-8: Solid's Portal — client-only: the server renders nothing for it, the browser renders it once it has the page. */
+    Portal: any;
+    /** CSS-2: a dynamic class with the view's scope class after it. */
+    scopedClass: (v: unknown, hash: string) => string;
+    /** SV-7b: a client question — not asked on the server; the browser asks it once hydrated (Solid's \`ssrSource: "client"\`). */
+    clientQuestion: (o?: {
+        loadingValue?: unknown;
+    }) => {
+        ssrSource: string;
+        loadingValue?: unknown;
+    };
+    /** 12 SF-2: a server fn as the client calls it — every call a flight. Asked in reactive scope it is a question, one
+     *  flight per arguments, as a JS import's; in imperative scope each call is a new request. \`fn\` is the module-level
+     *  \`"use server"\` function (SF-7a): the body in place, or — once Solid's \`transformDirectives\` has made it a reference
+     *  — a request to the server. */
+    serverRef(name: string, fn: (...a: unknown[]) => Promise<unknown>): (...args: unknown[]) => Flight;
+    /** SF-6: a server fn's body (a generator, as an action's), driven by promises — not by an action: it is no change of
+     *  the client's — behind a wire that copies arguments and result and lets only declared failures through. */
+    serverCall(name: string, gen: (...a: unknown[]) => Generator<unknown, unknown, unknown>, args: unknown[]): Promise<unknown>;
+    hoisted(name: string, get: Acc): void;
+    until: (p: () => unknown) => any;
+    onSettled: (f: () => void) => any;
+    onFlush: (f: () => void) => any;
+    refresh(name: string, get: Acc): void;
+    affects: (get: Acc) => any;
+    preOr: (v: unknown, init: () => unknown) => unknown;
+    module(key: unknown, factory: (rt: unknown) => Record<string, unknown>): Record<string, unknown>;
+    owner: () => any;
+    /** `context x: T = d` (RG-7): the declaration is the identity; `d`, if any, is evaluated once, owned where it is declared. */
+    /** `context x: T = d` (RG-7): the declaration is the identity (a sentinel default: absence is ours to decide); `d` is
+     *  evaluated once, owned where it is declared — created now, so it takes its id there on both sides (SV-3). */
+    context(name: string, dflt: (() => unknown) | null): {
+        name: string;
+        ctx: ReturnType<typeof createContext<Entry | undefined>>;
+        dflt: (() => unknown) | null;
+        owner: ReturnType<typeof getOwner>;
+        dv: Entry | null;
+    };
+    provide(c: {
+        name: string;
+        ctx: ReturnType<typeof createContext<Entry | undefined>>;
+        dflt: (() => unknown) | null;
+        owner: ReturnType<typeof getOwner>;
+        dv: Entry | null;
+    }, e: Entry): void;
+    use(c: {
+        name: string;
+        ctx: ReturnType<typeof createContext<Entry | undefined>>;
+        dflt: (() => unknown) | null;
+        owner: ReturnType<typeof getOwner>;
+        dv: Entry | null;
+    }, owner: ReturnType<typeof getOwner>): Entry;
+    useGet(c: {
+        name: string;
+        ctx: ReturnType<typeof createContext<Entry | undefined>>;
+        dflt: (() => unknown) | null;
+        owner: ReturnType<typeof getOwner>;
+        dv: Entry | null;
+    }, owner: ReturnType<typeof getOwner>): unknown;
+    runWithOwner: any;
+    /** An imperative read sees σ (H-10): a pending value is a value; a snapshot of an error throws it (R-f-7). */
+    snapshot(get: Acc): any;
+    errorClass: (name: string, params: string[], message: (...args: unknown[]) => unknown) => ErrorClass;
+    isA: (err: unknown, classes: unknown[] | undefined) => boolean;
+    PANIC: {
+        readonly panic: true;
+    };
+    catchMemo: typeof catchAcc;
+    tryCatch: typeof tryCatch;
+    catchRead: (f: () => unknown, match: (err: unknown) => boolean, alt: (err: unknown) => unknown) => unknown;
+    throw: (e: unknown) => never;
+    eq: (a: unknown, b: unknown) => boolean;
+    untrack: any;
+    latest: (f: () => unknown) => any;
+    isPending: (f: () => unknown) => any;
+    fmt: (v: unknown) => string;
+    show: (v: unknown) => unknown;
+    /** `errored fallback(e: A | B)`: a failure of another class passes to the boundary above (R-f-4) — the fallback hands it out
+     *  and a memo throws it there (a rethrow from the fallback itself did not recover until solidjs/solid#4277: ref/oracle/repros/dv7-rethrow.mjs). */
+    TypedErrored(props: {
+        classes: unknown[];
+        fallback: (err: Acc) => unknown;
+        children: unknown;
+    }): any;
+};
+export type App = ReturnType<typeof createApp>;

package/dist/web.d.ts

@@ -0,0 +1 @@
+export * from "./types/rt-web.js";