uneventful 0.0.7 → 0.0.8

package/dist/signals.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"signals.mjs","sources":["../src/cells.ts","../src/rules.ts","../src/signals.ts"],"sourcesContent":["import { Context, current, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { type RuleQueue, currentRule, ruleQueue, defaultQ, ruleStops } from \"./scheduling.ts\";\nimport { Job, OptionalCleanup, RecalcSource } from \"./types.ts\"\nimport { detached, getJob, makeJob } from \"./tracking.ts\";\nimport { Connection, Inlet, IsStream, Sink, Source, backpressure } from \"./streams.ts\";\nimport { apply, setMap } from \"./utils.ts\";\nimport { isError, markHandled } from \"./results.ts\";\nimport { nullCtx } from \"./internals.ts\";\nimport { defer } from \"./defer.ts\";\n\n/**\n * Error indicating a rule has attempted to write a value it indirectly\n * depends on, or which has already been read by another rule in the current\n * batch. (Also thrown when a cached function attempts to write a value at all,\n * directly or indirectly.)\n *\n * @category Errors\n */\nexport class WriteConflict extends Error {}\n\n/**\n * Error indicating a rule has attempted to write a value it directly depends\n * on, or a cached function has called itself, directly or indirectly.\n *\n * @category Errors\n */\nexport class CircularDependency extends Error {}\n\nvar timestamp = 1;\n\n/** recalcWhen(fn): map fn -> signal */\nconst fntrackers = new WeakMap<Function, () => number>();\n\n/** recalcWhen(key, factory): map factory -> key -> signal */\nconst obtrackers = new WeakMap<Function, WeakMap<WeakKey, () => number>>();\n\n/** stream controllers for stream+recalcWhen signals */\nconst streamtrackers = new WeakMap<Cell, ()=>void>();\n\nconst dirtyStack: Cell[] = [];\n\nfunction markDependentsDirty(cell: Cell) {\n    // We don't set validThrough here because that's how we tell the cell's been read/depended on\n    const latestSource = cell.latestSource = timestamp;\n    for(; cell; cell = dirtyStack.pop()) {\n        for (let sub=cell.subscribers; sub; sub = sub.nT) {\n            const tgt = sub.tgt;\n            if (tgt.latestSource >= latestSource) continue;\n            tgt.latestSource = latestSource;\n            tgt.queue?.add(tgt);\n            if (tgt.subscribers) dirtyStack.push(tgt);\n        }\n    }\n}\n\n// The .compute for a cell whose value has been explicitly set\nfunction returnValue(this: Cell) {\n    return this.value;\n}\n\n// The compute for a cell whose value is an explicit error\nfunction throwValue(this: Cell) {\n    throw this.value;\n}\n\n/**\n * Cells that are known to be clean as of this timestamp, but have not been\n * marked as read yet (and whose sources might also not be marked read).  This\n * lets us lazily determine if a cell's value has been depended on (i.e.\n * \"virtually read\") in this timestamp, even if it wasn't *actually* read.\n */\nconst notCaughtUp = [] as Cell[];\n\nconst enum Is {\n    Compute  = 1 << 2,\n    Error    = 1 << 4,\n    Running  = 1 << 5,\n    Stream   = 1 << 6,\n    Mutable  = 1 << 7,\n    Demanded = 1 << 8,            // Stream has been queued for demand update\n    Demand   = Stream | Demanded, // Mask for checking if stream + unqueued\n    Variable = Compute | Mutable,\n}\n\ntype Subscription = {\n    /** Source of the subscription */\n    src: Cell\n    nS: Subscription,\n    pS: Subscription,\n\n    /** Subscriber */\n    tgt: Cell\n    nT: Subscription,\n    pT: Subscription,\n\n    ts: number,\n\n    /* stack for active subscriptions on sources */\n    old: Subscription\n}\n\nvar freesubs: Subscription;\n\nfunction mksub(source: Cell, target: Cell) {\n    let sub: Subscription = freesubs;\n    if (sub) {\n        freesubs = sub.old;\n        sub.src = source; sub.nS = undefined; sub.pS = target.sources;\n        sub.tgt = target; sub.nT = sub.pT = undefined;\n        sub.ts = source.lastChanged; sub.old = source.adding;\n    } else sub = {\n        src: source, nS: undefined, pS: target.sources,\n        tgt: target, nT: undefined, pT: undefined,\n        ts: source.lastChanged, old: source.adding\n    }\n    // Add subscription to tail of target's sources\n    if (target.sources) target.sources.nS = sub;\n    target.sources = sub;\n    // track that this source has had a subscription added during this calculation\n    source.adding = sub;\n    // Set up reciprocal subscription if needed\n    if (target.subscribers || target.queue) source.subscribe(sub);\n}\n\nfunction delsub(sub: Subscription) {\n    sub.src.unsubscribe(sub);\n    if (sub.nS) sub.nS.pS = sub.pS;\n    if (sub.pS) sub.pS.nS = sub.nS;\n    sub.src = sub.tgt = sub.nS = sub.pS = sub.nT = sub.pT = undefined;\n    sub.old = freesubs;\n    freesubs = sub;\n}\n\nfunction subscribeAll(s: Subscription) {\n    if (s) while (s.pS) s = s.pS; else return;\n    for(; s; s = s.nS) s.src.subscribe(s);\n}\n\nfunction unsubscribeAll(s: Subscription) {\n    if (s) while (s.pS) s = s.pS; else return;\n    for(; s; s = s.nS) s.src.unsubscribe(s);\n}\n\nconst sentinel = {}  // a unique value for uniqueness checking\n\nexport class Cell {\n    value: any = undefined // the value\n    validThrough = 0; // timestamp of most recent validation or recalculation\n    lastChanged = 0;  // timestamp of last value change\n    latestSource = timestamp; // max lastChanged of this cell or any ancestor source\n    flags = 0;\n    ctx: Context = undefined;\n    /** The subscription being added during the current calculation - used for uniqueness */\n    adding: Subscription = undefined;\n    /** Linked list of sources */\n    sources: Subscription = undefined;\n    /** Linked list of targets */\n    subscribers: Subscription = undefined;\n    queue: RuleQueue = undefined;\n\n    /**\n     * The computation to be performed (if {@link Is.Compute}) or the\n     * setup/teardown for {@link Is.Stream}.\n     */\n    compute: (sub?: boolean) => any = returnValue;\n\n    stream<T>(sink: Sink<T>, _conn?: Connection, inlet?: Inlet) {\n        let lastValue = sentinel;\n        Cell.mkRule(() => {\n            const val = this.getValue();\n            if (val !== lastValue) {\n                const old = swapCtx(nullCtx);\n                try { sink(lastValue = val); } finally { swapCtx(old); }\n            }\n        }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);\n        return IsStream;\n    }\n\n    getValue() {\n        if (arguments.length) return apply(this.stream, this, arguments);\n        this.catchUp();\n        const dep = current.cell;\n        // Only create a dependency if our value can change\n        if (dep && this.flags & Is.Variable) {\n            if (this.flags & Is.Running) throw new CircularDependency(\"Cached function dependency cycle\");\n            // See if we've already got a subscription node for the dependent\n            let s = this.adding;\n            if (!s || s.tgt !== dep) {\n                // nope, it's new\n                mksub(this, dep);\n            } else {\n                // Yep, see if it's a hangover from last time\n                if (s.ts === -1) {\n                    // yep, mark it reused\n                    s.ts = this.lastChanged;\n                    if (s.nS) { // if not at end, move it\n                        s.nS.pS = s.pS;\n                        if (s.pS) s.pS.nS = s.nS;\n                        s.nS = undefined;\n                        s.pS = dep.sources;\n                        dep.sources.nS = s;\n                        dep.sources = s;\n                    }\n                }\n                // else it's already done, no need to do anything.\n            }\n        }\n        if (this.flags & Is.Error) throw this.value;\n        return this.value;\n    }\n\n    shouldWrite(changed: boolean) {\n        const cell = current.cell || currentRule;\n        if (cell) {\n            // When a cell changes within a sweep (i.e. from an active rule or other\n            // cell), we need to check if it's not a circular update or disallowed\n            // side-effect.  In such a case we bail out with an error, even if the\n            // change is idempotent.  (To avoid hiding value-dependent errors.)\n            if (!cell.queue) throw new WriteConflict(\"Side-effects not allowed outside rules\");\n            if (this.adding && this.adding.tgt === cell) throw new CircularDependency(\"Can't update direct dependency\");\n            if (this.validThrough === timestamp || this.hasBeenRead()) throw new WriteConflict(\"Value already used\");\n        } else if (changed) {\n            // We are *not* in a sweep, but *did* have a change.  So we may need to advance\n            // the timestamp, if we might have had readers in the current one.\n            if (this.validThrough === timestamp || notCaughtUp.length) { ++timestamp; notCaughtUp.length = 0; }\n        } else {\n            // Not in a sweep and no change -- no need to actually write anything\n            return false;\n        }\n        // If we changed as of the current timestamp, we're already dirty\n        // Otherwise, we should flag our subscribers as such.\n        (this.lastChanged === timestamp) || markDependentsDirty(this);\n        // If we have sources, reset the subscription timestamp of the first one\n        // to force a recalculation on our next catchUp().\n        if (this.sources) this.sources.ts = 0;\n        return true;\n    }\n\n    setValue(val: any, isErr: boolean) {\n        if (this.shouldWrite(val !== this.value || isErr !== !!(this.flags & Is.Error))) {\n            this.value = val;\n            this.lastChanged = timestamp;\n            this.flags = isErr ? this.flags | Is.Error : this.flags & ~Is.Error;\n        }\n        // We always reset the compute here because we might have been in the\n        // Calc state.  But we don't clear the Calc flag because we might need\n        // any previous sources to be released or unsubscribed.  (Which will\n        // happen on our next recalc.)\n        this.compute = isErr ? throwValue : returnValue;\n    }\n\n    setCalc(compute: () => any) {\n        if (this.shouldWrite(compute !== this.compute)) {\n            this.flags |= Is.Compute;\n            this.compute = compute;\n            this.ctx ||= makeCtx(null, this);\n        }\n    }\n\n    hasBeenRead() {\n        if (notCaughtUp.length) {\n            for(const cell of notCaughtUp) cell.catchUp();\n            notCaughtUp.length = 0;\n        }\n        return this.validThrough === timestamp;\n    }\n\n    catchUp(): void {\n        const {validThrough} = this;\n        if (validThrough === timestamp) return;\n        this.validThrough = timestamp;\n        if (!(this.flags & Is.Compute)) return;\n        if (this.sources) {\n            for(let sub=this.sources; sub; sub = sub.nS) {\n                const s = sub.src;\n                // changed since our last compute? we're definitely dirty\n                if (sub.ts !== s.lastChanged) return this.doRecalc();\n                // if source is clean, skip it (most should be)\n                // (note: only cells w/subscribers can be trusted as to their\n                // latestSource, as cacheds with no subscribers don't get\n                // notified by their upstreams)\n                if (s.subscribers && s.latestSource <= validThrough) continue;\n                // not a simple yes or no -- \"it's complicated\" -- so recurse\n                s.catchUp();\n                if (s.lastChanged > validThrough) {\n                    return this.doRecalc();\n                }\n            }\n            // If we got to this point, we didn't need to recalc, but that means\n            // none of our sources actually *changed*, despite at least one being\n            // dirty.  But that means we \"virtually\" read the clean values and\n            // therefore depended on them... which means if they get written to,\n            // either the timestamp must change or the write must be blocked.\n            //\n            // So we put them on our notCaughtUp list, in order to prevent rules\n            // from changing them (or their sources) in the same timestamp, and\n            // so that non-rule writes will know to update the timestamp.\n            for(let sub=this.sources; sub; sub = sub.nS) {\n                if (sub.src.validThrough !== timestamp) notCaughtUp.push(sub.src);\n            }\n        } else return this.doRecalc();\n    }\n\n    doRecalc() {\n        const oldCtx = swapCtx(this.ctx);\n        for(let sub = this.sources; sub; sub = sub.nS) {\n            sub.ts = -1; // mark stale for possible reuse\n            // attach sub to its source, so we can look it up\n            sub.old = sub.src.adding;\n            sub.src.adding = sub;\n            this.sources = sub;\n        }\n        this.flags |= Is.Running;\n        try {\n            try {\n                const future = this.compute();\n                if (future !== this.value || !this.lastChanged || this.flags & Is.Error) {\n                    this.value = future;\n                    this.lastChanged = timestamp;\n                }\n                this.flags &= ~Is.Error;\n            } catch(e) {\n                this.flags |= Is.Error\n                this.value = e;\n                this.lastChanged = timestamp;\n                if (currentRule === this) throw e;\n            }\n        } finally {\n            this.flags &= ~Is.Running;\n            swapCtx(oldCtx);\n            // reset this.src to the head of the list, dropping stale subscriptions\n            let head: Subscription;\n            for(let sub = this.sources; sub; ) {\n                const pS = sub.pS;\n                sub.src.adding = sub.old;\n                sub.old = undefined;\n                if (sub.ts === -1) delsub(sub); else head = sub;\n                sub = pS;\n            }\n            this.sources = head;\n            if (!head) {\n                // without sources, we can never change or be invalidated, so\n                // revert to settable value() or permanent constant\n                this.flags &= ~Is.Compute;\n            }\n        }\n    }\n\n    stop() {\n        this.setQ(null);\n        ruleStops.get(this)?.();\n    }\n\n    setQ(queue = defaultQ) {\n        // Don't unsubscribe if we have subscribers or there's going to be a queue\n        queue || this.subscribers || unsubscribeAll(this.sources);\n        if (this.queue) {\n            // Only add to new queue if queued on old\n            if (this.queue.has(this)) queue?.add(this);\n            this.queue.delete(this);\n            queue || this.ctx.job?.restart();\n        } else if (queue) {\n            // initial queue or re-enable, schedule it\n            queue.add(this);\n            // If we already have subscribers, we're already subscribed\n            this.subscribers || subscribeAll(this.sources);\n        }\n        this.queue = queue;\n    }\n\n    subscribe(sub: Subscription) {\n        if (!this.subscribers) {\n            this.queue || subscribeAll(this.sources);\n            // subscribe to source\n            if ((this.flags & Is.Demand) === Is.Stream) this.updateDemand();\n        }\n        if (this.subscribers !== sub && !sub.pT) { // avoid adding already-added subs\n            sub.nT = this.subscribers;\n            if (this.subscribers) this.subscribers.pT = sub;\n            this.subscribers = sub;\n        }\n    }\n\n    unsubscribe(sub: Subscription) {\n        if (sub.nT) sub.nT.pT = sub.pT;\n        if (sub.pT) sub.pT.nT = sub.nT;\n        if (this.subscribers === sub) this.subscribers = sub.nT;\n        sub.nT = sub.pT = undefined;\n        if (!this.subscribers) {\n            this.queue || unsubscribeAll(this.sources);\n            // unsubscribe from source\n            if ((this.flags & Is.Demand) === Is.Stream) this.updateDemand();\n        }\n    }\n\n    static mkValue<T>(val: T) {\n        const cell = new Cell;\n        cell.flags = Is.Mutable;\n        cell.value = val;\n        cell.lastChanged = timestamp;\n        return cell;\n    }\n\n    updateDemand() {\n        this.flags |= Is.Demanded;\n        defer(streamtrackers.get(this));\n    }\n\n    static mkStream<T>(src: Source<T>, val?: T) {\n        const cell = this.mkValue(val);\n        cell.flags |= Is.Stream;\n        const ctx = makeCtx();\n        const write = (v: T) => { cell.setValue(v, false);  };\n        let job: Job<void>;\n        streamtrackers.set(cell, () => {\n            if (!(cell.flags & Is.Demanded)) return;\n            cell.flags &= ~(Is.Demanded);\n            if (!cell.subscribers) {\n                // Last subscriber is gone, so reset to default value\n                write(val);\n                job?.end();  // unsubscribe from source\n                return\n            }\n            if (job) return;\n            job = ctx.job = makeJob<void>().do(r => {\n                if (isError(r)) {\n                    cell.setValue(markHandled(r), true);\n                } else {\n                    cell.setValue(val, false);\n                }\n                ctx.job = job = undefined;\n            });\n            const old = swapCtx(ctx);\n            try {\n                src(write, job);\n            } catch(e) {\n                job.end();\n                detached.asyncThrow(e);\n            } finally {\n                swapCtx(old);\n            }\n        });\n        return cell;\n    }\n\n    recalcWhen(src: RecalcSource): void;\n    recalcWhen<T extends WeakKey>(key: T, factory: (key: T) => RecalcSource): void;\n    recalcWhen<T extends WeakKey>(fnOrKey: T | RecalcSource, fn?: (key: T) => RecalcSource) {\n        let trackers: WeakMap<WeakKey, () => number> = fn ?\n            obtrackers.get(fn) || setMap(obtrackers, fn, new WeakMap) :\n            fntrackers\n        ;\n        let signal = trackers.get(fnOrKey);\n        if (!signal) {\n            const src = fn ? fn(<T>fnOrKey) : <RecalcSource> fnOrKey;\n            let ct = 0;\n            const c = Cell.mkStream(s => (src(() => s(++ct)), IsStream), ct);\n            trackers.set(fnOrKey, signal = c.getValue.bind(c));\n        }\n        signal();  // Subscribe to the cell\n    }\n\n    static mkCached<T>(compute: () => T) {\n        const cell = new Cell;\n        cell.compute = compute;\n        cell.ctx = makeCtx(null, cell);\n        cell.flags = Is.Compute;\n        return cell;\n    }\n\n    static mkRule(fn: (stop: () => void) => OptionalCleanup, q: RuleQueue) {\n        const cell = new Cell, outer = getJob(), job = makeJob(), stop = cell.stop.bind(cell);\n        outer === detached || ruleStops.set(cell, outer.release(stop));\n        cell.compute = () => {\n            try {\n                job.restart().must(fn(stop));\n                cell.lastChanged = timestamp;\n            } catch (e) {\n                stop();\n                throw e;\n            }\n        }\n        cell.ctx = makeCtx(job, cell);\n        cell.flags = Is.Compute;\n        cell.setQ(q);\n        return stop;\n    }\n}\n","import { defer } from \"./defer.ts\";\nimport { RuleQueue, currentRule, defaultQ, ruleQueue } from \"./scheduling.ts\";\nimport { AnyFunction, DisposeFn, OptionalCleanup } from \"./types.ts\";\nimport { Cell } from \"./cells.ts\";\nimport { CallableObject, apply, setMap } from \"./utils.ts\";\nimport { detached } from \"./tracking.ts\";\n\n/**\n * A decorator function that supports both TC39 and \"legacy\" decorator protocols\n *\n * @template F the type of method this decorator can decorate.  If the method\n * doesn't conform to this type, compile-time type checks will fail.\n *\n * @category Types and Interfaces\n */\nexport type GenericMethodDecorator<F extends AnyFunction> = {\n    /** TC39 Method Decorator @hidden */\n    (fn: F, ctx?: {kind: \"method\"}): F;\n\n    /** Legacy Method Decorator @hidden */\n    (proto: object, name: string|symbol, desc?: {value?: F}): void;\n}\n\n/**\n * The interface provided by {@link rule}, and other {@link rule.factory}()\n * functions.\n*\n* @category Types and Interfaces\n*/\nexport interface RuleFactory {\n    /**\n     * @inheritdoc rule factory tied to a specific scheduler.  See {@link rule} for\n     * more details.\n     */\n    (fn: (stop: DisposeFn) => OptionalCleanup): DisposeFn;\n\n    /**\n     * A function that will stop the currently-executing rule.  (Accessing this\n     * attribute will throw an error if no rule is currently running.)\n     *\n     * Note: this returns the stop for the current rule regardless of its\n     * scheduler, so you can access `rule.stop` even if the rule was created\n     * with a different scheduler.\n     */\n    readonly stop: DisposeFn;\n\n    /**\n     * Observe a condition and apply an action.\n     *\n     * For a given {@link RuleFactory} `r` (such as `rule`), `r.if(condition,\n     * action)` is roughly equivalent to `r(() => { if (condition()) return\n     * action(); })`, except that the rule is *only* rerun if the `action`'s\n     * dependencies change, *or* the **truthiness** of `condition()` changes. It\n     * will *not* be re-run if only the dependencies of `condition()` have\n     * changed, without affecting its truthiness.\n     *\n     * This behavior can be important for rules that nest other rules, have\n     * cleanups, fire off tasks, etc., as it may be wasteful to constantly tear\n     * them down and set them back up if the enabling condition is a calculation\n     * with frequently-changing dependencies.\n     *\n     * @remarks This is just a shortcut for wrapping `condition` as a signal\n     * that converts it to boolean. So if you already *have* a boolean signal,\n     * you can get the same effect with just `if (condition()) { ... }`.\n     */\n    if(condition: () => any, action: () => OptionalCleanup): DisposeFn\n\n    /**\n     * Decorate a method or function to behave as a rule, e.g.\n     *\n     * ```ts\n     * const animate = rule.factory(requestAnimationFrame);\n     *\n     * class Draggable {\n     *     ⁣@animate.method\n     *     trackPosition(handleTop: number, handleLeft: number) {\n     *         const {clientX, clientY} = lastMouseEvent();\n     *         this.element.style.top  = `${clientY - handleTop}px`;\n     *         this.element.style.left = `${clientX - handleLeft}px`;\n     *     }\n     * }\n     *\n     * // Start running the method in an animation frame for every change to\n     * // lastMouseEvent, until the current job ends:\n     * someDraggable.trackPosition(top, left);\n     * ```\n     * or:\n     * ```ts\n     * const logger = rule.method((formatString, signal) => { log(formatString, signal()); });\n     * ```\n     *\n     * Each time it's (explicitly) called, the decorated method will start a new\n     * rule, which will repeatedly run the method body (with the original\n     * arguments and `this`) whenever its dependencies change, according to the\n     * schedule defined by the rule factory.  (So e.g. `@rule.method` will\n     * update on the microtask after a change, etc.)\n     *\n     * The decorated method will always return a {@link DisposeFn} to let you\n     * explicitly stop the rule before the current job end.  But if the original\n     * method body doesn't return a dispose function of its own, TypeScript will\n     * consider the method to return void, unless you explicitly declare its\n     * return type to be `DisposeFn | void`.\n     *\n     * Also note that since rule methods can accept arbitrary parameters, they\n     * do not receive a `stop` parameter, and must therefore use {@link\n     * RuleFactory.stop rule.stop}() if they wish to terminate themselves.\n     */\n    readonly method: GenericMethodDecorator<(...args: any[]) => OptionalCleanup>\n\n    /**\n     * Return a rule factory for the given scheduling function, that you can\n     * then use to make rules that run in a specific time frame.\n     *\n     * ```ts\n     * // `animate` will now create rules that run during animation fames\n     * const animate = rule.factory(requestAnimationFrame);\n     *\n     * animate(() => {\n     *     // ... do stuff in an animation frame when signals used here change\n     * })\n     * ```\n     *\n     * (In addition to being callable, the returned function is also a\n     * {@link RuleFactory}, and thus has a `.method` decorator, `.if()` method,\n     * and so on.)\n     *\n     * @param scheduleFn A single-argument scheduling function (such as\n     * requestAnimationFrame, setImmediate, or queueMicrotask).  The rule\n     * scheduler will call it from time to time with a single callback.  The\n     * scheduling function should then arrange for that callback to be invoked\n     * *once* at some future point, when it is the desired time for all pending\n     * rules on that scheduler to run.\n     *\n     * @returns A {@link RuleFactory}, like {@link rule}.  If called with the\n     * same scheduling function more than once, it returns the same factory.\n     *\n     */\n    factory(scheduleFn: SchedulerFn): RuleFactory\n\n    /**\n     * Create a \"detached\" or standalone rule, that is not attached to any job.\n     *\n     * `r.detached(fn)` is shorthand for calling `detached.run(r, fn)`.  (Where\n     * `r` is a {@link RuleFactory} such as `rule`.)\n     *\n     * Note that since the created rule isn't attached to a job, it *must* be\n     * explicitly stopped, either by calling the returned disposal function or\n     * by the rule function arranging to stop itself via {@link rule.stop}() or\n     * its stop parameter.\n     */\n    detached(fn: (stop: DisposeFn) => OptionalCleanup): DisposeFn;\n\n    /**\n     * Change the scheduler used for the currently-executing rule.  Throws an\n     * error if no rule is running.\n     *\n     * @param scheduleFn Optional: The {@link SchedulerFn scheduling function}\n     * to use; the default microtask scheduler will be used if none is given or\n     * the given value is falsy.\n     *\n     * @remarks It's best to only use scheduling functions that were created\n     * *outside* the current rule, otherwise you'll be creating a new scheduling\n     * queue object on every run of the rule.  (These will get garbage collected\n     * with the scheduling functions, but you'll be creating more memory\n     * pressure and using more GC time if the rule runs frequently.)\n     */\n    setScheduler(scheduleFn?: SchedulerFn): void;\n}\n\ntype RuleFunction = (fn: ActionFunction) => DisposeFn\ntype ActionFunction = (stop: DisposeFn) => OptionalCleanup\n\nclass RF extends CallableObject<RuleFunction> implements RuleFactory {\n\n    constructor(q: RuleQueue) {\n        super((fn: ActionFunction) => Cell.mkRule(fn, q))\n    }\n\n    get stop() {\n        if (currentRule) return currentRule.stop.bind(currentRule);\n        throw new Error(\"No rule active\");\n    }\n\n    if(condition: () => any, action: () => OptionalCleanup): DisposeFn {\n        const cond = Cell.mkCached(() => !!condition());\n        return this(() => cond.getValue() ? action() : undefined);\n    }\n\n    get method(): GenericMethodDecorator<(...args: any[]) => OptionalCleanup> {\n        const self = this;\n        return (\n            fn: object | ((...args: any[]) => OptionalCleanup),\n            _ctxOrName?: any,\n            desc?: { value?: (...args: any[]) => OptionalCleanup; }\n        ) => {\n            if (desc) return void (desc.value = this.method(desc.value));\n            return function (this: any, ...args: any[]): DisposeFn {\n                return self(() => apply(fn as any, this, args));\n            };\n        }\n    }\n\n    factory(scheduleFn: SchedulerFn): RuleFactory {\n        return factories.get(scheduleFn) || setMap(factories, scheduleFn, new RF(ruleQueue(scheduleFn)));\n    }\n\n    detached(fn: ActionFunction) {\n        return detached.run(this as RuleFunction, fn);\n    }\n\n    setScheduler(scheduleFn?: SchedulerFn): void {\n        if (currentRule) currentRule.setQ(scheduleFn ? ruleQueue(scheduleFn) : defaultQ);\n        else throw new Error(\"No rule active\");\n    }\n}\n\n\nconst factories = new WeakMap<Function, RuleFactory>();\n\n/**\n * Subscribe a function to run every time certain values change.\n *\n * The function is run asynchronously, first after being created, then again\n * after there are changes in any of the values or cached functions it read\n * during its previous run.\n *\n * The created subscription is tied to the currently-active job (which may be\n * another rule).  So when that job is ended or restarted, the rule will be\n * terminated automatically.  You can also terminate it early by calling the\n * \"stop\" function that is both passed to the rule function and returned by\n * `rule()`.\n *\n * Note: this function will throw an error if called without an active job. If\n * you need a standalone rule, use {@link RuleFactory.detached rule.detached}().\n *\n * @param fn The function that will be run each time its dependencies change.\n * The function will be run in a restarted job each time, with any resources\n * used by the previous run being cleaned up.  The function is passed a single\n * argument: a function that can be called to terminate the rule.   The function\n * should return a cleanup function or void.\n *\n * @returns A function that can be called to terminate the rule.\n *\n * @category Signals\n */\nexport const rule: ((action: (stop: DisposeFn) => OptionalCleanup) => DisposeFn) & RuleFactory = (\n    RF.prototype.factory(defer)\n)\n\n/**\n * Synchronously run any pending rules tied to a specific schedule.\n *\n * (Note: \"pending\" rules are ones with at least one changed ancestor\n * dependency; this doesn't mean they will actually *do* anything, since\n * intermediate cached() function results might end up unchanged.)\n *\n * You should normally only need to call this when you need to *force*\n * side-effects to occur within a specific *synchronous* timeframe, e.g. if\n * rules need to be able to cancel a synchronous event or continue an IndexedDB\n * transaction.  (Otherwise, this is really only useful for testing.)\n *\n * @param scheduleFn The {@link SchedulerFn scheduler} used to create the rule\n * factory you wish to run pending rules for.  If not given, the default\n * {@link rule}() factory is targeted.\n *\n * @category Signals\n */\nexport function runRules(scheduleFn?: SchedulerFn) {\n    (scheduleFn ? ruleQueue(scheduleFn) : defaultQ).flush();\n}\n\n/**\n * A single-argument scheduling function (such as requestAnimationFrame,\n * setImmediate, or queueMicrotask).  The rule scheduler will call it from time\n * to time with a single callback.  The scheduling function should then arrange\n * for that callback to be invoked *once* at some future point, when it is the\n * desired time for all pending rules on that scheduler to run.\n *\n * @category Types and Interfaces\n */\nexport type SchedulerFn = (cb: () => unknown) => unknown;\n","/**\n * The Signals API for uneventful.\n *\n * @module uneventful/signals\n */\n\nimport { current, freeCtx, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { PlainFunction, Yielding, AnyFunction, Job } from \"./types.ts\";\nimport { Cell } from \"./cells.ts\";\nimport { rule } from \"./rules.ts\";\nimport { reject, resolve } from \"./results.ts\";\nimport { UntilMethod } from \"./sinks.ts\";\nimport { SignalSource, Source, Stream } from \"./streams.ts\";\nimport { callOrWait } from \"./call-or-wait.ts\";\nimport { CallableObject, apply } from \"./utils.ts\";\nimport { defer } from \"./defer.ts\";\nimport { next } from \"./sinks.ts\";  // needed for documentation link\n\nexport type * from \"./rules.ts\"\nexport { rule, runRules } from \"./rules.ts\"\nexport { WriteConflict, CircularDependency } from \"./cells.ts\";\n\n/**\n * An observable value, as a zero-argument callable with extra methods.\n *\n * In addition to being callable, signals also offer a `.value` getter, and\n * implement the standard JS methods `.toString()`, `.valueOf()`, and\n * `.toJSON()` in such a way that they reflect the signal's contents rather than\n * the signal itself.\n *\n * Signals also implement the {@link Source} interface, and can thus be\n * subscribed to.  Subscribers receive the current value first, and then any\n * changes thereafter.  They can be waited on by {@link until}(), in which case\n * the calling job resumes when the signal's value is truthy.\n *\n * You can also transform a signal to a {@link Writable} by calling its\n * .{@link Signal.withSet withSet}() method, or create a writable value using\n * {@link value}().\n *\n * @category Types and Interfaces\n */\nexport interface Signal<T> extends SignalSource<T>, UntilMethod<T> {\n    /**\n     * The current value\n     *\n     * @category Reading\n     */\n    readonly value: T\n\n    /** Current value @hidden */\n    valueOf()  : T\n\n    /** Current value as a string @hidden */\n    toString(): string\n\n    /** The current value @hidden */\n    toJSON()   : T\n\n    /**\n     * Get the signal's current value, without adding the signal as a dependency\n     *\n     * (This is exactly equivalent to calling {@link peek}(signal), and exists\n     * here mainly for interop with other signal frameworks.)\n     *\n     *  @category Reading */\n    peek(): T;\n\n    /** Get a read-only version of this signal @category Reading */\n    asReadonly(): Signal<T>\n\n    /** New writable signal with a custom setter @category Writing */\n    withSet(set: (v: T) => unknown): Writable<T>\n\n    /** @hidden */\n    \"uneventful.until\"(): Yielding<T>;\n}\n\n/** @internal */\nexport class SignalImpl<T> extends CallableObject<SignalSource<T>> implements Signal<T> {\n    constructor(protected _c: Cell) { super(_c.getValue.bind(_c)); }\n    get value() { return this(); }\n    valueOf()   { return this(); }\n    toString()  { return \"\" + this(); }\n    toJSON()    { return this(); }\n    peek()      { return peek(this as () => T); };\n    asReadonly(): Signal<T> { return this; }\n    withSet(set: (v: T) => unknown): Writable<T> {\n        return Object.assign(new WritableImpl<T>(this._c), {set});\n    }\n\n    *\"uneventful.next\"(): Yielding<T> {\n        return yield (r => {\n            let seen = false, res: T;\n            rule(stop => {\n                try { res = this(); } catch(e) { stop(); defer(reject.bind(null, r,e)); }\n                if (seen) { stop(); defer(resolve.bind(null, r, res)); }\n                seen = true;\n            })\n        });\n    }\n\n    *\"uneventful.until\"(): Yielding<T> {\n        return yield (r => {\n            let res: T;\n            try { res = this(); } catch(e) { reject(r, e); return; }\n            if (res) return resolve(r, res);\n            rule(stop => {\n                try { res = this(); } catch(e) { stop(); defer(reject.bind(null, r,e)); }\n                if (res) { stop(); defer(resolve.bind(null, r, res)); }\n            });\n        });\n    }\n}\n\n/**\n * A {@link Signal} with a {@link Writable.set | .set()} method and writable\n * {@link Writable.value | .value} property.\n *\n * @category Types and Interfaces\n */\nexport interface Writable<T> extends Signal<T>  {\n    /**\n     * Set the current value.  (Note: this is a bound method so it can be used\n     * as a callback.)\n     *\n     * @category Writing\n     */\n    readonly set: (val: T) => void;\n\n    get value(): T\n\n    /** Set the current value */\n    set value(val: T);\n}\n\n/** @internal */\nexport class WritableImpl<T> extends SignalImpl<T> implements Writable<T> {\n    get value() { return this(); }\n    set value(val: T) { this.set(val); }\n    set = (val: T) => { this._c.setValue(val, false); }\n    asReadonly(): Signal<T> {\n        return new SignalImpl<T>(this._c);\n    }\n}\n\n/**\n * A writable signal that can be set to either a value or an expression.\n *\n * Like a spreadsheet cell, a configurable signal can contain either a value or\n * a formula.  If you .set() a value or change the .value property of the\n * signal, the formula is cleared.  Conversely, if you set a formula with\n * .setf(), then the value is calculated using that formula from then on, until\n * another formula is set, or the value is changed directly again.\n *\n * @category Types and Interfaces\n */\nexport interface Configurable<T> extends Writable<T>  {\n    /**\n     * Set a formula that will be used to calculate the signal's value. If it\n     * uses the value of other signals, this signal's value will be recalculated\n     * when they change.\n     *\n     * @category Writing\n     */\n    setf(expr: () => T): this;\n}\n\n/** @internal */\nexport class ConfigurableImpl<T> extends WritableImpl<T> implements Configurable<T> {\n    setf(expr: () => T): this {\n        this._c.setCalc(expr);\n        return this;\n    }\n}\n\n/**\n * Create a {@link Configurable} signal with the given inital value\n *\n * @category Signals\n */\nexport function value<T>(val?: T): Configurable<T> {\n    const cell = Cell.mkValue(val);\n    return new ConfigurableImpl<T>(cell);\n}\n\n/**\n * Create a cached version of a function.  The returned callable is also a\n * {@link Signal}.\n *\n * Note: If the supplied function has a non-zero `.length` (i.e., it explicitly\n * takes arguments), it is assumed to be a {@link Source}, and the second\n * calling signature below will apply, even if TypeScript doesn't see it that\n * way!)\n *\n * @category Signals\n */\nexport function cached<T>(compute: () => T): Signal<T>;\n\n/**\n * If the supplied function has a non-zero `.length` (i.e., it explicitly takes\n * arguments), it is assumed to be a {@link Source}, and the second argument is\n * a default value for the created signal to use as default value until the\n * source produces a value.\n *\n * The source will be subscribed *only* while the signal is subscribed as a\n * stream, or observed (directly or indirectly) by a rule.  While subscribed,\n * the signal will update itself with the most recent value produced by the\n * source, triggering rules or events as appropriate if the value changes.  When\n * the signal is once again unobserved (or if the source ends without an error),\n * its value will revert to the supplied default.\n *\n * If the source ends *with* an error, however, then the cached function will\n * throw that error whenever called, until/unless it becomes unobserved again.\n * (And thus reverts to the default value once more.)\n *\n * @param source A {@link Source} providing data which will become this signal's\n * value\n * @param defaultVal The value to use when the signal is unobserved or waiting for\n * the first item from the source.\n */\nexport function cached<T>(source: Source<T>, defaultVal?: T): Signal<T>;\nexport function cached<T extends Signal<any>>(signal: T): T\nexport function cached<T>(compute: Source<T> | (() => T), initVal?: T): Signal<T> {\n    if (compute instanceof SignalImpl) return compute;\n    return new SignalImpl<T>(\n        compute.length ? Cell.mkStream(compute as Source<T>, initVal) : Cell.mkCached(compute as () => T)\n    );\n}\n\n/**\n * Call a function without creating a dependency on any signals it reads.  (Like\n * {@link Signal.peek}, but for any function with any arguments.)\n *\n * You can also pass in any arguments the function takes, and the function's\n * return value is returned.\n *\n * (Note: Typed overloads are not supported: TypeScript will use the function's\n * *last* overload for argument-typing purposes.  If you need to call a function\n * with a specific overload, wrap the function with {@link action}() instead, and\n * then TypeScript will be able to detect which overload you're using.)\n *\n * @returns The result of calling `fn(..args)`\n *\n * @category Signals\n */\nexport function peek<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F> {\n    if (!current.cell) return fn(...args);\n    const old = swapCtx(makeCtx(current.job));\n    try { return fn(...args); } finally { freeCtx(swapCtx(old)); }\n}\n\n/**\n * Wrap a function (or decorate a method) so that signals it reads are not added\n * as dependencies to the current rule (if any).  (Basically, it's shorthand for\n * wrapping the function or method body in a giant call to {@link peek}().)\n *\n * So, instead of writing an action function like this:\n *\n * ```ts\n * function outer(arg1, arg2) {\n *     return peek(() => {\n *         // reactive values used here will not be added to the running rule\n *     })\n * }\n * ```\n * you can just write this:\n * ```ts\n * const outer = action((arg1, arg2) => {\n *     // reactive values used here will not be added to the running rule\n * });\n * ```\n * or this:\n * ```ts\n * class Something {\n *     ⁣⁣@action  // auto-detects TC39 or legacy decorators\n *     someMethod(arg1) {\n *         // reactive values used here will not be added to the running rule\n *     }\n * }\n * ```\n *\n * @param fn The function to wrap.  It can take any arguments or return value,\n * and overloads are supported.  However, any non-standard properties the\n * function may have had will *not* be present on the wrapped function, even if\n * TypeScript will act as if they are!\n *\n * @returns A wrapped version of the function that passes through its arguments\n * to the original function, while running with dependency tracking suppressed\n * (as with {@link peek}()).\n *\n * @category Signals\n */\nexport function action<F extends AnyFunction>(fn: F): F;\n\n/** @hidden TC39 Decorator protocol */\nexport function action<F extends AnyFunction>(fn: F, ctx: {kind: \"method\"}): F;\n\n/** @hidden Legacy Decorator protocol */\nexport function action<F extends AnyFunction, D extends {value?: F}>(\n    clsOrProto: any, name: string|symbol, desc: D\n): D\n\nexport function action<F extends AnyFunction, D extends {value?: F}>(fn: F, _ctx?: any, desc?: D): D | F {\n    if (desc) return {...desc, value: action(desc.value)};\n    return <F> function (this: ThisParameterType<F>) {\n        if (!current.cell) return apply(fn, this, arguments);\n        const old = swapCtx(makeCtx(current.job));\n        try { return apply(fn, this, arguments); } finally { freeCtx(swapCtx(old)); }\n    }\n}\n\n/**\n * Wait for and return the next truthy value (or error) from a data source (when\n * processed with `yield *` within a {@link Job}).\n *\n * This differs from {@link next}() in that it waits for the next \"truthy\" value\n * (i.e., not null, false, zero, empty string, etc.), and when used with signals\n * or a signal-using function, it can resume *immediately* if the result is\n * already truthy.  (It also supports zero-argument signal-using functions,\n * automatically wrapping them with {@link cached}(), as the common use case for\n * until() is to wait for an arbitrary condition to be satisfied.)\n *\n * @param source The source to wait on, which can be:\n * - An object with an `\"uneventful.until\"` method returning a {@link Yielding}\n *   (in which case the result will be the the result of calling that method)\n * - A {@link Signal}, or a zero-argument function returning a value based on\n *   signals (in which case the job resumes as soon as the result is truthy,\n *   perhaps immediately)\n * - A {@link Source} (in which case the job resumes on the next truthy value\n *   it produces\n *\n * (Note: if the supplied source is a function with a non-zero `.length`, it is\n * assumed to be a {@link Source}.)\n *\n * @returns a Yieldable that when processed with `yield *` in a job, will return\n * the triggered event, or signal value.  An error is thrown if event stream\n * throws or closes early, or the signal throws.\n *\n * @category Signals\n * @category Scheduling\n */\n\nexport function until<T>(source: UntilMethod<T> | Stream<T> | (() => T)): Yielding<T> {\n    return callOrWait<T>(source, \"uneventful.until\", waitTruthy, recache);\n}\nfunction recache<T>(s: () => T) { return until(cached(s)); }\nfunction waitTruthy<T>(job: Job<T>, v: T) { v && job.return(v); }\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"signals.mjs","sources":["../src/cells.ts","../src/rules.ts","../src/signals.ts"],"sourcesContent":["import { Context, current, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { DisposeFn, Job, OptionalCleanup, RecalcSource } from \"./types.ts\"\nimport { detached, getJob, makeJob } from \"./tracking.ts\";\nimport { Connection, Inlet, IsStream, Sink, Source, backpressure } from \"./streams.ts\";\nimport { apply, arrayEq, setMap } from \"./utils.ts\";\nimport { isError, markHandled } from \"./results.ts\";\nimport { nullCtx } from \"./internals.ts\";\nimport { defer } from \"./defer.ts\";\nimport { Batch, batch } from \"./scheduling.ts\";\nimport { action, peek, type Configurable } from \"./signals.ts\";\n\nconst ruleQueues = new WeakMap<Function, RuleQueue>();\nexport function ruleQueue(scheduleFn: (cb: () => unknown) => unknown = defer) {\n    ruleQueues.has(scheduleFn) || ruleQueues.set(scheduleFn, batch<Cell>(runRules, scheduleFn));\n    return ruleQueues.get(scheduleFn);\n}\n\nexport type RuleQueue = Batch<Cell>;\nexport var currentRule: Cell;\nexport const ruleStops = new WeakMap<Cell, DisposeFn>();\nexport const defaultQ = /* @__PURE__ */ ruleQueue(defer);\n\nvar currentQueue: RuleQueue;\nfunction runRules(this: RuleQueue, q: Set<Cell>) {\n    // another queue is running? reschedule for later\n    if (currentQueue) return;\n    currentQueue = this;\n    try {\n        // run rules marked dirty by value changes\n        for (currentRule of q) {\n            currentRule.catchUp();\n            q.delete(currentRule);\n        }\n    } finally {\n        currentQueue = currentRule = undefined;\n    }\n}\n\n/**\n * Error indicating a rule has attempted to write a value it indirectly\n * depends on, or which has already been read by another rule in the current\n * batch. (Also thrown when a cached function attempts to write a value at all,\n * directly or indirectly.)\n *\n * @category Errors\n */\nexport class WriteConflict extends Error {}\n\n/**\n * Error indicating a rule has attempted to write a value it directly depends\n * on, or a cached function has called itself, directly or indirectly.\n *\n * @category Errors\n */\nexport class CircularDependency extends Error {}\n\nvar timestamp = 1;\n\n/** recalcWhen(fn): map fn -> signal */\nconst fntrackers = new WeakMap<Function, () => number>();\n\n/** recalcWhen(key, factory): map factory -> key -> signal */\nconst obtrackers = new WeakMap<Function, WeakMap<WeakKey, () => number>>();\n\n/** stream controllers for stream+recalcWhen signals */\nconst monitors = new WeakMap<Cell, ()=>void>();\n\n/** Cells whose demand has changed and need to start/stop jobs, etc. */\nexport const demandChanges = batch<Cell>(q => { for(const cell of q) cell.updateDemand(); });\n\nconst dirtyStack: Cell[] = [];\n\nfunction markDependentsDirty(cell: Cell) {\n    // We don't set validThrough here because that's how we tell the cell's been read/depended on\n    const latestSource = cell.latestSource = timestamp;\n    for(; cell; cell = dirtyStack.pop()) {\n        for (let sub=cell.subscribers; sub; sub = sub.nT) {\n            const tgt = sub.tgt;\n            if (tgt.latestSource >= latestSource) continue;\n            tgt.latestSource = latestSource;\n            tgt.queue?.add(tgt);\n            if (tgt.subscribers) dirtyStack.push(tgt);\n        }\n    }\n}\n\n// The .compute for a cell whose value has been explicitly set\nfunction returnValue(this: Cell) {\n    return this.value;\n}\n\n// The compute for a cell whose value is an explicit error\nfunction throwValue(this: Cell) {\n    throw this.value;\n}\n\n/**\n * Cells that are known to be clean as of this timestamp, but have not been\n * marked as read yet (and whose sources might also not be marked read).  This\n * lets us lazily determine if a cell's value has been depended on (i.e.\n * \"virtually read\") in this timestamp, even if it wasn't *actually* read.\n */\nconst notCaughtUp = [] as Cell[];\n\nconst enum Is {\n    Observed = 1 << 0,  // Cell has subscribers or a rule queue\n    Stopped  = 1 << 1,  // Stateful cell requested stop\n    Compute  = 1 << 2,\n    Error    = 1 << 4,\n    Running  = 1 << 5,\n    Stateful = 1 << 6,  // Cell has state (e.g. job, stream) that depends on its observed-ness\n    Mutable  = 1 << 7,\n    Variable = Compute | Mutable,\n}\n\ntype Subscription = {\n    /** Source of the subscription */\n    src: Cell\n    nS: Subscription,\n    pS: Subscription,\n\n    /** Subscriber */\n    tgt: Cell\n    nT: Subscription,\n    pT: Subscription,\n\n    ts: number,\n\n    /* stack for active subscriptions on sources */\n    old: Subscription\n}\n\nvar freesubs: Subscription;\n\nfunction mksub(source: Cell, target: Cell) {\n    let sub: Subscription = freesubs;\n    if (sub) {\n        freesubs = sub.old;\n        sub.src = source; sub.nS = undefined; sub.pS = target.sources;\n        sub.tgt = target; sub.nT = sub.pT = undefined;\n        sub.ts = source.lastChanged; sub.old = source.adding;\n    } else sub = {\n        src: source, nS: undefined, pS: target.sources,\n        tgt: target, nT: undefined, pT: undefined,\n        ts: source.lastChanged, old: source.adding\n    }\n    // Add subscription to tail of target's sources\n    if (target.sources) target.sources.nS = sub;\n    target.sources = sub;\n    // track that this source has had a subscription added during this calculation\n    source.adding = sub;\n    // Set up reciprocal subscription if needed\n    if (target.flags & Is.Observed) source.subscribe(sub);\n}\n\n/** Delete subscription, with recursive constant folding */\nfunction removeConstListener(sub: Subscription) {\n    const{tgt, nS, pS} = sub;\n    if (sub.src.adding === sub) sub.src.adding = sub.old;\n    delsub(sub);\n    // Recurse if its source list becomes empty\n    if (tgt.sources === sub) (tgt.sources = nS || pS) || tgt.becomeConstant();\n}\n\n/** Delete subscription as part of recalc cleanup only */\nfunction delsub(sub: Subscription) {\n    sub.src.unsubscribe(sub);\n    if (sub.nS) sub.nS.pS = sub.pS;\n    if (sub.pS) sub.pS.nS = sub.nS;\n    sub.src = sub.tgt = sub.nS = sub.pS = sub.nT = sub.pT = undefined;\n    sub.old = freesubs;\n    freesubs = sub;\n}\n\nfunction subscribeAll(c: Cell) {\n    for(let s = firstSource(c); s; s = s.nS) s.src.subscribe(s);\n    toggleDemand(c);\n}\n\nfunction unsubscribeAll(c: Cell) {\n    for(let s = firstSource(c); s; s = s.nS) s.src.unsubscribe(s);\n    toggleDemand(c);\n}\n\nconst sentinel = {}  // a unique value for uniqueness checking\n\nfunction firstSource(c: Cell) {\n    let s = c.sources;\n    if (s) while (s.pS) s = s.pS;  // Back up to the start (in case the cell is running)\n    return s;\n}\n\nfunction toggleDemand(c: Cell) {\n    // We toggle the observed flag to match our current state; if we're also\n    // stateful, we need to toggle our \"dirty\" status in the demand queue, too.\n    if (((c.flags ^= Is.Observed) & Is.Stateful) === Is.Stateful) {\n        // If we were already in the queue, then we were dirty in the old state,\n        // which means we're *clean* in the new state, and vice versa.  This\n        // lets us avoid redundant work in the queue when demand briefly\n        // flip-flops (due to e.g. nested rules being restarted).\n        demandChanges.has(c) ? demandChanges.delete(c) : demandChanges.add(c);\n    }\n}\n\nexport class Cell {\n    value: any = undefined // the value\n    validThrough = 0; // timestamp of most recent validation or recalculation\n    lastChanged = 0;  // timestamp of last value change\n    latestSource = timestamp; // max lastChanged of this cell or any ancestor source\n    flags = 0;\n    ctx: Context = undefined;\n    /** The subscription being added during the current calculation - used for uniqueness */\n    adding: Subscription = undefined;\n    /** Linked list of sources */\n    sources: Subscription = undefined;\n    /** Linked list of targets */\n    subscribers: Subscription = undefined;\n    queue: RuleQueue = undefined;\n\n    /**\n     * The computation to be performed (if {@link Is.Compute}) or the\n     * setup/teardown for {@link Is.Stateful}.\n     */\n    compute: (sub?: boolean) => any = returnValue;\n\n    stream<T>(sink: Sink<T>, _conn?: Connection, inlet?: Inlet) {\n        let lastValue = sentinel;\n        Cell.mkRule(() => {\n            const val = this.getValue();\n            if (val !== lastValue) {\n                const old = swapCtx(nullCtx);\n                try { sink(lastValue = val); } finally { swapCtx(old); }\n            }\n        }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);\n        return IsStream;\n    }\n\n    getValue() {\n        if (arguments.length) return apply(this.stream, this, arguments);\n        const dep = current.cell;\n        // Only create a dependency if our value can change\n        if (dep && this.flags & Is.Variable) {\n            if (this.flags & Is.Running) throw new CircularDependency(\"Cached function dependency cycle\");\n            // See if we've already got a subscription node for the dependent\n            let s = this.adding;\n            if (!s || s.tgt !== dep) {\n                // nope, it's new\n                mksub(this, dep);\n                s = this.adding;\n            } else {\n                // Yep, see if it's a hangover from last time\n                if (s.ts === -1) {\n                    // yep, mark it reused\n                    s.ts = this.lastChanged;\n                    if (s.nS) { // if not at end, move it\n                        s.nS.pS = s.pS;\n                        if (s.pS) s.pS.nS = s.nS;\n                        s.nS = undefined;\n                        s.pS = dep.sources;\n                        dep.sources.nS = s;\n                        dep.sources = s;\n                    }\n                }\n                // else it's already done, no need to do anything.\n            }\n            this.catchUp();\n            if (this.adding === s) s.ts = this.lastChanged;\n        } else this.catchUp();\n        if (this.flags & Is.Error) throw this.value;\n        return this.value;\n    }\n\n    shouldWrite(changed: boolean) {\n        const cell = current.cell || currentRule;\n        if (cell) {\n            // When a cell changes within a sweep (i.e. from an active rule or other\n            // cell), we need to check if it's not a circular update or disallowed\n            // side-effect.  In such a case we bail out with an error, even if the\n            // change is idempotent.  (To avoid hiding value-dependent errors.)\n            if (!cell.queue) throw new WriteConflict(\"Side-effects not allowed outside rules\");\n            if (this.adding && this.adding.tgt === cell) throw new CircularDependency(\"Can't update direct dependency\");\n            if (this.validThrough === timestamp || this.hasBeenRead()) throw new WriteConflict(\"Value already used\");\n        } else if (changed) {\n            // We are *not* in a sweep, but *did* have a change.  So we may need to advance\n            // the timestamp, if we might have had readers in the current one.\n            if (this.validThrough === timestamp || notCaughtUp.length) { ++timestamp; notCaughtUp.length = 0; }\n        } else {\n            // Not in a sweep and no change -- no need to actually write anything\n            return false;\n        }\n        // If we changed as of the current timestamp, we're already dirty\n        // Otherwise, we should flag our subscribers as such.\n        (this.lastChanged === timestamp) || markDependentsDirty(this);\n        // If we have sources, reset the subscription timestamp of the first one\n        // to force a recalculation on our next catchUp().  (It should be safe\n        // because if we were running, we'd have thrown \"value already used\" above.)\n        if (this.sources) this.sources.ts = 0;\n        return true;\n    }\n\n    setValue(val: any, isErr: boolean) {\n        if (this.shouldWrite(val !== this.value || isErr !== !!(this.flags & Is.Error))) {\n            this.value = val;\n            this.lastChanged = timestamp;\n            this.flags = isErr ? this.flags | Is.Error : this.flags & ~Is.Error;\n        }\n        // We always reset the compute here because we might have been in the\n        // Calc state.  But we don't clear the Calc flag because we might need\n        // any previous sources to be released or unsubscribed.  (Which will\n        // happen on our next recalc.)\n        this.compute = isErr ? throwValue : returnValue;\n    }\n\n    setCalc(compute: () => any) {\n        if (this.shouldWrite(compute !== this.compute)) {\n            this.flags |= Is.Compute;\n            this.compute = compute;\n            this.ctx ||= makeCtx(null, this);\n        }\n    }\n\n    hasBeenRead() {\n        if (notCaughtUp.length) {\n            for(const cell of notCaughtUp) cell.catchUp();\n            notCaughtUp.length = 0;\n        }\n        return this.validThrough === timestamp;\n    }\n\n    catchUp(): void {\n        const {validThrough} = this;\n        if (validThrough === timestamp) return;\n        this.validThrough = timestamp;\n        if (!(this.flags & Is.Compute)) return;\n        if (this.sources) {\n            for(let sub=this.sources; sub; sub = sub.nS) {\n                const s = sub.src;\n                // changed since our last compute? we're definitely dirty\n                if (sub.ts !== s.lastChanged) return this.doRecalc();\n                // if source is clean, skip it (most should be)\n                // (note: only cells w/subscribers can be trusted as to their\n                // latestSource, as cacheds with no subscribers don't get\n                // notified by their upstreams)\n                if (s.subscribers && s.latestSource <= validThrough) continue;\n                // not a simple yes or no -- \"it's complicated\" -- so recurse\n                s.catchUp();\n                if (s.lastChanged > validThrough) {\n                    return this.doRecalc();\n                }\n            }\n            // If we got to this point, we didn't need to recalc, but that means\n            // none of our sources actually *changed*, despite at least one being\n            // dirty.  But that means we \"virtually\" read the clean values and\n            // therefore depended on them... which means if they get written to,\n            // either the timestamp must change or the write must be blocked.\n            //\n            // So we put them on our notCaughtUp list, in order to prevent rules\n            // from changing them (or their sources) in the same timestamp, and\n            // so that non-rule writes will know to update the timestamp.\n            for(let sub=this.sources; sub; sub = sub.nS) {\n                if (sub.src.validThrough !== timestamp) notCaughtUp.push(sub.src);\n            }\n        } else return this.doRecalc();\n    }\n\n    doRecalc() {\n        const {ctx} = this, oldCtx = swapCtx(ctx);\n        if (this.flags & Is.Stateful) {\n            ctx.job?.restart();\n        }\n        for(let sub = this.sources; sub; sub = sub.nS) {\n            sub.ts = -1; // mark stale for possible reuse\n            // attach sub to its source, so we can look it up\n            sub.old = sub.src.adding;\n            sub.src.adding = sub;\n            this.sources = sub;\n        }\n        this.flags |= Is.Running;\n        try {\n            try {\n                const future = this.compute();\n                if (future !== this.value || !this.lastChanged || this.flags & Is.Error) {\n                    this.value = future;\n                    this.lastChanged = timestamp;\n                }\n                this.flags &= ~Is.Error;\n            } catch(e) {\n                this.flags |= Is.Error\n                this.value = e;\n                this.lastChanged = timestamp;\n                if (currentRule === this) throw e;\n            }\n        } finally {\n            this.flags &= ~Is.Running;\n            if (this.flags & Is.Stateful) {\n                demandChanges.delete(this);\n                if (this.flags & (Is.Error|Is.Stopped)) {\n                    this.flags &= ~Is.Stopped;\n                    ctx.job?.restart();\n                } else if (this.flags & Is.Observed) {\n                } else {\n                    ctx.job?.restart();\n                }\n            }\n            swapCtx(oldCtx);\n            // reset this.src to the head of the list, dropping stale subscriptions\n            let head: Subscription;\n            for(let sub = this.sources; sub; ) {\n                const pS = sub.pS;\n                sub.src.adding = sub.old;\n                sub.old = undefined;\n                if (sub.ts === -1) delsub(sub); else head = sub;\n                sub = pS;\n            }\n            // without sources, we can never change or be invalidated, so flag as uncomputable\n            (this.sources = head) || this.becomeConstant()\n        }\n    }\n\n    becomeConstant() {\n        // Not safe if running, and running cells will do this on exit anyway.\n        // And if we're stateful, we can change by being observed/unobserved, so\n        // aren't really constant.\n        if (this.flags & (Is.Running | Is.Stateful)) return;\n\n        this.flags &= ~Is.Compute;\n\n        // If we're mutable, don't delete subscriptions\n        if (this.flags & Is.Variable) return;\n\n        // It's safe to delete subscriptions in the adding stack, because those\n        // cells are already reading the current value (or not) during their\n        // active recalc.\n        while (this.adding) removeConstListener(this.adding);\n\n        // For any other subscriptions, we only delete ones that match our timestamp,\n        // as they've already read our latest value.  The rest will have to wait\n        // until they recalc, at which point they won't renew their subscription and\n        // it'll get cleared out then.  (And propagate if applicable.)\n        for(let sub = this.subscribers; sub; ) {\n            const {nT} = sub; (sub.ts !== this.lastChanged) || removeConstListener(sub); sub = nT;\n        }\n    }\n\n    stop() {\n        this.setQ(null);\n        // force immediate stop unless we're running (in which case doRecalc\n        // will handle it for us, since we have no demand any more):\n        if (this.flags & Is.Running) { this.flags |= Is.Stopped; } else this.updateDemand();\n        ruleStops.get(this)?.();\n    }\n\n    setQ(queue: RuleQueue|null = defaultQ) {\n        if (queue == this.queue) return;  // use `==` to ignore null/undefined\n        if (!this.subscribers) {\n            // Without subscribers, adding/removing a queue will change demand,\n            // so we'll need to unsubscribe from sources if (and ONLY if) we're\n            // removing a *currently active* queue:\n            queue || !this.queue || unsubscribeAll(this);\n        }\n        if (this.queue) {\n            // Only add to new queue if queued on old\n            if (this.queue.has(this)) queue?.add(this);\n            this.queue.delete(this);\n        } else if (queue) {\n            // initial queue or re-enable, schedule it\n            queue.add(this);\n            // If we already have subscribers, we're already subscribed\n            this.subscribers || subscribeAll(this);\n        }\n        this.queue = queue;\n    }\n\n    subscribe(sub: Subscription) {\n        if (!this.subscribers && !this.queue) {\n            // 0->1 subs, engage demand (unless we already have it via queue)\n            subscribeAll(this);\n        }\n        if (this.subscribers !== sub && !sub.pT) { // avoid adding already-added subs\n            sub.nT = this.subscribers;\n            if (this.subscribers) this.subscribers.pT = sub;\n            this.subscribers = sub;\n        }\n    }\n\n    unsubscribe(sub: Subscription) {\n        if (sub.nT) sub.nT.pT = sub.pT;\n        if (sub.pT) sub.pT.nT = sub.nT;\n        if (this.subscribers === sub) this.subscribers = sub.nT;\n        sub.nT = sub.pT = undefined;\n        if (!this.subscribers && !this.queue) {\n            // 1->0 subs, remove demand (unless we still have it via queue)\n            unsubscribeAll(this);\n        }\n    }\n\n    static mkValue<T>(val: T) {\n        const cell = new Cell;\n        cell.flags = Is.Mutable;\n        cell.value = val;\n        cell.lastChanged = timestamp;\n        return cell;\n    }\n\n    isObserved() {\n        // intentional side effect: start state tracking\n        return !!((this.flags|= Is.Stateful) & Is.Observed);\n    }\n\n    getJob() {\n        this.flags |= Is.Stateful;\n        return this.ctx.job ||= makeJob();\n    }\n\n    updateDemand() {\n        demandChanges.delete(this);\n        if (monitors.has(this)) {\n            monitors.get(this)();\n        } else if (this.flags & Is.Observed) {\n            // Trigger an async update so we run on the right scheduler\n            this.shouldWrite(true);\n        } else {\n            // no demand: restart job if active\n            this.ctx.job?.restart();\n        }\n    }\n\n    static mkStream<T>(src: Source<T>, val?: T) {\n        const cell = this.mkValue(val);\n        cell.flags |= Is.Stateful;\n        const ctx = makeCtx();\n        const write = (v: T) => { cell.setValue(v, false);  };\n        let job: Job<void>;\n        monitors.set(cell, () => {\n            if (!cell.subscribers) {\n                // Last subscriber is gone, so reset to default value\n                write(val);\n                job?.end();  // unsubscribe from source\n                return\n            }\n            if (job) return;\n            job = ctx.job = makeJob<void>().do(r => {\n                if (isError(r)) {\n                    cell.setValue(markHandled(r), true);\n                } else {\n                    cell.setValue(val, false);\n                }\n                ctx.job = job = undefined;\n            });\n            const old = swapCtx(ctx);\n            try {\n                src(write, job);\n            } catch(e) {\n                job.end();\n                detached.asyncThrow(e);\n            } finally {\n                swapCtx(old);\n            }\n        });\n        return cell;\n    }\n\n    recalcWhen(src: RecalcSource): void;\n    recalcWhen<T extends WeakKey>(key: T, factory: (key: T) => RecalcSource): void;\n    recalcWhen<T extends WeakKey>(fnOrKey: T | RecalcSource, fn?: (key: T) => RecalcSource) {\n        let trackers: WeakMap<WeakKey, () => number> = fn ?\n            obtrackers.get(fn) || setMap(obtrackers, fn, new WeakMap) :\n            fntrackers\n        ;\n        let signal = trackers.get(fnOrKey);\n        if (!signal) {\n            const src = fn ? fn(<T>fnOrKey) : <RecalcSource> fnOrKey;\n            let ct = 0;\n            const c = Cell.mkStream(s => (src(() => s(++ct)), IsStream), ct);\n            trackers.set(fnOrKey, signal = c.getValue.bind(c));\n        }\n        signal();  // Subscribe to the cell\n    }\n\n    static mkCached<T>(compute: () => T) {\n        const cell = new Cell;\n        cell.compute = compute;\n        cell.ctx = makeCtx(null, cell);\n        cell.flags = Is.Compute;\n        return cell;\n    }\n\n    static mkRule(fn: () => OptionalCleanup, q: RuleQueue) {\n        const outer = getJob(), cell = Cell.mkCached(() => {\n            try {\n                const cleanup = fn();\n                if (cleanup) (cell.ctx.job || cell.getJob()).must(cleanup);\n                cell.lastChanged = timestamp;\n            } catch (e) {\n                cell.stop();\n                throw e;\n            }\n        }), stop = cell.stop.bind(cell);\n        outer === detached || ruleStops.set(cell, outer.release(stop));\n        cell.setQ(q);\n        return stop;\n    }\n}\n\n/**\n * Keep an expression's old value unless there's a semantic change\n *\n * By default, reactive values (i.e. {@link cached}(), or {@link value}() with a\n * {@link Configurable.setf setf}()) are considered to have \"changed\" (and thus\n * trigger recalculation of their dependents) when they are different according\n * to `===` comparison.\n *\n * This works well for primitive values, but for arrays and objects it's not\n * always ideal, because two arrays can have the exact same elements and still\n * be different according to `===`.  So this function lets you substitute a\n * different comparison function (like a deep-equal or shallow-equal) instead.\n * (The default is {@link arrayEq}() if no compare function is supplied.)\n *\n * Specifically, if your reactive expression returns `unchangedIf(newVal,\n * compare)`, then the expression's previous value will be kept if the compare\n * function returns true when called with the old and new values. Otherwise, the\n * new value will be used.\n *\n * @remarks\n * - If the reactive expression's last \"value\" was an error, the new value is\n *   returned\n * - An error will be thrown if this function is called outside a reactive\n *   expression or from within a {@link peek}() call or {@link action} wrapper.\n *\n * @category Reactive Values\n */\n\nexport function unchangedIf<T>(newVal: T, equals: (v1: T, v2: T) => boolean = arrayEq): T {\n    const {cell} = current;\n    if (cell) {\n        return (cell.flags & Is.Error || !equals(cell.value, newVal)) ? newVal : cell.value;\n    } else {\n        throw new Error(\"unchangedIf() must be called from a reactive expression\");\n    }\n}\n","import { defer } from \"./defer.ts\";\nimport { Cell, RuleQueue, currentRule, defaultQ, ruleQueue } from \"./cells.ts\";\nimport { AnyFunction, DisposeFn, OptionalCleanup } from \"./types.ts\";\nimport { CallableObject, apply, setMap } from \"./utils.ts\";\nimport { detached } from \"./tracking.ts\";\n\n/**\n * A decorator function that supports both TC39 and \"legacy\" decorator protocols\n *\n * @template F the type of method this decorator can decorate.  If the method\n * doesn't conform to this type, compile-time type checks will fail.\n *\n * @category Types and Interfaces\n */\nexport type GenericMethodDecorator<F extends AnyFunction> = {\n    /** TC39 Method Decorator @hidden */\n    (fn: F, ctx?: {kind: \"method\"}): F;\n\n    /** Legacy Method Decorator @hidden */\n    (proto: object, name: string|symbol, desc?: {value?: F}): void;\n}\n\n/**\n * The interface provided by {@link rule}, and other {@link rule.factory}()\n * functions.\n*\n* @category Types and Interfaces\n*/\nexport interface RuleFactory {\n    /**\n     * @inheritdoc rule factory tied to a specific scheduler.  See {@link rule} for\n     * more details.\n     */\n    (fn: () => OptionalCleanup): DisposeFn;\n\n    /**\n     * A function that will stop the currently-executing rule.  (Accessing this\n     * attribute will throw an error if no rule is currently running.)\n     *\n     * Note: this returns the stop for the current rule regardless of its\n     * scheduler, so you can access `rule.stop` even if the rule was created\n     * with a different scheduler.\n     */\n    readonly stop: DisposeFn;\n\n    /**\n     * Observe a condition and apply an action.\n     *\n     * For a given {@link RuleFactory} `r` (such as `rule`), `r.if(condition,\n     * action)` is roughly equivalent to `r(() => { if (condition()) return\n     * action(); })`, except that the rule is *only* rerun if the `action`'s\n     * dependencies change, *or* the **truthiness** of `condition()` changes. It\n     * will *not* be re-run if only the dependencies of `condition()` have\n     * changed, without affecting its truthiness.\n     *\n     * This behavior can be important for rules that nest other rules, have\n     * cleanups, fire off tasks, etc., as it may be wasteful to constantly tear\n     * them down and set them back up if the enabling condition is a calculation\n     * with frequently-changing dependencies.\n     *\n     * @remarks This is just a shortcut for wrapping `condition` as a signal\n     * that converts it to boolean. So if you already *have* a boolean signal,\n     * you can get the same effect with just `if (condition()) { ... }`.\n     */\n    if(condition: () => any, action: () => OptionalCleanup): DisposeFn\n\n    /**\n     * Decorate a method or function to behave as a rule, e.g.\n     *\n     * ```ts\n     * const animate = rule.factory(requestAnimationFrame);\n     *\n     * class Draggable {\n     *     ⁣@animate.method\n     *     trackPosition(handleTop: number, handleLeft: number) {\n     *         const {clientX, clientY} = lastMouseEvent();\n     *         this.element.style.top  = `${clientY - handleTop}px`;\n     *         this.element.style.left = `${clientX - handleLeft}px`;\n     *     }\n     * }\n     *\n     * // Start running the method in an animation frame for every change to\n     * // lastMouseEvent, until the current job ends:\n     * someDraggable.trackPosition(top, left);\n     * ```\n     * or:\n     * ```ts\n     * const logger = rule.method((formatString, signal) => { log(formatString, signal()); });\n     * ```\n     *\n     * Each time it's (explicitly) called, the decorated method will start a new\n     * rule, which will repeatedly run the method body (with the original\n     * arguments and `this`) whenever its dependencies change, according to the\n     * schedule defined by the rule factory.  (So e.g. `@rule.method` will\n     * update on the microtask after a change, etc.)\n     *\n     * The decorated method will always return a {@link DisposeFn} to let you\n     * explicitly stop the rule before the current job end.  But if the original\n     * method body doesn't return a dispose function of its own, TypeScript will\n     * consider the method to return void, unless you explicitly declare its\n     * return type to be `DisposeFn | void`.\n     *\n     * Also note that since rule methods can accept arbitrary parameters, they\n     * do not receive a `stop` parameter, and must therefore use {@link\n     * RuleFactory.stop rule.stop}() if they wish to terminate themselves.\n     */\n    readonly method: GenericMethodDecorator<(...args: any[]) => OptionalCleanup>\n\n    /**\n     * Return a rule factory for the given scheduling function, that you can\n     * then use to make rules that run in a specific time frame.\n     *\n     * ```ts\n     * // `animate` will now create rules that run during animation fames\n     * const animate = rule.factory(requestAnimationFrame);\n     *\n     * animate(() => {\n     *     // ... do stuff in an animation frame when signals used here change\n     * })\n     * ```\n     *\n     * (In addition to being callable, the returned function is also a\n     * {@link RuleFactory}, and thus has a `.method` decorator, `.if()` method,\n     * and so on.)\n     *\n     * @param scheduleFn A single-argument scheduling function (such as\n     * requestAnimationFrame, setImmediate, or queueMicrotask).  The rule\n     * scheduler will call it from time to time with a single callback.  The\n     * scheduling function should then arrange for that callback to be invoked\n     * *once* at some future point, when it is the desired time for all pending\n     * rules on that scheduler to run.\n     *\n     * @returns A {@link RuleFactory}, like {@link rule}.  If called with the\n     * same scheduling function more than once, it returns the same factory.\n     *\n     */\n    factory(scheduleFn: SchedulerFn): RuleFactory\n\n    /**\n     * Create a \"detached\" or standalone rule, that is not attached to any job.\n     *\n     * `r.detached(fn)` is shorthand for calling `detached.run(r, fn)`.  (Where\n     * `r` is a {@link RuleFactory} such as `rule`.)\n     *\n     * Note that since the created rule isn't attached to a job, it *must* be\n     * explicitly stopped, either by calling the returned disposal function or\n     * by the rule function arranging to stop itself via {@link rule.stop}().\n     */\n    detached(fn: () => OptionalCleanup): DisposeFn;\n\n    /**\n     * Change the scheduler used for the currently-executing rule.  Throws an\n     * error if no rule is running.\n     *\n     * @param scheduleFn Optional: The {@link SchedulerFn scheduling function}\n     * to use; the default microtask scheduler will be used if none is given or\n     * the given value is falsy.\n     *\n     * @remarks It's best to only use scheduling functions that were created\n     * *outside* the current rule, otherwise you'll be creating a new scheduling\n     * queue object on every run of the rule.  (These will get garbage collected\n     * with the scheduling functions, but you'll be creating more memory\n     * pressure and using more GC time if the rule runs frequently.)\n     */\n    setScheduler(scheduleFn?: SchedulerFn): void;\n}\n\ntype RuleFunction = (fn: ActionFunction) => DisposeFn\ntype ActionFunction = () => OptionalCleanup\n\nclass RF extends CallableObject<RuleFunction> implements RuleFactory {\n\n    constructor(q: RuleQueue) {\n        super((fn: ActionFunction) => Cell.mkRule(fn, q))\n    }\n\n    get stop() {\n        if (currentRule) return currentRule.stop.bind(currentRule);\n        throw new Error(\"No rule active\");\n    }\n\n    if(condition: () => any, action: () => OptionalCleanup): DisposeFn {\n        const cond = Cell.mkCached(() => !!condition());\n        return this(() => cond.getValue() ? action() : undefined);\n    }\n\n    get method(): GenericMethodDecorator<(...args: any[]) => OptionalCleanup> {\n        const self = this;\n        return (\n            fn: object | ((...args: any[]) => OptionalCleanup),\n            _ctxOrName?: any,\n            desc?: { value?: (...args: any[]) => OptionalCleanup; }\n        ) => {\n            if (desc) return void (desc.value = this.method(desc.value));\n            return function (this: any, ...args: any[]): DisposeFn {\n                return self(() => apply(fn as any, this, args));\n            };\n        }\n    }\n\n    factory(scheduleFn: SchedulerFn): RuleFactory {\n        return factories.get(scheduleFn) || setMap(factories, scheduleFn, new RF(ruleQueue(scheduleFn)));\n    }\n\n    detached(fn: ActionFunction) {\n        return detached.run(this as RuleFunction, fn);\n    }\n\n    setScheduler(scheduleFn?: SchedulerFn): void {\n        if (currentRule) currentRule.setQ(scheduleFn ? ruleQueue(scheduleFn) : defaultQ);\n        else throw new Error(\"No rule active\");\n    }\n}\n\n\nconst factories = new WeakMap<Function, RuleFactory>();\n\n/**\n * Subscribe a function to run every time certain values change.\n *\n * The function is run asynchronously, first after being created, then again\n * after there are changes in any of the {@link value}()s or {@link cached}()\n * functions it read during its previous run.\n *\n * The created subscription is tied to the currently-active job (which may be\n * another rule).  So when that job is ended or restarted, the rule will be\n * terminated automatically.  You can also terminate it early by calling the\n * \"stop\" function that is returned by `rule()`, or by calling\n * {@link rule.stop}() from within the rule function.\n *\n * Note: this function will throw an error if called without an active job. If\n * you need a standalone rule, use {@link RuleFactory.detached rule.detached}().\n *\n * @param fn The function that will be run each time its dependencies change.\n * The function will be run in a restarted job each time, with any resources\n * used by the previous run being cleaned up.  The function is called with no\n * arguments, and should return a cleanup function or void.\n *\n * @returns A function that can be called to terminate the rule.\n *\n * @category Reactive Behaviors\n */\nexport const rule: ((fn: () => OptionalCleanup) => DisposeFn) & RuleFactory = (\n    RF.prototype.factory(defer)\n)\n\n/**\n * Synchronously run any pending rules tied to a specific schedule.\n *\n * (Note: \"pending\" rules are ones with at least one changed ancestor\n * dependency; this doesn't mean they will actually *do* anything, since\n * intermediate cached() function results might end up unchanged.)\n *\n * You should normally only need to call this when you need to *force*\n * side-effects to occur within a specific *synchronous* timeframe, e.g. if\n * rules need to be able to cancel a synchronous event or continue an IndexedDB\n * transaction.  (Otherwise, this is really only useful for testing.)\n *\n * @param scheduleFn The {@link SchedulerFn scheduler} used to create the rule\n * factory you wish to run pending rules for.  If not given, the default\n * {@link rule}() factory is targeted.\n *\n * @category Reactive Behaviors\n */\nexport function runRules(scheduleFn?: SchedulerFn) {\n    (scheduleFn ? ruleQueue(scheduleFn) : defaultQ).flush();\n}\n\n/**\n * A single-argument scheduling function (such as requestAnimationFrame,\n * setImmediate, or queueMicrotask).  The rule scheduler will call it from time\n * to time with a single callback.  The scheduling function should then arrange\n * for that callback to be invoked *once* at some future point, when it is the\n * desired time for all pending rules on that scheduler to run.\n *\n * @category Types and Interfaces\n */\nexport type SchedulerFn = (cb: () => unknown) => unknown;\n","/**\n * The Signals API for uneventful.\n *\n * @module uneventful/signals\n */\n\nimport { current, freeCtx, makeCtx, swapCtx } from \"./ambient.ts\";\nimport { PlainFunction, Yielding, AnyFunction, Job } from \"./types.ts\";\nimport { Cell } from \"./cells.ts\";\nimport { rule } from \"./rules.ts\";\nimport { reject, resolve } from \"./results.ts\";\nimport { UntilMethod } from \"./sinks.ts\";\nimport { SignalSource, Source, Stream } from \"./streams.ts\";\nimport { callOrWait } from \"./call-or-wait.ts\";\nimport { CallableObject, apply } from \"./utils.ts\";\nimport { defer } from \"./defer.ts\";\nimport { next } from \"./sinks.ts\";  // needed for documentation link\n\nexport type * from \"./rules.ts\"\nexport { rule, runRules } from \"./rules.ts\"\nexport { WriteConflict, CircularDependency, unchangedIf } from \"./cells.ts\";\n\n/**\n * An observable value, as a zero-argument callable with extra methods.\n *\n * In addition to being callable, signals also offer a `.value` getter, and\n * implement the standard JS methods `.toString()`, `.valueOf()`, and\n * `.toJSON()` in such a way that they reflect the signal's contents rather than\n * the signal itself.\n *\n * Signals also implement the {@link Source} interface, and can thus be\n * subscribed to.  Subscribers receive the current value first, and then any\n * changes thereafter.  They can be waited on by {@link until}(), in which case\n * the calling job resumes when the signal's value is truthy.\n *\n * You can also transform a signal to a {@link Writable} by calling its\n * .{@link Signal.withSet withSet}() method, or create a writable value using\n * {@link value}().\n *\n * @category Types and Interfaces\n */\nexport interface Signal<T> extends SignalSource<T>, UntilMethod<T> {\n    /**\n     * The current value\n     *\n     * @category Reading\n     */\n    readonly value: T\n\n    /** Current value @hidden */\n    valueOf()  : T\n\n    /** Current value as a string @hidden */\n    toString(): string\n\n    /** The current value @hidden */\n    toJSON()   : T\n\n    /**\n     * Get the signal's current value, without adding the signal as a dependency\n     *\n     * (This is exactly equivalent to calling {@link peek}(signal), and exists\n     * here mainly for interop with other signal frameworks.)\n     *\n     *  @category Reading */\n    peek(): T;\n\n    /** Get a read-only version of this signal @category Reading */\n    asReadonly(): Signal<T>\n\n    /** New writable signal with a custom setter @category Writing */\n    withSet(set: (v: T) => unknown): Writable<T>\n\n    /** @hidden */\n    \"uneventful.until\"(): Yielding<T>;\n}\n\n/** @internal */\nexport class SignalImpl<T> extends CallableObject<SignalSource<T>> implements Signal<T> {\n    constructor(protected _c: Cell) { super(_c.getValue.bind(_c)); }\n    get value() { return this(); }\n    valueOf()   { return this(); }\n    toString()  { return \"\" + this(); }\n    toJSON()    { return this(); }\n    peek()      { return peek(this as () => T); };\n    asReadonly(): Signal<T> { return this; }\n    withSet(set: (v: T) => unknown): Writable<T> {\n        return Object.assign(new WritableImpl<T>(this._c), {set});\n    }\n\n    *\"uneventful.next\"(): Yielding<T> {\n        return yield (r => {\n            let seen = false, res: T;\n            rule(() => {\n                try { res = this(); } catch(e) { rule.stop(); defer(reject.bind(null, r,e)); }\n                if (seen) { rule.stop(); defer(resolve.bind(null, r, res)); }\n                seen = true;\n            })\n        });\n    }\n\n    *\"uneventful.until\"(): Yielding<T> {\n        return yield (r => {\n            let res: T;\n            try { res = this(); } catch(e) { reject(r, e); return; }\n            if (res) return resolve(r, res);\n            rule(() => {\n                try { res = this(); } catch(e) { rule.stop(); defer(reject.bind(null, r,e)); }\n                if (res) { rule.stop(); defer(resolve.bind(null, r, res)); }\n            });\n        });\n    }\n}\n\n/**\n * A {@link Signal} with a {@link Writable.set | .set()} method and writable\n * {@link Writable.value | .value} property.\n *\n * @category Types and Interfaces\n */\nexport interface Writable<T> extends Signal<T>  {\n    /**\n     * Set the current value.  (Note: this is a bound method so it can be used\n     * as a callback.)\n     *\n     * @category Writing\n     */\n    readonly set: (val: T) => void;\n\n    get value(): T\n\n    /** Set the current value */\n    set value(val: T);\n}\n\n/** @internal */\nexport class WritableImpl<T> extends SignalImpl<T> implements Writable<T> {\n    get value() { return this(); }\n    set value(val: T) { this.set(val); }\n    set = (val: T) => { this._c.setValue(val, false); }\n    asReadonly(): Signal<T> {\n        return new SignalImpl<T>(this._c);\n    }\n}\n\n/**\n * A writable signal that can be set to either a value or an expression.\n *\n * Like a spreadsheet cell, a configurable signal can contain either a value or\n * a formula.  If you .set() a value or change the .value property of the\n * signal, the formula is cleared.  Conversely, if you set a formula with\n * .setf(), then the value is calculated using that formula from then on, until\n * another formula is set, or the value is changed directly again.\n *\n * @category Types and Interfaces\n */\nexport interface Configurable<T> extends Writable<T>  {\n    /**\n     * Set a formula that will be used to calculate the signal's value. If it\n     * uses the value of other signals, this signal's value will be recalculated\n     * when they change.\n     *\n     * @category Writing\n     */\n    setf(expr: () => T): this;\n}\n\n/** @internal */\nexport class ConfigurableImpl<T> extends WritableImpl<T> implements Configurable<T> {\n    setf(expr: () => T): this {\n        this._c.setCalc(expr);\n        return this;\n    }\n}\n\n/**\n * Create a {@link Configurable} signal with the given inital value\n *\n * @category Reactive Values\n */\nexport function value<T>(val?: T): Configurable<T> {\n    const cell = Cell.mkValue(val);\n    return new ConfigurableImpl<T>(cell);\n}\n\n/**\n * Create a cached version of a function.  The returned callable is also a\n * {@link Signal}.\n *\n * Note: If the supplied function has a non-zero `.length` (i.e., it explicitly\n * takes arguments), it is assumed to be a {@link Source}, and the second\n * calling signature below will apply, even if TypeScript doesn't see it that\n * way!)\n *\n * @category Reactive Values\n */\nexport function cached<T>(compute: () => T): Signal<T>;\n\n/**\n * If the supplied function has a non-zero `.length` (i.e., it explicitly takes\n * arguments), it is assumed to be a {@link Source}, and the second argument is\n * a default value for the created signal to use as default value until the\n * source produces a value.\n *\n * The source will be subscribed *only* while the signal is subscribed as a\n * stream, or observed (directly or indirectly) by a rule.  While subscribed,\n * the signal will update itself with the most recent value produced by the\n * source, triggering rules or events as appropriate if the value changes.  When\n * the signal is once again unobserved (or if the source ends without an error),\n * its value will revert to the supplied default.\n *\n * If the source ends *with* an error, however, then the cached function will\n * throw that error whenever called, until/unless it becomes unobserved again.\n * (And thus reverts to the default value once more.)\n *\n * @param source A {@link Source} providing data which will become this signal's\n * value\n * @param defaultVal The value to use when the signal is unobserved or waiting for\n * the first item from the source.\n */\nexport function cached<T>(source: Source<T>, defaultVal?: T): Signal<T>;\nexport function cached<T extends Signal<any>>(signal: T): T\nexport function cached<T>(compute: Source<T> | (() => T), initVal?: T): Signal<T> {\n    if (compute instanceof SignalImpl) return compute;\n    return new SignalImpl<T>(\n        compute.length ? Cell.mkStream(compute as Source<T>, initVal) : Cell.mkCached(compute as () => T)\n    );\n}\n\n/**\n * Call a function without creating a dependency on any signals it reads.  (Like\n * {@link Signal.peek}, but for any function with any arguments.)\n *\n * You can also pass in any arguments the function takes, and the function's\n * return value is returned.\n *\n * (Note: Typed overloads are not supported: TypeScript will use the function's\n * *last* overload for argument-typing purposes.  If you need to call a function\n * with a specific overload, wrap the function with {@link action}() instead, and\n * then TypeScript will be able to detect which overload you're using.)\n *\n * @returns The result of calling `fn(..args)`\n *\n * @category Reactive Values\n */\nexport function peek<F extends PlainFunction>(fn: F, ...args: Parameters<F>): ReturnType<F> {\n    if (!current.cell) return fn(...args);\n    const old = swapCtx(makeCtx(current.job));\n    try { return fn(...args); } finally { freeCtx(swapCtx(old)); }\n}\n\n/**\n * Wrap a function (or decorate a method) so that signals it reads are not added\n * as dependencies to the current rule (if any).  (Basically, it's shorthand for\n * wrapping the function or method body in a giant call to {@link peek}().)\n *\n * So, instead of writing an action function like this:\n *\n * ```ts\n * function outer(arg1, arg2) {\n *     return peek(() => {\n *         // reactive values used here will not be added to the running rule\n *     })\n * }\n * ```\n * you can just write this:\n * ```ts\n * const outer = action((arg1, arg2) => {\n *     // reactive values used here will not be added to the running rule\n * });\n * ```\n * or this:\n * ```ts\n * class Something {\n *     ⁣⁣@action  // auto-detects TC39 or legacy decorators\n *     someMethod(arg1) {\n *         // reactive values used here will not be added to the running rule\n *     }\n * }\n * ```\n *\n * @param fn The function to wrap.  It can take any arguments or return value,\n * and overloads are supported.  However, any non-standard properties the\n * function may have had will *not* be present on the wrapped function, even if\n * TypeScript will act as if they are!\n *\n * @returns A wrapped version of the function that passes through its arguments\n * to the original function, while running with dependency tracking suppressed\n * (as with {@link peek}()).\n *\n * @category Reactive Behaviors\n */\nexport function action<F extends AnyFunction>(fn: F): F;\n\n/** @hidden TC39 Decorator protocol */\nexport function action<F extends AnyFunction>(fn: F, ctx: {kind: \"method\"}): F;\n\n/** @hidden Legacy Decorator protocol */\nexport function action<F extends AnyFunction, D extends {value?: F}>(\n    clsOrProto: any, name: string|symbol, desc: D\n): D\n\nexport function action<F extends AnyFunction, D extends {value?: F}>(fn: F, _ctx?: any, desc?: D): D | F {\n    if (desc) return {...desc, value: action(desc.value)};\n    return <F> function (this: ThisParameterType<F>) {\n        if (!current.cell) return apply(fn, this, arguments);\n        const old = swapCtx(makeCtx(current.job));\n        try { return apply(fn, this, arguments); } finally { freeCtx(swapCtx(old)); }\n    }\n}\n\n/**\n * Wait for and return the next truthy value (or error) from a data source (when\n * processed with `yield *` within a {@link Job}).\n *\n * This differs from {@link next}() in that it waits for the next \"truthy\" value\n * (i.e., not null, false, zero, empty string, etc.), and when used with signals\n * or a signal-using function, it can resume *immediately* if the result is\n * already truthy.  (It also supports zero-argument signal-using functions,\n * automatically wrapping them with {@link cached}(), as the common use case for\n * until() is to wait for an arbitrary condition to be satisfied.)\n *\n * @param source The source to wait on, which can be:\n * - An object with an `\"uneventful.until\"` method returning a {@link Yielding}\n *   (in which case the result will be the the result of calling that method)\n * - A {@link Signal}, or a zero-argument function returning a value based on\n *   signals (in which case the job resumes as soon as the result is truthy,\n *   perhaps immediately)\n * - A {@link Source} (in which case the job resumes on the next truthy value\n *   it produces\n *\n * (Note: if the supplied source is a function with a non-zero `.length`, it is\n * assumed to be a {@link Source}.)\n *\n * @returns a Yieldable that when processed with `yield *` in a job, will return\n * the triggered event, or signal value.  An error is thrown if event stream\n * throws or closes early, or the signal throws.\n *\n * @category Scheduling\n */\n\nexport function until<T>(source: UntilMethod<T> | Stream<T> | (() => T)): Yielding<T> {\n    return callOrWait<T>(source, \"uneventful.until\", waitTruthy, recache);\n}\nfunction recache<T>(s: () => T) { return until(cached(s)); }\nfunction waitTruthy<T>(job: Job<T>, v: T) { v && job.return(v); }\n"],"names":["runRules"],"mappings":"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"}

