@webreflection/utils 0.2.0 → 0.2.1

package/README.md

@@ -9,10 +9,29 @@ A [collection](./src/) of utility functions.
 
 ```js
 // example: a shim based on ArrayBuffer if native is `false`
-import { SharedArrayBuffer, native } from 'https://esm.run/@webreflection/utils/shared-array-buffer';
+import { SharedArrayBuffer, native } from '@webreflection/utils/shared-array-buffer';
 
 // example: self bound Promise.withResolvers()
-import withResolvers from 'https://esm.run/@webreflection/utils/with-resolvers';
+import withResolvers from '@webreflection/utils/with-resolvers';
 
 const { promise, resolve, reject } = withResolvers();
+
+// example: any object bound method
+import bound from '@webreflection/utils/bound';
+
+const { all, resolve } = bound(Promise);
+all([1, 2, 3]);
+resolve(4);
+
+
+// example: any object bound method is identical
+//          particularly useful for listeners identity
+import boundOnce from '@webreflection/utils/bound-once';
+
+const { all, resolve } = boundOnce(Promise);
+all([1, 2, 3]);
+resolve(4);
+
+boundOnce(Promise).all === all;
+boundOnce(Promise).resolve === resolve;
 ```

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@webreflection/utils",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "exports": {
     "./bound": {
       "types": "./types/bound.d.ts",
       "import": "./src/bound.js"
     },
+    "./bound-once": {
+      "types": "./types/bound-once.d.ts",
+      "import": "./src/bound-once.js"
+    },
     "./shared-array-buffer": {
       "types": "./types/shared-array-buffer.d.ts",
       "import": "./src/shared-array-buffer.js"
@@ -19,6 +23,7 @@
   },
   "tests": [
     "bound",
+    "bound-once",
     "shared-array-buffer",
     "with-resolvers"
   ],

package/src/bound-once.js

@@ -0,0 +1,29 @@
+//@ts-check
+
+/**
+ * @type {WeakMap<object, Map<string | symbol, (...args: any[]) => unknown>>}
+ */
+const methods = new WeakMap;
+
+/**
+ * @type {ProxyHandler<any>}
+ */
+const handler = {
+  get(target, prop) {
+    const known = /** @type {Map<string | symbol, (...args: any[]) => unknown>} */ (methods.get(target));
+    let method = known.get(prop);
+    if (!method) known.set(prop, (method = target[prop].bind(target)));
+    return method;
+  }
+};
+
+/**
+ * @template {object} T
+ * @param {T} target
+ * @returns {import('./bound.js').Bound<T>}
+ */
+export default target => {
+  let known = methods.get(target);
+  if (!known) methods.set(target, (known = new Map));
+  return new Proxy(target, handler);
+};

package/types/bound-once.d.ts

@@ -0,0 +1,2 @@
+declare function _default<T extends object>(target: T): import("./bound.js").Bound<T>;
+export default _default;