uneventful 0.0.11 → 0.0.13

package/dist/call-or-wait-CvOF0pao.mjs

@@ -0,0 +1,22 @@
+import { s as start, j as connect, p as isValue, h as isError, f as markHandled } from './jobutils-O9tOTNKC.mjs';
+import { i as isFunction } from './utils-BgqyDPjA.mjs';
+
+function callOrWait(source, method, handler, noArgs) {
+  if (source && isFunction(source[method]))
+    return source[method]();
+  if (!isFunction(source))
+    mustBeSourceOrSignal();
+  return (source.length === 0 ? noArgs(source) : false) || start((job) => {
+    connect(source, (v) => handler(job, v)).do((r) => {
+      if (isValue(r))
+        job.throw(new Error("Stream ended"));
+      else if (isError(r))
+        job.throw(markHandled(r));
+    });
+  });
+}
+function mustBeSourceOrSignal() {
+  throw new TypeError("not a source or signal");
+}
+
+export { callOrWait as c, mustBeSourceOrSignal as m };

package/dist/ext.d.ts

@@ -1,4 +1,4 @@
-import { P as PlainFunction } from './types-N2ua11te.js';
+import { P as PlainFunction } from './types-pElgImr7.js';
 
 /**
  * This module provides helpers for creating *extensions*: a way of extending
@@ -15,8 +15,7 @@ import { P as PlainFunction } from './types-N2ua11te.js';
  *
  * @module uneventful/ext
  *
- * @experimental
- *
+ * @disableGroups
  * @summary Tools for extending objects with extra state and behavior, without
  * directly modifying them.
  */