package/dist/{sinks-kEzJo6Hc.d.ts → sinks-5TuxCRtX.d.ts}

@@ -178,5 +178,30 @@ declare function recalcWhen(src: RecalcSource): void;
  * function, not a closure, or the same memory thrash issue will occur!)
  */
 declare function recalcWhen<T extends WeakKey>(key: T, factory: (key: T) => RecalcSource): void;
+/**
+ * Find out whether the active signal is being observed, or just queried.
+ *
+ * If the return value is true, the caller is running within a signal
+ * calculation that is being observed by subscribers (such as a rule or stream
+ * listener).  If the return value is false, the caller is running within a
+ * signal calculation that is *not* observed by any subscribers, and the signal
+ * will be recalculated whenever it transitions from unobserved to observed.
+ *
+ * Returns `undefined` if the caller isn't running in a signal calculation.
+ *
+ * @remarks Note that calling this function within a signal calculation even
+ * once adds a *permanent*, implicit dependency to that signal, on whether the
+ * signal is being observed.  (As does using any job APIs directly.)
+ *
+ * The assumption here is that if you're checking whether it's observed, it's
+ * because you only want to do certain things *while* it's being observed, so
+ * the signal needs to be recalculated when it *starts* being observed, so you
+ * can do those things.  (If you need to undo or clean up those things when the
+ * signal is no-longer observed, you can register a cleanup callback via e.g.
+ * {@link must}(), or wrap them in a sub-job with start, connect, etc.)
+ *
+ * @category Signals
+ */
+declare function isObserved(): boolean | undefined;
 
