thaw 5.0.4 → 6.0.0

package/README.md

@@ -2,6 +2,14 @@ The narrow belt for AOP 🎀
 ---
 This package provides **narrow-trench** methods for aspect-oriented programming (AOP).
 
+## Abstract
+
+* Consistent advice pattern semantics 📐
+* Deterministic behavior (tested with mocked timers) ⚖️
+* Preserves `this` context 🔒
+* Small, predictable behavior 🎯
+* Zero dependencies 🗽
+
 ## Prerequisites
 
 * Node.js `>= 20.0.0`
@@ -15,37 +23,97 @@ npm install thaw --save
 ### Usage
 
 ```javascript
-import * as thaw from 'thaw';
-
-const around = thaw.around((val) => val + 1, (val) => val + val);
-const after = thaw.after((val) => val + 1, (val) => val + val);
-const before = thaw.before((val) => val + 1, (val) => val + val);
-const compose = thaw.compose(around, after, before);
-
-console.assert(around(1) === 6, 'around');
-console.assert(after(1) === 4, 'after');
-console.assert(before(1) === 3, 'before');
-console.assert(compose(1) === 29, 'compose');
-
-let bip = 0;
-const debounce = thaw.debounce(() => bip++, 100);
-
-setTimeout(debounce, 0);
-setTimeout(debounce, 100);
-setTimeout(debounce, 250); // will fire
-setTimeout(debounce, 300);
-setTimeout(debounce, 350); // will fire
-setTimeout(debounce, 400);
-setTimeout(() => console.assert(bip === 2, 'debounce'), 1e3);
-
-let pib = 0;
-const throttle = thaw.throttle(() => pib++, 100);
-
-setTimeout(throttle, 0); // will fire
-setTimeout(throttle, 100);
-setTimeout(throttle, 250); // will fire
-setTimeout(throttle, 300);
-setTimeout(throttle, 350); // will fire
-setTimeout(throttle, 400);
-setTimeout(() => console.assert(pib === 3, 'throttle'), 1e3);
+import {
+  after,
+  afterReturning,
+  afterThrowing,
+  around,
+  before,
+  debounce,
+  pipe,
+  throttle,
+} from 'thaw';
+
+{
+  const fn = after(
+    (v) => v + 1,
+    (...args) => console.log('args passed to fn', args), // [ 1 ]
+  );
+
+  console.log('after', fn(1)); // 2
+}
+
+{
+  const fn = afterReturning(
+    (a, b) => a + b,
+    (result, ...args) => `${ result }-${ args }`,
+  );
+
+  console.log('afterReturning', fn(2, 3)); // 5-2,3
+}
+
+{
+  const fn = afterThrowing(
+    () => { throw new Error('boom'); },
+    (err, ...args) => console.error('afterThrowing', `${ err.message }-${ args }`), // boom-2,3
+  );
+
+  try {
+    fn(2, 3);
+  } catch (err) {
+    console.error('afterThrowing', err.message); // boom
+  }
+}
+
+{
+  const fn = around(
+    (v) => v + 1,
+    (proceed, ...args) => proceed() + args.at(0),
+  );
+
+  console.log('around', fn(1)); // 3
+}
+
+{
+  const fn = before(
+    (v) => v + 1,
+    (...args) => console.log('args passed to fn', args), // [ 1 ]
+  );
+
+  console.log('before', fn(1)); // 2
+}
+
+{
+  const fn = debounce((v) => {
+    console.log('debounce', v); // 3; after -> 200ms
+  }, 200);
+
+  fn(1);
+  fn(2);
+  fn(3);
+}
+
+{
+  const fn = pipe(
+    (v) => v + 2,
+    (v) => v + 3,
+    (v) => v + 4,
+  );
+
+  console.log('pipe', fn(1)); // 10
+}
+
+{
+  const fn = throttle((v) => {
+    console.log('throttle', v); // 1; idle -> 200ms
+  }, 200);
+
+  fn(1);
+  fn(2);
+  fn(3);
+}
 ```
+
+---
+
+For more details, please check tests in the repository.

package/dist/index.cjs