@@ -100,23 +99,19 @@ declare function ext<Target extends WeakKey, ExtType extends Object>(factory: (t
  * arguments (minus an initial `target` argument).
  */
 declare function method<Target extends object, Method extends PlainFunction>(factory: (tgt: Target, map: WeakMap<Target, Method>) => Method, map?: WeakMap<Target, Method>): (tgt: Target, ...args: Parameters<Method>) => ReturnType<Method>;
-/** Helper types for working with {@link Ext} Subclasses */
+/** Helper types for working with {@link Ext} Subclasses @experimental */
 declare namespace Ext {
     /** Get the target type of an {@link Ext} subclass constructor */
     type Target<T extends Ext.Class> = InstanceType<T>["of"];
     /**
      * Get the type of extension that will be returned by the static API.
      *
-     * Defaults to the subclass instance type, but can be overridden by `declare
-     * readonly __type__: OtherType` in a subclass, so long as the
-     * {@link Ext.__new__ `__new__()`} method is also overridden to return that
-     * type.
+     * Defaults to the subclass instance type, but can be changed by overriding
+     * {@link Ext.__new__ `__new__()`} to return a different type.
      */
     type Type<T extends Ext.Class> = InstanceType<T> extends {
-        __type__: infer R;
+        __new__(ob: any): infer R;
     } ? (unknown extends R ? InstanceType<T> : R) : InstanceType<T>;
-    /** The type of weakmap passed to {@link Ext.__new__ `__new__()`} */
-    type Map<Class extends Ext.Class> = WeakMap<Ext.Target<Class>, any>;
     /**
      * The type constraint for static generics in the API; you probably won't use this directly.
      */
@@ -148,6 +143,8 @@ declare namespace Ext {
  *
  * Instance and static members you can override to customize extension creation,
  * deletion, target and return types.
+ *
+ * @experimental
  */
 declare abstract class Ext<Target extends WeakKey = WeakKey> {
     /**
@@ -160,28 +157,13 @@ declare abstract class Ext<Target extends WeakKey = WeakKey> {
      */
     readonly of: Target;
     /**
-     * A "virtual" property you can override in subclasses to change the static
-     * interface's return type.  For example, if a subclass does `declare readonly __type__:
-     * Promise<this>`, and overrides `__new__`() to return a promise, then the
-     * static APIs for the subclass (like `.for()`) will return promises instead
-     * of instances. (See the {@link __new__ `__new__`} method for more
-     * details.)
+     * @deprecated Use `.for()` or `prototype.__inst__()` instead!
      *
-     * Note: this property is not actually set by any code, so you can't do anything
-     * other than declare it.  It's just a hack to work around TypeScript's limited
-     * type parameterization for static generics.
-     *
-     * @category Lifecycle Hooks
-     */
-    readonly __type__: unknown;
-    /**
-     * @deprecated Use .for() instead!
-     *
-     * Never directly call the constructor of an Ext subclass except from the
-     * {@link __new__ `__new__()`} method - otherwise you run the risk of having
-     * multiple instances for the same target.  (And it may accept invalid
-     * parameter values if you've redefined the type of the {@link Ext.of `of`}
-     * property in a sub-subclass.)
+     * Never directly call the constructor of an Ext subclass.  If you're
+     * creating an instance in {@link __new__ `__new__()`}, use the
+     * {@link __inst__ `__inst__()`} method instead.  Otherwise,
+     * you should use the .for or .get methods, as they are properly typed
+     * and won't create multiple instances for the same target.
      */
     constructor(of: Target);
     /**
@@ -215,22 +197,16 @@ declare abstract class Ext<Target extends WeakKey = WeakKey> {
      * behavior, e.g. to execute the constructor within a job, or create a
      * promise for an extension instance to be asynchronously initiaized, etc.
      *
-     * If you will be creating something other than an instance of the subclass,
-     * you must also redeclare the type of the {@link __type__ `__type__`}
-     * property.  For example:
+     * For example:
      *
      * ```ts
-     * class AsyncExt extends Ext {
-     *     declare readonly __type__: Job<this>
-     *
+     * class AsyncExt extends Ext<SomeType> {
      *     // simulate slow initialization
      *     *setup() { yield *sleep(100); return this; }
      *
-     *     static __new__<Class extends typeof AsyncExt>(
-     *         tgt: Ext.Target<Class>, map: Ext.Map<Class>
-     *     ) {
-     *         const ext = new this(tgt);
-     *         map.set(tgt, root.start(ext.setup()) as Ext.Type<Class>);
+     *     __new__(tgt: SomeType): Job<this> {
+     *         const ext = this.__inst__(tgt);
+     *         return start(this.__inst__(tgt).setup())
      *     }
      * }
      * ```
@@ -239,13 +215,25 @@ declare abstract class Ext<Target extends WeakKey = WeakKey> {
      * extension whose `setup()` has finished. (And subclasses of `AsyncExt`
      * will share the same behavior, while being subtyped appropriately.)
      *
-     * (Note: your `__new__` method *must* store what it created in the supplied
-     * map for the given target, and the value it sets must conform to the
-     * declared `__type__`, which is *not* checked for you by TypeScript!)
+     * @remarks Note that while this is technically an instance method, it's
+     * actually called with the class *prototype*, so you should not use any
+     * properties or methods of `this` other than `__inst__`.  Think of it
+     * as a function that's just on the class as a convenient way of configuring
+     * it.
+     *
+     * @category Lifecycle Hooks
+     */
+    __new__<C extends Ext>(this: C, tgt: C["of"]): unknown;
+    /**
+     * Given a target, create an extension instance.
+     *
+     * You do not need to override this, nor should you: it's just a type-safe
+     * way to construct an extension instance, since an Ext subclass's
+     * constructor may accept a wider type than the class actually requires.
      *
      * @category Lifecycle Hooks
      */
-    static __new__<Class extends Ext.Class>(this: Class, tgt: Ext.Target<Class>, map: Ext.Map<Class>): void;
+    __inst__<T extends Ext>(this: T, tgt: T["of"]): T;
     /**
      * This method is called by {@link delete}() if it finds an existing
      * extension for the target. You can override it in a subclass to do any

package/dist/ext.mjs

@@ -1,4 +1,4 @@
-import { s as setMap } from './utils-cyEhnyp7.mjs';
+import { s as setMap } from './utils-BgqyDPjA.mjs';
 
 function ext(factory, map = /* @__PURE__ */ new WeakMap()) {
   return (tgt) => map.has(tgt) ? map.get(tgt) : setMap(map, tgt, factory(tgt, map));
@@ -9,13 +9,13 @@ function method(factory, map = /* @__PURE__ */ new WeakMap()) {
 const classMap = /* @__PURE__ */ ext((cls) => /* @__PURE__ */ new WeakMap());
 class Ext {
   /**
-   * @deprecated Use .for() instead!
+   * @deprecated Use `.for()` or `prototype.__inst__()` instead!
    *
-   * Never directly call the constructor of an Ext subclass except from the
-   * {@link __new__ `__new__()`} method - otherwise you run the risk of having
-   * multiple instances for the same target.  (And it may accept invalid
-   * parameter values if you've redefined the type of the {@link Ext.of `of`}
-   * property in a sub-subclass.)
+   * Never directly call the constructor of an Ext subclass.  If you're
+   * creating an instance in {@link __new__ `__new__()`}, use the
+   * {@link __inst__ `__inst__()`} method instead.  Otherwise,
+   * you should use the .for or .get methods, as they are properly typed
+   * and won't create multiple instances for the same target.
    */
   constructor(of) {
     this.of = of;
@@ -26,7 +26,7 @@ class Ext {
    */
   static for(tgt) {
     const map = classMap(this);
-    return map.get(tgt) ?? (this.__new__(tgt, map), map.get(tgt));
+    return map.get(tgt) ?? setMap(map, tgt, this.prototype.__new__(tgt));
   }
   /**
    * Get the current extension instance for the given target, or `undefined`
@@ -64,22 +64,16 @@ class Ext {
    * behavior, e.g. to execute the constructor within a job, or create a
    * promise for an extension instance to be asynchronously initiaized, etc.
    *
-   * If you will be creating something other than an instance of the subclass,
-   * you must also redeclare the type of the {@link __type__ `__type__`}
-   * property.  For example:
+   * For example:
    *
    * ```ts
-   * class AsyncExt extends Ext {
-   *     declare readonly __type__: Job<this>
-   *
+   * class AsyncExt extends Ext<SomeType> {
    *     // simulate slow initialization
    *     *setup() { yield *sleep(100); return this; }
    *
-   *     static __new__<Class extends typeof AsyncExt>(
-   *         tgt: Ext.Target<Class>, map: Ext.Map<Class>
-   *     ) {
-   *         const ext = new this(tgt);
-   *         map.set(tgt, root.start(ext.setup()) as Ext.Type<Class>);
+   *     __new__(tgt: SomeType): Job<this> {
+   *         const ext = this.__inst__(tgt);
+   *         return start(this.__inst__(tgt).setup())
    *     }
    * }
    * ```
@@ -88,14 +82,28 @@ class Ext {
    * extension whose `setup()` has finished. (And subclasses of `AsyncExt`
    * will share the same behavior, while being subtyped appropriately.)
    *
-   * (Note: your `__new__` method *must* store what it created in the supplied
-   * map for the given target, and the value it sets must conform to the
-   * declared `__type__`, which is *not* checked for you by TypeScript!)
+   * @remarks Note that while this is technically an instance method, it's
+   * actually called with the class *prototype*, so you should not use any
+   * properties or methods of `this` other than `__inst__`.  Think of it
+   * as a function that's just on the class as a convenient way of configuring
+   * it.
+   *
+   * @category Lifecycle Hooks
+   */
+  __new__(tgt) {
+    return this.__inst__(tgt);
+  }
+  /**
+   * Given a target, create an extension instance.
+   *
+   * You do not need to override this, nor should you: it's just a type-safe
+   * way to construct an extension instance, since an Ext subclass's
+   * constructor may accept a wider type than the class actually requires.
    *
    * @category Lifecycle Hooks
    */
-  static __new__(tgt, map) {
-    map.set(tgt, new this(tgt, map));
+  __inst__(tgt) {
+    return new this.constructor(tgt);
   }
   /**
    * This method is called by {@link delete}() if it finds an existing