-export { type EachResult as E, type NextMethod as N, type UntilMethod as U, type Each as a, each as e, forEach as f, next as n, recalcWhen as r };
+export { type EachResult as E, type NextMethod as N, type UntilMethod as U, type Each as a, each as e, forEach as f, isObserved as i, next as n, recalcWhen as r };

package/dist/utils-P0JEpWXG.mjs

@@ -0,0 +1,87 @@
+let defer = typeof queueMicrotask === "function" ? queueMicrotask : /* @__PURE__ */ ((p) => (cb) => p.then(cb))(Promise.resolve());
+
+function batch(process, sched) {
+  return new _Batch(process, sched);
+}
+class _Batch {
+  constructor(reap, sched) {
+    this.reap = reap;
+    this.sched = sched;
+    this._flags = 0 /* Unset */;
+    this.q = /* @__PURE__ */ new Set();
+    this._run = () => {
+      this._flags &= ~2 /* Scheduled */;
+      this.flush();
+    };
+    /** Run all pending items */
+    this.flush = () => {
+      if (this._flags & 1 /* Running */)
+        return;
+      const { q: queue } = this;
+      if (!queue.size)
+        return;
+      this._flags |= 1 /* Running */;
+      try {
+        this.reap(queue);
+      } finally {
+        this._flags &= ~1 /* Running */;
+        !queue.size || this._flags & 2 /* Scheduled */ || this._sched();
+      }
+    };
+  }
+  /** Is this queue currently running? */
+  isRunning() {
+    return !!(this._flags & 1 /* Running */);
+  }
+  /** Is this queue currently empty? */
+  isEmpty() {
+    return !this.q.size;
+  }
+  add(subject) {
+    this.q.size || this._flags & (1 /* Running */ | 2 /* Scheduled */) || this._sched();
+    this.q.add(subject);
+  }
+  delete(subject) {
+    this.q.delete(subject);
+  }
+  has(subject) {
+    return this.q.has(subject);
+  }
+  _sched() {
+    this._flags |= 2 /* Scheduled */;
+    (this.sched || defer)(this._run);
+  }
+}
+
+const isArray = Array.isArray;
+function arrayEq(a, b) {
+  return a === b || isArray(a) && isArray(b) && a.length === b.length && a.every(same, b);
+}
+function same(item, idx) {
+  return item === this[idx];
+}
+function setMap(map, key, val) {
+  map.set(key, val);
+  return val;
+}
+function isFunction(f) {
+  return typeof f === "function";
+}
+const CallableObject = /* @__PURE__ */ (() => Object.assign(
+  function CallableObject2(fn) {
+    return Object.setPrototypeOf(fn, new.target.prototype);
+  },
+  { prototype: Function.prototype }
+  // No need to have extra prototypes in the chain
+))();
+const apply = Reflect.apply;
+const GeneratorBase = /* @__PURE__ */ (() => {
+  function G() {
+  }
+  G.prototype = function* () {
+  }.constructor.prototype.prototype;
+  return G;
+})();
+
+export { CallableObject as C, GeneratorBase as G, arrayEq as a, batch as b, apply as c, defer as d, isArray as e, isFunction as i, setMap as s };
+//# sourceMappingURL=utils-P0JEpWXG.mjs.map

