uneventful 0.0.9 → 0.0.11

package/dist/shared.mjs

@@ -0,0 +1,52 @@
+import { c as root, m as must, s as start, n as noop } from './jobutils-Dvu-e99o.mjs';
+import { a as isGeneratorFunction, b as decorateMethod, i as isFunction, c as apply, s as setMap } from './utils-cyEhnyp7.mjs';
+
+function service(factory) {
+  let known = false, value = void 0;
+  if (isGeneratorFunction(factory))
+    factory = fork(factory);
+  return () => {
+    if (known)
+      return value;
+    root.start(() => {
+      value = factory();
+      known = true;
+      must(() => {
+        value = void 0;
+        known = false;
+      });
+    });
+    return value;
+  };
+}
+function expiring(obj) {
+  const p = Proxy.revocable(obj, {});
+  must(p.revoke);
+  return p.proxy;
+}
+function fork(genOrFunc, ...args) {
+  if (args.length)
+    return decorateMethod(fork, genOrFunc, ...args);
+  if (isFunction(genOrFunc))
+    return function(...args2) {
+      return fork(apply(genOrFunc, this, args2));
+    };
+  else {
+    if (forks.has(genOrFunc))
+      return forks.get(genOrFunc);
+    const job = start();
+    start(function* run() {
+      try {
+        job.return(yield* genOrFunc);
+      } catch (e) {
+        job.throw(e);
+      }
+      yield noop;
+    });
+    const it = { [Symbol.iterator]: job[Symbol.iterator].bind(job) };
+    return setMap(forks, it, setMap(forks, genOrFunc, it));
+  }
+}
+const forks = /* @__PURE__ */ new WeakMap();
+
+export { expiring, fork, service };

package/dist/signals.d.ts

