uneventful 0.0.4 → 0.0.6

package/dist/utils.d.ts

@@ -0,0 +1,58 @@
+import { A as AnyFunction } from './types-N2ua11te.js';
+
+/**
+ * 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
+ * you happen to need them.
+ *
+ * @module uneventful/utils
+ */
+
+/**
+ * Set a value in a Map or WeakMap, and return the value.
+ *
+ * Commonly used with constructions like `return map.get(key) ?? setMap(map,
+ * key, calculateDefault())`.
+ *
+ * @template K The type of key accepted by the map
+ * @template V The type of value accepted by the map
+ */
+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"`)
+ */
+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.)
+ *
+ * The way this works is that you subclass CallableObject and define a
+ * 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.
+ *
+ * @template T The call/return signature that instances of the class will
+ * implement.
+ */
+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 apply: typeof Reflect.apply;
+
+export { CallableObject, apply, isFunction, setMap };

package/dist/utils.mjs

@@ -0,0 +1,18 @@
+function setMap(map, key, val) {
+  map.set(key, val);
+  return val;
+}
+function isFunction(f) {
+  return typeof f === "function";
+}
+const CallableObject = () => 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;
+
+export { CallableObject, apply, isFunction, setMap };
+//# sourceMappingURL=utils.mjs.map

package/dist/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","sources":["../src/utils.ts"],"sourcesContent":["/**\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 * 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 */\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 */\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//@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 const {apply} = Reflect;\n"],"names":[],"mappings":"AAAO,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,GAAG,MAAM,MAAM,CAAC,MAAM;AACjD,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,EAAE;AACU,MAAC,EAAE,KAAK,EAAE,GAAG;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "uneventful",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "description": "Declarative, event-driven reactivity: signals, streams, structured concurrency, and easy resource cleanup",
     "keywords": [
         "signals",
@@ -15,11 +15,28 @@
     "homepage": "https://uneventful.js.org",
     "license": "ISC",
     "type": "module",
-    "files": ["./dist/*"],
+    "types": "./dist/mod.d.ts",
+    "files": [
+        "./dist/*"
+    ],
     "exports": {
-        "import": {
-            "types": "./dist/mod.d.ts",
-            "default": "./dist/mod.mjs"
+        ".": {
+            "import": {
+                "types": "./dist/mod.d.ts",
+                "default": "./dist/mod.mjs"
+            }
+        },
+        "./signals": {
+            "import": {
+                "types": "./dist/signals.d.ts",
+                "default": "./dist/signals.mjs"
+            }
+        },
+        "./utils": {
+            "import": {
+                "types": "./dist/utils.d.ts",
+                "default": "./dist/utils.mjs"
+            }
         }
     },
     "scripts": {
@@ -28,7 +45,7 @@
         "watch": "mocha -r tsx --watch",
         "watch-docs": "onchange -i --kill \"*.md\"  \"guides/**/*.md\" \"typedoc.config.*\" \"typedoc/*\" -- tsx typedoc/run.mts --watch",
         "test": "mocha -r tsx && pkgroll",
-        "prepare": "pkgroll --sourcemap"
+        "prepare": "pkgroll --sourcemap --clean-dist"
     },
     "mocha": {
         "spec": "specs/*.spec.ts",
@@ -53,9 +70,9 @@
         "chai": "^4.3.10",
         "chai-as-promised": "^7.1.1",
         "mocha": "^10.2.0",
-        "monkey-around": "^2.3.0",
+        "monkey-around": "^3",
         "onchange": "^7.1.0",
-        "pkgroll": "^2.0.1",
+        "pkgroll": "^2.1",
         "sinon": "^17.0.1",
         "sinon-chai": "^3.7.0",
         "ts-node": "^10.9.1",