package/dist/utils-P0JEpWXG.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-P0JEpWXG.mjs","sources":["../src/defer.ts","../src/scheduling.ts","../src/utils.ts"],"sourcesContent":["/**\n * Invoke a no-argument function as a microtask, using queueMicrotask or Promise.resolve().then()\n *\n * @category Scheduling\n */\nexport let defer: (cb: () => any) => void =\n    typeof queueMicrotask === \"function\" ?\n        queueMicrotask :\n        (p => (cb: () => any) => p.then(cb))(Promise.resolve());\n\n/**\n * @internal For testing use only!\n *\n */\nexport function setDefer(fn: typeof defer) {\n    defer = fn;\n}","import { defer } from \"./defer.ts\";\n\n/** Scheduler state flags */\nconst enum Is {\n    Unset = 0,\n    _ = 1,\n    Running   = _ << 0,\n    Scheduled = _ << 1,\n}\n\n/**\n * A generic batch processing queue, implemented as a set.  (So items are\n * processed at most once per batch run.)\n *\n * @template T The type of items that will be in the batch\n *\n * @category Scheduling\n */\nexport interface Batch<T> {\n    /** Is the batch processing function currently running? */\n    isRunning(): boolean;\n\n    /** Is the batch currently empty? */\n    isEmpty(): boolean;\n\n    /**\n     * Add an item to the batch.  Schedules the batch for processing if the\n     * batch was empty and is not already scheduled.  (Does nothing if the\n     * item is already in the batch.)\n     */\n    add(item: T): void;\n\n    /** Remove an item from the batch.  (Does not affect the schedule.) */\n    delete(item: T): void;\n\n    /** Is the item in the batch? */\n    has(item: any): boolean;\n\n    /**\n     * Process the batch now by calling the processing function, unless the\n     * batch is empty or already running.  If the processing function exits\n     * without fully emptying the batch (due to errors, time limits, etc.),\n     * another flush will be scheduled via the batch's scheduler (unless one is\n     * already scheduled).\n     */\n    readonly flush: () => void;\n}\n\n\n/**\n * Create a batch processing queue from the given processing loop and scheduling\n * function.\n *\n * @template T The type of items that will be in the batch\n *\n * @param process A function taking a set of items.  It should remove items from\n * the set, usually *before* processing them.  (So that the batch won't\n * perpetually block on that item in case of a persistent error.)  If the\n * processing function doesn't remove all items from the set, another processing\n * pass will be done later.  (This allows you to rate-limit processing, so as\n * not to hog the current thread.)\n *\n * @param sched A single-argument scheduling function (like\n * requestAnimationFrame, setImmediate, or queueMicrotask).  The batch will call\n * it from time to time with a single callback.  The scheduling function should\n * then arrange for that callback to be invoked *once* at some future point,\n * when it is the desired time for pending items to be processed.  If no\n * function is given (or it's undefined/null), {@link defer} is used.\n *\n * @returns a {@link Batch} that items can be added to for later processing.\n *\n * @category Scheduling\n */\nexport function batch<T>(process: (items: Set<T>) => void, sched?: (cb: () => unknown) => unknown): Batch<T> {\n    return new _Batch(process, sched);\n}\n\n/**\n * A generic queue for things that need to be run at-most-once per item\n * per timeframe.\n *\n * @category Scheduling\n */\nclass _Batch<T> implements Batch<T> {\n    protected _flags: Is = Is.Unset;\n    protected readonly q = new Set<T>();\n\n    constructor(\n        protected readonly reap: (queue: Set<T>) => void,\n        protected readonly sched: ((cb: () => unknown) => unknown) | undefined | null,\n    ) {}\n\n    /** Is this queue currently running? */\n    isRunning() { return !!(this._flags & Is.Running); }\n\n    /** Is this queue currently empty? */\n    isEmpty() { return !this.q.size; }\n\n    add(subject: T) {\n        this.q.size || this._flags & (Is.Running|Is.Scheduled) || this._sched();\n        this.q.add(subject);\n    }\n\n    delete(subject: any) {\n        this.q.delete(subject);\n    }\n\n    has(subject: any) {\n        return this.q.has(subject);\n    }\n\n    protected _sched() {\n        this._flags |= Is.Scheduled;\n        (this.sched || defer)(this._run);\n    }\n\n    protected _run = () => {\n        this._flags &= ~Is.Scheduled;\n        this.flush();\n    }\n\n    /** Run all pending items */\n    flush = () => {\n        // already running? skip it\n        if (this._flags & Is.Running) return;\n        const {q: queue} = this;\n        // nothing to do? skip it\n        if (!queue.size) return;\n        this._flags |= Is.Running;\n        try {\n            this.reap(queue);\n        } finally {\n            this._flags &= ~Is.Running;\n            // schedule again if we're stopping early due to error\n            !queue.size || (this._flags & Is.Scheduled) || this._sched();\n        }\n    }\n}\n","/**\n * Utilities that aren't part of Uneventful's core feature set, but are exposed\n * anyway, because they're boilerplate that can save duplication elsewhere if\n * you happen to need them.\n *\n * @module uneventful/utils\n */\nimport { AnyFunction } from \"./types.ts\";\n\n/**\n * Shorthand for Array.isArray()\n *\n * @category Data Structures\n */\nexport const isArray = Array.isArray;\n\n/**\n * Return true if the supplied parameters are the same object/vaue, or are\n * arrays with identical contents.\n *\n * @category Data Structures\n */\nexport function arrayEq<T>(a: readonly T[] | null | undefined, b: readonly T[] | null | undefined): boolean;\nexport function arrayEq<T>(a: any, b: any): boolean;\nexport function arrayEq<T>(a: readonly T[] | null | undefined, b: readonly T[] | null | undefined) {\n    return (a===b) || (isArray(a) && isArray(b) && a.length === b.length && a.every(same, b))\n}\n\nfunction same(this: any[], item: any, idx:  number) { return item === this[idx]; }\n\n/**\n * Set a value in a Map or WeakMap, and return the value.\n *\n * Commonly used with constructions like `return map.get(key) ?? setMap(map,\n * key, calculateDefault())`.\n *\n * @template K The type of key accepted by the map\n * @template V The type of value accepted by the map\n *\n * @category Data Structures\n */\nexport function setMap<K, V>(map: { set(key: K, val: V): void; }, key: K, val: V) {\n    map.set(key, val);\n    return val;\n}\n\n/**\n * Is the given value a function?  (Shorthand for `typeof f === \"function\"`)\n *\n * @category Functional Programming\n */\nexport function isFunction(f: any): f is Function {\n    return typeof f === \"function\";\n}\n\n/**\n * This class hides the implementation details of inheriting from Function in\n * the documentation.  (By default, typedoc exposes all the inherited properties\n * and members, which we don't want.  By inheriting from it instead of from\n * Function, we keep the documentation free of unimportant details.)\n *\n * The way this works is that you subclass CallableObject and define a\n * constructor that calls `super(someClosure)` where `someClosure` is a unique\n * function object, which will then pick up any properties or methods defined by\n * the subclass.\n *\n * @template T The call/return signature that instances of the class will\n * implement.\n *\n * @category Functional Programming\n */\n//@ts-ignore not really a duplicate\nexport declare class CallableObject<T extends AnyFunction> extends Function {\n    /**\n     * @param fn A unique function or closure, to be passed to super() in a\n     * subclass.  The function object will gain a prototype from `new.target`,\n     * thereby picking up any properties or methods defined by the class,\n     * and becoming `this` for the calling constructor.\n     *\n     * (Note that calling the constructor by any means other than super() from\n     * a constructor will result in an error or some other unhelpful result.)\n     */\n    constructor(fn: T);\n    /** @internal */ declare length: number;\n    /** @internal */ declare arguments: any;\n    /** @internal */ declare caller: Function;\n    /** @internal */ declare prototype: any;\n    /** @internal */ declare name: string;\n}\n//@ts-ignore CallableObject<T> adheres to the constraint of T in its *implementation*\nexport interface CallableObject<T extends AnyFunction> extends T {\n    /** @internal */ [Symbol.hasInstance](value: any): boolean;\n    /** @internal */ apply(this: Function, thisArg: any, argArray?: any): any;\n    /** @internal */ bind(this: Function, thisArg: any, ...argArray: any[]): any;\n    /** @internal */ call(this: Function, thisArg: any, ...argArray: any[]): any;\n    /** @internal */ toString(): string;\n}\n//@ts-ignore This is the real implementation of the above declarations\nexport const CallableObject = /* @__PURE__ */ ( () => <typeof CallableObject> Object.assign(\n    function CallableObject<T>(fn: T) { return Object.setPrototypeOf(fn, new.target.prototype); },\n    {prototype: Function.prototype }  // No need to have extra prototypes in the chain\n))();\n\nexport { batch, type Batch } from \"./scheduling.ts\";\n\n/**\n * Calls the `target` function with the given object as the `this` value and the\n * elements of given array as the arguments.\n *\n * @category Functional Programming\n */\nexport const apply = Reflect.apply;\n\n/**\n * A pseudo-constructor for the abstract ancestor type of all generators,\n * useful for testing whether something is `instanceof Generator`.\n *\n * @category Data Structures\n */\nexport const GeneratorBase = /* @__PURE__ */ (() => {\n    function G() {}; G.prototype = (function *(){}).constructor.prototype.prototype;\n    return G as any as abstract new () => Generator;\n})()\n"],"names":[],"mappings":"AAAU,IAAC,KAAK,GAAG,OAAO,cAAc,KAAK,UAAU,GAAG,cAAc,mBAAmB,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,OAAO,EAAE;;ACQjI,SAAS,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE;AACtC,EAAE,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AACpC,CAAC;AACD,MAAM,MAAM,CAAC;AACb,EAAE,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE;AAC3B,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;AACrB,IAAI,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;AACvB,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,aAAa;AAChC,IAAI,IAAI,CAAC,CAAC,mBAAmB,IAAI,GAAG,EAAE,CAAC;AACvC,IAAI,IAAI,CAAC,IAAI,GAAG,MAAM;AACtB,MAAM,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,iBAAiB;AACxC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;AACnB,KAAK,CAAC;AACN;AACA,IAAI,IAAI,CAAC,KAAK,GAAG,MAAM;AACvB,MAAM,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC;AACzB,QAAQ,OAAO;AACf,MAAM,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC;AAChC,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI;AACrB,QAAQ,OAAO;AACf,MAAM,IAAI,CAAC,MAAM,IAAI,CAAC,eAAe;AACrC,MAAM,IAAI;AACV,QAAQ,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACzB,OAAO,SAAS;AAChB,QAAQ,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,eAAe;AACxC,QAAQ,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,oBAAoB,IAAI,CAAC,MAAM,EAAE,CAAC;AACxE,OAAO;AACP,KAAK,CAAC;AACN,GAAG;AACH;AACA,EAAE,SAAS,GAAG;AACd,IAAI,OAAO,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,eAAe,CAAC;AAC7C,GAAG;AACH;AACA,EAAE,OAAO,GAAG;AACZ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;AACxB,GAAG;AACH,EAAE,GAAG,CAAC,OAAO,EAAE;AACf,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;AACxF,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AACxB,GAAG;AACH,EAAE,MAAM,CAAC,OAAO,EAAE;AAClB,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;AAC3B,GAAG;AACH,EAAE,GAAG,CAAC,OAAO,EAAE;AACf,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAC/B,GAAG;AACH,EAAE,MAAM,GAAG;AACX,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,iBAAiB;AACrC,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;AACrC,GAAG;AACH;;AC3DY,MAAC,OAAO,GAAG,KAAK,CAAC,QAAQ;AAC9B,SAAS,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE;AAC9B,EAAE,OAAO,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAC1F,CAAC;AACD,SAAS,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE;AACzB,EAAE,OAAO,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,CAAC;AAC5B,CAAC;AACM,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE;AACtC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACpB,EAAE,OAAO,GAAG,CAAC;AACb,CAAC;AACM,SAAS,UAAU,CAAC,CAAC,EAAE;AAC9B,EAAE,OAAO,OAAO,CAAC,KAAK,UAAU,CAAC;AACjC,CAAC;AACW,MAAC,cAAc,mBAAmB,CAAC,MAAM,MAAM,CAAC,MAAM;AAClE,EAAE,SAAS,eAAe,CAAC,EAAE,EAAE;AAC/B,IAAI,OAAO,MAAM,CAAC,cAAc,CAAC,EAAE,EAAE,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAC3D,GAAG;AACH,EAAE,EAAE,SAAS,EAAE,QAAQ,CAAC,SAAS,EAAE;AACnC;AACA,CAAC,IAAI;AAEO,MAAC,KAAK,GAAG,OAAO,CAAC,MAAM;AACvB,MAAC,aAAa,mBAAmB,CAAC,MAAM;AACpD,EAAE,SAAS,CAAC,GAAG;AACf,GAAG;AAEH,EAAE,CAAC,CAAC,SAAS,GAAG,aAAa;AAC7B,GAAG,CAAC,WAAW,CAAC,SAAS,CAAC,SAAS,CAAC;AACpC,EAAE,OAAO,CAAC,CAAC;AACX,CAAC;;;;"}