@@ -131,6 +131,9 @@ interface RuleFactory {
      */
     factory(scheduleFn: SchedulerFn): RuleFactory;
     /**
+     * @deprecated Use {@link RuleFactory.root} instead
+     *
+     * ---
      * Create a "detached" or standalone rule, that is not attached to any job.
      *
      * `r.detached(fn)` is shorthand for calling `detached.run(r, fn)`.  (Where
@@ -141,6 +144,17 @@ interface RuleFactory {
      * by the rule function arranging to stop itself via {@link rule.stop}().
      */
     detached(fn: () => OptionalCleanup): DisposeFn;
+    /**
+     * Create a standalone rule, not attached to the current job.
+     *
+     * `r.root(fn)` is shorthand for calling `root.run(r, fn)`, where `r` is a
+     * {@link RuleFactory} such as `rule`.
+     *
+     * The created rule will run until the {@link root} job stops, unless
+     * explicitly stopped.  (Either by calling the returned disposal function or
+     * by the rule function arranging to stop itself via {@link rule.stop}().)
+     */
+    root(fn: () => OptionalCleanup): DisposeFn;
     /**
      * Change the scheduler used for the currently-executing rule.  Throws an
      * error if no rule is running.
@@ -171,7 +185,7 @@ interface RuleFactory {
  * {@link rule.stop}() from within the rule function.
  *
  * Note: this function will throw an error if called without an active job. If
- * you need a standalone rule, use {@link RuleFactory.detached rule.detached}().
+ * you need a standalone rule, use {@link RuleFactory.root rule.root}().
  *
  * @param fn The function that will be run each time its dependencies change.
  * The function will be run in a restarted job each time, with any resources
@@ -181,6 +195,7 @@ interface RuleFactory {
  * @returns A function that can be called to terminate the rule.
  *
  * @category Reactive Behaviors
+ * @function
  */
 declare const rule: ((fn: () => OptionalCleanup) => DisposeFn) & RuleFactory;
 /**
@@ -327,9 +342,16 @@ interface Writable<T> extends Signal<T> {
      * @category Writing
      */
     readonly set: (val: T) => void;
-    get value(): T;
-    /** Set the current value */
-    set value(val: T);
+    value: T;
+    /**
+     * Update the current value with a patch function
+     *
+     * Note: this reads the signal's current value, which may produce a write
+     * conflict or circular dependency if you call it from inside a rule.
+     *
+     * @category Writing
+     */
+    edit(patch: (before: T) => T): void;
 }
 /**
  * A writable signal that can be set to either a value or an expression.

package/dist/signals.mjs

@@ -1,5 +1,6 @@
-import { M as swapCtx, N as nullCtx, c as backpressure, I as IsStream, p as current, O as makeCtx, B as makeJob, h as isError, f as markHandled, d as detached, g as getJob, v as reject, b as resolve, P as freeCtx, l as callOrWait } from './call-or-wait-DpJBh_pS.mjs';
-import { b as batch, a as arrayEq, d as defer, c as apply, s as setMap, C as CallableObject } from './utils-P0JEpWXG.mjs';
+import { F as pushCtx, G as popCtx, w as makeJob, c as root, f as isError, e as markHandled, g as getJob, x as detached, k as currentCell, o as reject, b as resolve } from './jobutils-Dvu-e99o.mjs';
+import { b as backpressure, I as IsStream, a as callOrWait } from './call-or-wait-EzXJX5Dq.mjs';
+import { e as batch, f as arrayEq, d as defer, c as apply, s as setMap, C as CallableObject } from './utils-cyEhnyp7.mjs';
 
 const ruleQueues = /* @__PURE__ */ new WeakMap();
 function ruleQueue(scheduleFn = defer) {
@@ -31,6 +32,14 @@ var timestamp = 1;
 const fntrackers = /* @__PURE__ */ new WeakMap();
 const obtrackers = /* @__PURE__ */ new WeakMap();
 const monitors = /* @__PURE__ */ new WeakMap();
+const staleStreams = batch((q) => {
+  for (const cell of q)
+    if (!cell.subscribers) {
+      ++timestamp;
+      break;
+    }
+  q.clear();
+});
 const demandChanges = batch((q) => {
   for (const cell of q)
     cell.updateDemand();
@@ -128,6 +137,7 @@ function toggleDemand(c) {
     demandChanges.has(c) ? demandChanges.delete(c) : demandChanges.add(c);
   }
 }
+let dummySource;
 class Cell {
   constructor() {
     this.value = void 0;
@@ -139,7 +149,7 @@ class Cell {
     this.latestSource = timestamp;
     // max lastChanged of this cell or any ancestor source
     this.flags = 0;
-    this.ctx = void 0;
+    this.job = void 0;
     /** The subscription being added during the current calculation - used for uniqueness */
     this.adding = void 0;
     /** Linked list of sources */
@@ -158,11 +168,11 @@ class Cell {
     Cell.mkRule(() => {
       const val = this.getValue();
       if (val !== lastValue) {
-        const old = swapCtx(nullCtx);
+        pushCtx();
         try {
           sink(lastValue = val);
         } finally {
-          swapCtx(old);
+          popCtx();
         }
       }
     }, inlet ? ruleQueue(backpressure(inlet)) : defaultQ);
@@ -171,8 +181,8 @@ class Cell {
   getValue() {
     if (arguments.length)
       return apply(this.stream, this, arguments);
-    const dep = current.cell;
-    if (dep && this.flags & 132 /* Variable */) {
+    const dep = currentCell;
+    if (dep && this.flags & 132 /* Variable */ && (dep.flags & 8 /* Peeking */) === 0) {
       if (this.flags & 32 /* Running */)
         throw new CircularDependency("Cached function dependency cycle");
       let s = this.adding;
@@ -203,7 +213,7 @@ class Cell {
     return this.value;
   }
   shouldWrite(changed) {
-    const cell = current.cell || currentRule;
+    const cell = currentCell || currentRule;
     if (cell) {
       if (!cell.queue)
         throw new WriteConflict("Side-effects not allowed outside rules");
@@ -236,7 +246,6 @@ class Cell {
     if (this.shouldWrite(compute !== this.compute)) {
       this.flags |= 4 /* Compute */;
       this.compute = compute;
-      this.ctx ||= makeCtx(null, this);
     }
   }
   hasBeenRead() {
@@ -252,8 +261,13 @@ class Cell {
     if (validThrough === timestamp)
       return;
     this.validThrough = timestamp;
-    if (!(this.flags & 4 /* Compute */))
+    if (!(this.flags & 4 /* Compute */)) {
+      if (this.flags & 256 /* Stream */ && !this.subscribers) {
+        this.lastChanged = timestamp;
+        staleStreams.add(this);
+      }
       return;
+    }
     if (this.sources) {
       for (let sub = this.sources; sub; sub = sub.nS) {
         const s = sub.src;
@@ -274,9 +288,9 @@ class Cell {
       return this.doRecalc();
   }
   doRecalc() {
-    const { ctx } = this, oldCtx = swapCtx(ctx);
+    pushCtx(this.job, this);
     if (this.flags & 64 /* Stateful */) {
-      ctx.job?.restart();
+      this.job?.restart();
     }
     for (let sub = this.sources; sub; sub = sub.nS) {
       sub.ts = -1;
@@ -306,12 +320,12 @@ class Cell {
         demandChanges.delete(this);
         if (this.flags & (16 /* Error */ | 2 /* Stopped */)) {
           this.flags &= ~2 /* Stopped */;
-          ctx.job?.restart();
+          this.job?.restart();
         } else if (this.flags & 1 /* Observed */) ; else {
-          ctx.job?.restart();
+          this.job?.restart();
         }
       }
-      swapCtx(oldCtx);
+      popCtx();
       let head;
       for (let sub = this.sources; sub; ) {
         const pS = sub.pS;
@@ -327,8 +341,12 @@ class Cell {
     }
   }
   becomeConstant() {
-    if (this.flags & (32 /* Running */ | 64 /* Stateful */))
+    if (this.flags & 32 /* Running */)
       return;
+    if (this.flags & 64 /* Stateful */) {
+      mksub(dummySource ||= Cell.mkValue(null), this);
+      return;
+    }
     this.flags &= ~4 /* Compute */;
     if (this.flags & 132 /* Variable */)
       return;
@@ -395,11 +413,15 @@ class Cell {
     return cell;
   }
   isObserved() {
+    if (this.flags & 8 /* Peeking */)
+      return false;
     return !!((this.flags |= 64 /* Stateful */) & 1 /* Observed */);
   }
   getJob() {
+    if (this.job)
+      return this.job;
     this.flags |= 64 /* Stateful */;
-    return this.ctx.job ||= makeJob();
+    return this.job = makeJob();
   }
   updateDemand() {
     demandChanges.delete(this);
@@ -408,13 +430,12 @@ class Cell {
     } else if (this.flags & 1 /* Observed */) {
       this.shouldWrite(true);
     } else {
-      this.ctx.job?.restart();
+      this.job?.restart();
     }
   }
   static mkStream(src, val) {
     const cell = this.mkValue(val);
-    cell.flags |= 64 /* Stateful */;
-    const ctx = makeCtx();
+    cell.flags |= 64 /* Stateful */ | 256 /* Stream */;
     const write = (v) => {
       cell.setValue(v, false);
     };
@@ -427,27 +448,39 @@ class Cell {
       }
       if (job)
         return;
-      job = ctx.job = makeJob().do((r) => {
+      job = makeJob(root).do((r) => {
         if (isError(r)) {
           cell.setValue(markHandled(r), true);
         } else {
           cell.setValue(val, false);
         }
-        ctx.job = job = void 0;
+        job = void 0;
       });
-      const old = swapCtx(ctx);
+      pushCtx(job);
       try {
         src(write, job);
       } catch (e) {
         job.end();
-        detached.asyncThrow(e);
+        root.asyncThrow(e);
       } finally {
-        swapCtx(old);
+        popCtx();
       }
     });
     return cell;
   }
+  peek(fn, thisArg, args) {
+    if (this.flags & 8 /* Peeking */)
+      return apply(fn, thisArg, args);
+    this.flags |= 8 /* Peeking */;
+    try {
+      return apply(fn, thisArg, args);
+    } finally {
+      this.flags &= ~8 /* Peeking */;
+    }
+  }
   recalcWhen(fnOrKey, fn) {
+    if (this.flags & 8 /* Peeking */)
+      return;
     let trackers = fn ? obtrackers.get(fn) || setMap(obtrackers, fn, /* @__PURE__ */ new WeakMap()) : fntrackers;
     let signal = trackers.get(fnOrKey);
     if (!signal) {
@@ -461,7 +494,6 @@ class Cell {
   static mkCached(compute) {
     const cell = new Cell();
     cell.compute = compute;
-    cell.ctx = makeCtx(null, cell);
     cell.flags = 4 /* Compute */;
     return cell;
   }
@@ -470,20 +502,20 @@ class Cell {
       try {
         const cleanup = fn();
         if (cleanup)
-          (cell.ctx.job || cell.getJob()).must(cleanup);
-        cell.lastChanged = timestamp;
+          (cell.job || cell.getJob()).must(cleanup);
       } catch (e) {
         cell.stop();
         throw e;
       }
     }), stop = cell.stop.bind(cell);
     outer === detached || ruleStops.set(cell, outer.release(stop));
+    cell.flags |= 64 /* Stateful */;
     cell.setQ(q);
     return stop;
   }
 }
 function unchangedIf(newVal, equals = arrayEq) {
-  const { cell } = current;
+  const cell = currentCell;
   if (cell) {
     return cell.flags & 16 /* Error */ || !equals(cell.value, newVal) ? newVal : cell.value;
   } else {
@@ -520,6 +552,9 @@ class RF extends CallableObject {
   detached(fn) {
     return detached.run(this, fn);
   }
+  root(fn) {
+    return root.run(this, fn);
+  }
   setScheduler(scheduleFn) {
     if (currentRule)
       currentRule.setQ(scheduleFn ? ruleQueue(scheduleFn) : defaultQ);
@@ -619,6 +654,9 @@ class WritableImpl extends SignalImpl {
   asReadonly() {
     return new SignalImpl(this._c);
   }
+  edit(patch) {
+    this.set(patch(this()));
+  }
 }
 class ConfigurableImpl extends WritableImpl {
   setf(expr) {
@@ -638,27 +676,13 @@ function cached(compute, initVal) {
   );
 }
 function peek(fn, ...args) {
-  if (!current.cell)
-    return fn(...args);
-  const old = swapCtx(makeCtx(current.job));
-  try {
-    return fn(...args);
-  } finally {
-    freeCtx(swapCtx(old));
-  }
+  return currentCell ? currentCell.peek(fn, null, args) : fn(...args);
 }
 function action(fn, _ctx, desc) {
   if (desc)
     return { ...desc, value: action(desc.value) };
-  return function() {
-    if (!current.cell)
-      return apply(fn, this, arguments);
-    const old = swapCtx(makeCtx(current.job));
-    try {
-      return apply(fn, this, arguments);
-    } finally {
-      freeCtx(swapCtx(old));
-    }
+  return function(...args) {
+    return currentCell ? currentCell.peek(fn, this, args) : apply(fn, this, args);
   };
 }
 function until(source) {
@@ -672,4 +696,3 @@ function waitTruthy(job, v) {
 }
 
 export { CircularDependency, ConfigurableImpl, SignalImpl, WritableImpl, WriteConflict, action, cached, peek, rule, runRules, unchangedIf, until, value };
-//# sourceMappingURL=signals.mjs.map

package/dist/{utils-P0JEpWXG.mjs → utils-cyEhnyp7.mjs}

@@ -53,6 +53,10 @@ class _Batch {
   }
 }
 
+function decorateMethod(decorate, fn, _ctxOrName, desc) {
+  const method = decorate(desc ? desc.value : fn);
+  return desc ? { ...desc, value: method } : method;
+}
 const isArray = Array.isArray;
 function arrayEq(a, b) {
   return a === b || isArray(a) && isArray(b) && a.length === b.length && a.every(same, b);
@@ -67,14 +71,17 @@ function setMap(map, key, val) {
 function isFunction(f) {
   return typeof f === "function";
 }
-const CallableObject = /* @__PURE__ */ (() => Object.assign(
+const CallableObject = /* @__PURE__ */ (() => {
   function CallableObject2(fn) {
     return Object.setPrototypeOf(fn, new.target.prototype);
-  },
-  { prototype: Function.prototype }
-  // No need to have extra prototypes in the chain
-))();
+  }
+  CallableObject2.prototype = Function.prototype;
+  return CallableObject2;
+})();
 const apply = Reflect.apply;
+function call(fn, thisArg, ...args) {
+  return thisArg ? apply(fn, thisArg, args) : args.length ? fn(...args) : fn();
+}
 const GeneratorBase = /* @__PURE__ */ (() => {
   function G() {
   }
@@ -82,6 +89,8 @@ const GeneratorBase = /* @__PURE__ */ (() => {
   }.constructor.prototype.prototype;
   return G;
 })();
+function isGeneratorFunction(fn) {
+  return isFunction(fn) && fn.prototype instanceof GeneratorBase;
+}
 
-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
+export { CallableObject as C, GeneratorBase as G, isGeneratorFunction as a, decorateMethod as b, apply as c, defer as d, batch as e, arrayEq as f, isArray as g, call as h, isFunction as i, setMap as s };

package/dist/utils.d.ts

@@ -66,14 +66,51 @@ declare function batch<T>(process: (items: Set<T>) => void, sched?: (cb: () => u
  * @module uneventful/utils
  */
 
+/**
+ * Helper for creating hybrid legacy/TC39 decorator/wrapper functions, e.g.:
+ *
+ * ```ts
+ * // As wrapper function
+ * export function myDecorator<T>(fn: SomeFnType<T>): SomeFnType<T>;
+ *
+ * // TC39 decorator
+ * export function myDecorator<T>(fn: SomeFnType<T>, ctx: {kind: "method"}): SomeFnType<T>
+ *
+ * // "Legacy"/"TypeScript Experimental" Decorator
+ * export function myDecorator<T,D extends {value?: SomeFnType<T>}>(clsOrProto:any, name: string|symbol, desc: D): D
+ *
+ * // Implementation
+ * export function myDecorator<T>(factory: SomeFnType<T>, ...args: any[]): SomeFnType<T> {
+ *     // extra args means we're being used as a decorator, so run as decorator:
+ *     if (args.length) return decorateMethod(myDecorator, factory, ...args as [any, any]);
+ *     // No extra args, we're b
+ *     return () => {
+ *     }
+ * }
+ * ```
+ *
+ * Yes, this is fairly ugly, but it's also the **only** way to make this work
+ * when the wrapper is a generic function.  (TypeScript's type system doesn't
+ * allow generic values, declaring functions as implementing interfaces,
+ * higher-order kinds, or any other tricks that would let you avoid this giant
+ * ball of boilerplate for generic decorators.)
+ *
+ * @category Functions and Decorators
+ */
+declare function decorateMethod<F extends AnyFunction, D extends {
+    value?: F;
+}>(decorate: (fn: F) => F, fn: F, _ctxOrName: string | symbol | {
+    kind: "method";
+}, desc?: D): F | D;
 /**
  * Shorthand for Array.isArray()
  *
  * @category Data Structures
+ * @function
  */
 declare const isArray: (arg: any) => arg is any[];
 /**
- * Return true if the supplied parameters are the same object/vaue, or are
+ * Return true if the supplied parameters are the same object/value, or are
  * arrays with identical contents.
  *
  * @category Data Structures
@@ -97,54 +134,68 @@ declare function setMap<K, V>(map: {
 /**
  * Is the given value a function?  (Shorthand for `typeof f === "function"`)
  *
- * @category Functional Programming
+ * @category Functions and Decorators
  */
 declare function isFunction(f: any): f is Function;
 /**
- * This class hides the implementation details of inheriting from Function in
- * the documentation.  (By default, typedoc exposes all the inherited properties
- * and members, which we don't want.  By inheriting from it instead of from
- * Function, we keep the documentation free of unimportant details.)
+ * A base class for creating callable objects.
  *
  * The way this works is that you subclass CallableObject and define a
- * constructor that calls `super(someClosure)` where `someClosure` is a unique
+ * constructor that calls `super(someClosure)` where `someClosure` is a *unique*
  * function object, which will then pick up any properties or methods defined by
  * the subclass.
  *
+ * (Note: It needs to be unique because the `super()` call only sets its
+ * prototype, and returns the function you passed as `this`.  So if you call it
+ * with the same function more than once, you're just reinitializing the same
+ * object instead of creating a new one.)
+ *
  * @template T The call/return signature that instances of the class will
  * implement.
  *
- * @category Functional Programming
+ * @param fn A unique function or closure, to be passed to super() in a
+ * subclass.  The function object will gain a prototype from `new.target`,
+ * thereby picking up any properties or methods defined by the class, and
+ * becoming `this` for the calling constructor.
+ *
+ * (Note that calling the constructor by any means other than super() from a
+ * constructor will result in an error or some other unhelpful result.)
+ *
+ * @category Functions and Decorators
  */
-declare class CallableObject<T extends AnyFunction> extends Function {
-    /**
-     * @param fn A unique function or closure, to be passed to super() in a
-     * subclass.  The function object will gain a prototype from `new.target`,
-     * thereby picking up any properties or methods defined by the class,
-     * and becoming `this` for the calling constructor.
-     *
-     * (Note that calling the constructor by any means other than super() from
-     * a constructor will result in an error or some other unhelpful result.)
-     */
-    constructor(fn: T);
-}
-interface CallableObject<T extends AnyFunction> extends T {
-}
-declare const CallableObject: any;
+declare const CallableObject: new <T extends AnyFunction>(fn: T) => T;
 
 /**
  * Calls the `target` function with the given object as the `this` value and the
- * elements of given array as the arguments.
+ * elements of given array as the arguments.  (Shorthand for Reflect.apply)
  *
- * @category Functional Programming
+ * @category Functions and Decorators
+ * @function
  */
 declare const apply: typeof Reflect.apply;
+/**
+ * Like `fn.call(thisArg, ...args)`, but monomorphic, and the `thisArg`
+ * parameter can be omitted or null.
+ *
+ * This is mostly useful as syntax sugar for an immediately-evaluated function
+ * expression, replacing `(() => {...})()` with `call(() => {...})`.
+ *
+ * @category Functions and Decorators
+ */
+declare function call<F extends AnyFunction>(fn: F, thisArg?: ThisParameterType<F>, ...args: Parameters<F>): ReturnType<F>;
 /**
  * A pseudo-constructor for the abstract ancestor type of all generators,
  * useful for testing whether something is `instanceof Generator`.
  *
  * @category Data Structures
+ * @class
  */
 declare const GeneratorBase: abstract new () => Generator;
+/**
+ * Is the given function a native generator function?
+ *
+ * @category Functions and Decorators
+ */
+declare function isGeneratorFunction<G extends Generator<any, any, any> = Generator>(fn: any): fn is (this: any, ...args: any[]) => G;
 
-export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, isArray, isFunction, setMap };
+export { type Batch, CallableObject, GeneratorBase, apply, arrayEq, batch, call, decorateMethod, isArray, isFunction, isGeneratorFunction, setMap };

package/dist/utils.mjs

@@ -1,2 +1 @@
-export { C as CallableObject, G as GeneratorBase, c as apply, a as arrayEq, b as batch, e as isArray, i as isFunction, s as setMap } from './utils-P0JEpWXG.mjs';
-//# sourceMappingURL=utils.mjs.map
+export { C as CallableObject, G as GeneratorBase, c as apply, f as arrayEq, e as batch, h as call, b as decorateMethod, g as isArray, i as isFunction, a as isGeneratorFunction, s as setMap } from './utils-cyEhnyp7.mjs';