@@ -3,52 +3,71 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.throttle = exports.debounce = exports.compose = exports.before = exports.around = exports.after = void 0;
-const around = (fn, cb) => {
-  return (...args) => {
-    return cb(fn(cb(...args)));
-  };
-};
-exports.around = around;
-const after = (fn, cb) => {
-  return (...args) => {
-    return cb(fn(...args));
+exports.throttle = exports.pipe = exports.debounce = exports.before = exports.around = exports.afterThrowing = exports.afterReturning = exports.after = void 0;
+const after = (fn, advice) => {
+  return function (...args) {
+    const result = fn.apply(this, args);
+    advice.apply(this, args);
+    return result;
   };
 };
 exports.after = after;
-const before = (fn, cb) => {
-  return (...args) => {
-    return fn(cb(...args));
+const afterReturning = (fn, advice) => {
+  return function (...args) {
+    return advice.call(this, fn.apply(this, args), ...args);
   };
 };
-exports.before = before;
-const compose = (...fns) => {
-  return (...args) => {
-    let result = null;
-    for (let i = 0; i < fns.length; i++) {
-      result = fns[i](...(i ? [result] : args));
+exports.afterReturning = afterReturning;
+const afterThrowing = (fn, advice) => {
+  return function (...args) {
+    try {
+      return fn.apply(this, args);
+    } catch (err) {
+      advice.call(this, err, ...args);
+      throw err;
     }
-    return result;
   };
 };
-exports.compose = compose;
+exports.afterThrowing = afterThrowing;
+const around = (fn, advice) => {
+  return function (...args) {
+    const proceed = () => fn.apply(this, args);
+    return advice.call(this, proceed, ...args);
+  };
+};
+exports.around = around;
+const before = (fn, advice) => {
+  return function (...args) {
+    advice.apply(this, args);
+    return fn.apply(this, args);
+  };
+};
+exports.before = before;
 const debounce = (fn, wait = 0) => {
-  let tick;
-  return (...args) => {
-    clearTimeout(tick);
-    tick = setTimeout(() => {
-      fn(...args);
+  let timer;
+  return function (...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      fn.apply(this, args);
     }, wait);
   };
 };
 exports.debounce = debounce;
+const pipe = (...fns) => {
+  if (fns.length === 0) {
+    return (...args) => args.length <= 1 ? args.at(0) : args;
+  }
+  return function (...args) {
+    return fns.reduce((acc, fn, idx) => idx ? fn.call(this, acc) : fn.apply(this, acc), args);
+  };
+};
+exports.pipe = pipe;
 const throttle = (fn, wait = 0) => {
-  let tick;
-  return (...args) => {
-    tick = !tick && setTimeout(() => {
-      tick = clearTimeout(tick);
-      fn(...args);
-    }, wait);
+  let timer;
+  return function (...args) {
+    timer ||= (fn.apply(this, args), setTimeout(() => {
+      timer = null;
+    }, wait));
   };
 };
 exports.throttle = throttle;

package/package.json

@@ -11,11 +11,10 @@
   "devDependencies": {
     "@babel/cli": "^7.28.6",
     "@babel/core": "^7.29.0",
-    "@babel/eslint-parser": "^7.28.6",
     "@babel/preset-env": "^7.29.0",
     "c8": "^10.1.3",
-    "eslint": "^9.39.2",
-    "eslint-config-ultra-refined": "^3.8.5",
+    "eslint": "^10.0.0",
+    "eslint-config-ultra-refined": "^4.0.1",
     "mocha": "^11.7.5"
   },
   "engines": {
@@ -51,5 +50,5 @@
     "test:cover": "c8 --include=src --reporter=lcov --reporter=text npm test"
   },
   "type": "module",
-  "version": "5.0.4"
+  "version": "6.0.0"
 }

package/src/index.js

@@ -1,51 +1,73 @@
-export const around = (fn, cb) => {
-  return (...args) => {
-    return cb(fn(cb(...args)));
-  };
-};
-
-export const after = (fn, cb) => {
-  return (...args) => {
-    return cb(fn(...args));
-  };
-};
-
-export const before = (fn, cb) => {
-  return (...args) => {
-    return fn(cb(...args));
-  };
-};
-
-export const compose = (...fns) => {
-  return (...args) => {
-    let result = null;
-
-    for (let i = 0; i < fns.length; i++) {
-      result = fns[i](...(i ? [result] : args));
-    }
-
-    return result;
-  };
-};
-
-export const debounce = (fn, wait = 0) => {
-  let tick;
-
-  return (...args) => {
-    clearTimeout(tick);
-    tick = setTimeout(() => {
-      fn(...args);
-    }, wait);
-  };
-};
-
-export const throttle = (fn, wait = 0) => {
-  let tick;
-
-  return (...args) => {
-    tick = !tick && setTimeout(() => {
-      tick = clearTimeout(tick);
-      fn(...args);
-    }, wait);
-  };
-};
+export const after = (fn, advice) => {
+  return function (...args) {
+    const result = fn.apply(this, args);
+
+    advice.apply(this, args);
+
+    return result;
+  };
+};
+
+export const afterReturning = (fn, advice) => {
+  return function (...args) {
+    return advice.call(this, fn.apply(this, args), ...args);
+  };
+};
+
+export const afterThrowing = (fn, advice) => {
+  return function (...args) {
+    try {
+      return fn.apply(this, args);
+    } catch (err) {
+      advice.call(this, err, ...args);
+      throw err;
+    }
+  };
+};
+
+export const around = (fn, advice) => {
+  return function (...args) {
+    const proceed = () => fn.apply(this, args);
+
+    return advice.call(this, proceed, ...args);
+  };
+};
+
+export const before = (fn, advice) => {
+  return function (...args) {
+    advice.apply(this, args);
+
+    return fn.apply(this, args);
+  };
+};
+
+export const debounce = (fn, wait = 0) => {
+  let timer;
+
+  return function (...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      fn.apply(this, args);
+    }, wait);
+  };
+};
+
+export const pipe = (...fns) => {
+  if (fns.length === 0) {
+    return (...args) => args.length <= 1 ? args.at(0) : args;
+  }
+
+  return function (...args) {
+    return fns.reduce((acc, fn, idx) => idx ? fn.call(this, acc) : fn.apply(this, acc), args);
+  };
+};
+
+export const throttle = (fn, wait = 0) => {
+  let timer;
+
+  return function (...args) {
+    timer ||= (fn.apply(this, args), setTimeout(() => {
+      timer = null;
+    }, wait));
+  };
+};