package/dist/utils.d.ts

@@ -1,5 +1,63 @@
 import { A as AnyFunction } from './types-N2ua11te.js';
 
+/**
+ * A generic batch processing queue, implemented as a set.  (So items are
+ * processed at most once per batch run.)
+ *
+ * @template T The type of items that will be in the batch
+ *
+ * @category Scheduling
+ */
+interface Batch<T> {
+    /** Is the batch processing function currently running? */
+    isRunning(): boolean;
+    /** Is the batch currently empty? */
+    isEmpty(): boolean;
+    /**
+     * Add an item to the batch.  Schedules the batch for processing if the
+     * batch was empty and is not already scheduled.  (Does nothing if the
+     * item is already in the batch.)
+     */
+    add(item: T): void;
+    /** Remove an item from the batch.  (Does not affect the schedule.) */
+    delete(item: T): void;
+    /** Is the item in the batch? */
+    has(item: any): boolean;
+    /**
+     * Process the batch now by calling the processing function, unless the
+     * batch is empty or already running.  If the processing function exits
+     * without fully emptying the batch (due to errors, time limits, etc.),
+     * another flush will be scheduled via the batch's scheduler (unless one is
+     * already scheduled).
+     */
+    readonly flush: () => void;
+}
+/**
+ * Create a batch processing queue from the given processing loop and scheduling
+ * function.
+ *
+ * @template T The type of items that will be in the batch
+ *
+ * @param process A function taking a set of items.  It should remove items from
+ * the set, usually *before* processing them.  (So that the batch won't
+ * perpetually block on that item in case of a persistent error.)  If the
+ * processing function doesn't remove all items from the set, another processing
+ * pass will be done later.  (This allows you to rate-limit processing, so as
+ * not to hog the current thread.)
+ *
+ * @param sched A single-argument scheduling function (like
+ * requestAnimationFrame, setImmediate, or queueMicrotask).  The batch will call
+ * it from time to time with a single callback.  The scheduling function should
+ * then arrange for that callback to be invoked *once* at some future point,
+ * when it is the desired time for pending items to be processed.  If no
+ * function is given (or it's undefined/null), {@link defer} is used.
+ *
+ * @returns a {@link Batch} that items can be added to for later processing.
+ *
+ * @category Scheduling
+ */
+declare function batch<T>(process: (items: Set<T>) => void, sched?: (cb: () => unknown) => unknown): Batch<T>;
+
 /**
  * Utilities that aren't part of Uneventful's core feature set, but are exposed
  * anyway, because they're boilerplate that can save duplication elsewhere if
@@ -8,6 +66,20 @@ import { A as AnyFunction } from './types-N2ua11te.js';
  * @module uneventful/utils
  */
 
+/**
+ * Shorthand for Array.isArray()
+ *
+ * @category Data Structures
+ */
+declare const isArray: (arg: any) => arg is any[];
+/**
+ * Return true if the supplied parameters are the same object/vaue, or are
+ * arrays with identical contents.
+ *
+ * @category Data Structures
+ */
+declare function arrayEq<T>(a: readonly T[] | null | undefined, b: readonly T[] | null | undefined): boolean;
+declare function arrayEq<T>(a: any, b: any): boolean;
 /**
  * Set a value in a Map or WeakMap, and return the value.
  *
@@ -16,12 +88,16 @@ import { A as AnyFunction } from './types-N2ua11te.js';
  *
  * @template K The type of key accepted by the map
  * @template V The type of value accepted by the map
+ *
+ * @category Data Structures
  */
 declare function setMap<K, V>(map: {
     set(key: K, val: V): void;
 }, key: K, val: V): V;
 /**
  * Is the given value a function?  (Shorthand for `typeof f === "function"`)
+ *
+ * @category Functional Programming
  */
 declare function isFunction(f: any): f is Function;
 /**
@@ -37,6 +113,8 @@ declare function isFunction(f: any): f is Function;
  *
  * @template T The call/return signature that instances of the class will
  * implement.
+ *
+ * @category Functional Programming
  */
 declare class CallableObject<T extends AnyFunction> extends Function {
     /**
@@ -53,6 +131,20 @@ declare class CallableObject<T extends AnyFunction> extends Function {
 interface CallableObject<T extends AnyFunction> extends T {
 }
 declare const CallableObject: any;
+
+/**
+ * Calls the `target` function with the given object as the `this` value and the
+ * elements of given array as the arguments.
+ *
+ * @category Functional Programming
+ */
 declare const apply: typeof Reflect.apply;
+/**
+ * A pseudo-constructor for the abstract ancestor type of all generators,
+ * useful for testing whether something is `instanceof Generator`.
+ *
+ * @category Data Structures
+ */
+declare const GeneratorBase: abstract new () => Generator;
 
-export { CallableObject, apply, isFunction, setMap };
+export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, isArray, isFunction, setMap };