hookable 5.4.1 → 5.5.0

package/LICENSE.md

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2018 Pooya Parsa <pooya@pi0.ir>
+Copyright (c) Pooya Parsa <pooya@pi0.io>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function flatHooks(configHooks, hooks = {}, parentName) {
   for (const key in configHooks) {
     const subHook = configHooks[key];
@@ -28,42 +26,62 @@ function mergeHooks(...hooks) {
   }
   for (const key in finalHooks) {
     if (finalHooks[key].length > 1) {
-      const arr = finalHooks[key];
-      finalHooks[key] = (...args) => serial(arr, (fn) => fn(...args));
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
     } else {
       finalHooks[key] = finalHooks[key][0];
     }
   }
   return finalHooks;
 }
-function serial(tasks, fn) {
-  return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve(null));
+function serial(tasks, function_) {
+  return tasks.reduce(
+    (promise, task) => promise.then(() => function_(task)),
+    Promise.resolve()
+  );
+}
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks, name, ...args) {
+  const task = createTask(name);
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks, name, ...args) {
+  const task = createTask(name);
+  return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
 }
-function serialCaller(hooks, args) {
-  return hooks.reduce((promise, hookFn) => promise.then(() => hookFn.apply(void 0, args)), Promise.resolve(null));
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => hookFunction(...arguments_)),
+    Promise.resolve()
+  );
 }
 function parallelCaller(hooks, args) {
-  return Promise.all(hooks.map((hook) => hook.apply(void 0, args)));
+  return Promise.all(hooks.map((hook) => hook(...args)));
 }
 function callEachWith(callbacks, arg0) {
-  for (const cb of callbacks) {
-    cb(arg0);
+  for (const callback of callbacks) {
+    callback(arg0);
   }
 }
 
 class Hookable {
   constructor() {
     this._hooks = {};
-    this._before = null;
-    this._after = null;
-    this._deprecatedMessages = null;
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
     this._deprecatedHooks = {};
     this.hook = this.hook.bind(this);
     this.callHook = this.callHook.bind(this);
     this.callHookWith = this.callHookWith.bind(this);
   }
-  hook(name, fn, opts = {}) {
-    if (!name || typeof fn !== "function") {
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
       return () => {
       };
     }
@@ -73,7 +91,7 @@ class Hookable {
       dep = this._deprecatedHooks[name];
       name = dep.to;
     }
-    if (dep && !opts.allowDeprecated) {
+    if (dep && !options.allowDeprecated) {
       let message = dep.message;
       if (!message) {
         message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
@@ -86,31 +104,42 @@ class Hookable {
         this._deprecatedMessages.add(message);
       }
     }
+    if (!function_.name) {
+      try {
+        Object.defineProperty(function_, "name", {
+          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+          configurable: true
+        });
+      } catch {
+      }
+    }
     this._hooks[name] = this._hooks[name] || [];
-    this._hooks[name].push(fn);
+    this._hooks[name].push(function_);
     return () => {
-      if (fn) {
-        this.removeHook(name, fn);
-        fn = null;
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
       }
     };
   }
-  hookOnce(name, fn) {
+  hookOnce(name, function_) {
     let _unreg;
-    let _fn = (...args) => {
-      _unreg();
-      _unreg = null;
-      _fn = null;
-      return fn(...args);
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
     };
-    _unreg = this.hook(name, _fn);
+    _unreg = this.hook(name, _function);
     return _unreg;
   }
-  removeHook(name, fn) {
+  removeHook(name, function_) {
     if (this._hooks[name]) {
-      const idx = this._hooks[name].indexOf(fn);
-      if (idx !== -1) {
-        this._hooks[name].splice(idx, 1);
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
       }
       if (this._hooks[name].length === 0) {
         delete this._hooks[name];
@@ -133,9 +162,13 @@ class Hookable {
   }
   addHooks(configHooks) {
     const hooks = flatHooks(configHooks);
-    const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+    const removeFns = Object.keys(hooks).map(
+      (key) => this.hook(key, hooks[key])
+    );
     return () => {
-      removeFns.splice(0, removeFns.length).forEach((unreg) => unreg());
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
     };
   }
   removeHooks(configHooks) {
@@ -144,18 +177,23 @@ class Hookable {
       this.removeHook(key, hooks[key]);
     }
   }
-  callHook(name, ...args) {
-    return this.callHookWith(serialCaller, name, ...args);
+  removeAllHooks() {
+    for (const key in this._hooks) {
+      delete this._hooks[key];
+    }
+  }
+  callHook(name, ...arguments_) {
+    return this.callHookWith(serialTaskCaller, name, ...arguments_);
   }
-  callHookParallel(name, ...args) {
-    return this.callHookWith(parallelCaller, name, ...args);
+  callHookParallel(name, ...arguments_) {
+    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
   }
-  callHookWith(caller, name, ...args) {
-    const event = this._before || this._after ? { name, args, context: {} } : void 0;
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
     if (this._before) {
       callEachWith(this._before, event);
     }
-    const result = caller(this._hooks[name] || [], args);
+    const result = caller(this._hooks[name] || [], arguments_);
     if (result instanceof Promise) {
       return result.finally(() => {
         if (this._after && event) {
@@ -168,21 +206,21 @@ class Hookable {
     }
     return result;
   }
-  beforeEach(fn) {
+  beforeEach(function_) {
     this._before = this._before || [];
-    this._before.push(fn);
+    this._before.push(function_);
     return () => {
-      const index = this._before.indexOf(fn);
+      const index = this._before.indexOf(function_);
       if (index !== -1) {
         this._before.splice(index, 1);
       }
     };
   }
-  afterEach(fn) {
+  afterEach(function_) {
     this._after = this._after || [];
-    this._after.push(fn);
+    this._after.push(function_);
     return () => {
-      const index = this._after.indexOf(fn);
+      const index = this._after.indexOf(function_);
       if (index !== -1) {
         this._after.splice(index, 1);
       }
@@ -232,6 +270,7 @@ function createDebugger(hooks, _options = {}) {
     _idCtr[event.name]--;
   });
   return {
+    /** Stop debugging and remove listeners */
     close: () => {
       unsubscribeBefore();
       unsubscribeAfter();

package/dist/index.d.ts

@@ -1,42 +1,42 @@
-declare type HookCallback = (...args: any) => Promise<void> | void;
+type HookCallback = (...arguments_: any) => Promise<void> | void;
 interface Hooks {
     [key: string]: HookCallback;
 }
-declare type HookKeys<T> = keyof T & string;
-declare type DeprecatedHook<T> = {
+type HookKeys<T> = keyof T & string;
+type DeprecatedHook<T> = {
     message?: string;
     to: HookKeys<T>;
 };
-declare type DeprecatedHooks<T> = {
+type DeprecatedHooks<T> = {
     [name in HookKeys<T>]: DeprecatedHook<T>;
 };
-declare type ValueOf<C> = C extends Record<any, any> ? C[keyof C] : never;
-declare type Strings<T> = Exclude<keyof T, number | symbol>;
-declare type KnownKeys<T> = keyof {
+type ValueOf<C> = C extends Record<any, any> ? C[keyof C] : never;
+type Strings<T> = Exclude<keyof T, number | symbol>;
+type KnownKeys<T> = keyof {
     [K in keyof T as string extends K ? never : number extends K ? never : K]: never;
 };
-declare type StripGeneric<T> = Pick<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
-declare type OnlyGeneric<T> = Omit<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
-declare type Namespaces<T> = ValueOf<{
+type StripGeneric<T> = Pick<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
+type OnlyGeneric<T> = Omit<T, KnownKeys<T> extends keyof T ? KnownKeys<T> : never>;
+type Namespaces<T> = ValueOf<{
     [key in Strings<T>]: key extends `${infer Namespace}:${string}` ? Namespace : never;
 }>;
-declare type BareHooks<T> = ValueOf<{
+type BareHooks<T> = ValueOf<{
     [key in Strings<T>]: key extends `${string}:${string}` ? never : key;
 }>;
-declare type HooksInNamespace<T, Namespace extends string> = ValueOf<{
+type HooksInNamespace<T, Namespace extends string> = ValueOf<{
     [key in Strings<T>]: key extends `${Namespace}:${infer HookName}` ? HookName : never;
 }>;
-declare type WithoutNamespace<T, Namespace extends string> = {
+type WithoutNamespace<T, Namespace extends string> = {
     [key in HooksInNamespace<T, Namespace>]: `${Namespace}:${key}` extends keyof T ? T[`${Namespace}:${key}`] : never;
 };
-declare type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>>) & Partial<{
+type NestedHooks<T> = (Partial<StripGeneric<T>> | Partial<OnlyGeneric<T>>) & Partial<{
     [key in Namespaces<StripGeneric<T>>]: NestedHooks<WithoutNamespace<T, key>>;
 }> & Partial<{
     [key in BareHooks<StripGeneric<T>>]: T[key];
 }>;
 
-declare type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
-declare type InferSpyEvent<HT extends Record<string, any>> = {
+type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback ? HT[HN] : never;
+type InferSpyEvent<HT extends Record<string, any>> = {
     [key in keyof HT]: {
         name: key;
         args: Parameters<HT[key]>;
@@ -50,28 +50,31 @@ declare class Hookable<HooksT = Record<string, HookCallback>, HookNameT extends
     private _deprecatedHooks;
     private _deprecatedMessages;
     constructor();
-    hook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>, opts?: {
+    hook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>, options?: {
         allowDeprecated?: boolean;
     }): () => void;
-    hookOnce<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): () => void;
-    removeHook<NameT extends HookNameT>(name: NameT, fn: InferCallback<HooksT, NameT>): void;
+    hookOnce<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): () => void;
+    removeHook<NameT extends HookNameT>(name: NameT, function_: InferCallback<HooksT, NameT>): void;
     deprecateHook<NameT extends HookNameT>(name: NameT, deprecated: HookKeys<HooksT> | DeprecatedHook<HooksT>): void;
     deprecateHooks(deprecatedHooks: Partial<Record<HookNameT, DeprecatedHook<HooksT>>>): void;
     addHooks(configHooks: NestedHooks<HooksT>): () => void;
     removeHooks(configHooks: NestedHooks<HooksT>): void;
-    callHook<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any>;
-    callHookParallel<NameT extends HookNameT>(name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): Promise<any[]>;
-    callHookWith<NameT extends HookNameT, CallFunction extends (hooks: HookCallback[], args: Parameters<InferCallback<HooksT, NameT>>) => any>(caller: CallFunction, name: NameT, ...args: Parameters<InferCallback<HooksT, NameT>>): ReturnType<CallFunction>;
-    beforeEach(fn: (event: InferSpyEvent<HooksT>) => void): () => void;
-    afterEach(fn: (event: InferSpyEvent<HooksT>) => void): () => void;
+    removeAllHooks(): void;
+    callHook<NameT extends HookNameT>(name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): Promise<any>;
+    callHookParallel<NameT extends HookNameT>(name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): Promise<any[]>;
+    callHookWith<NameT extends HookNameT, CallFunction extends (hooks: HookCallback[], arguments_: Parameters<InferCallback<HooksT, NameT>>) => any>(caller: CallFunction, name: NameT, ...arguments_: Parameters<InferCallback<HooksT, NameT>>): ReturnType<CallFunction>;
+    beforeEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
+    afterEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void;
 }
 declare function createHooks<T>(): Hookable<T>;
 
 declare function flatHooks<T>(configHooks: NestedHooks<T>, hooks?: T, parentName?: string): T;
 declare function mergeHooks<T>(...hooks: NestedHooks<T>[]): T;
-declare function serial<T>(tasks: T[], fn: (task: T) => Promise<any> | any): Promise<any>;
-declare function serialCaller(hooks: HookCallback[], args?: any[]): Promise<any>;
-declare function parallelCaller(hooks: HookCallback[], args?: any[]): Promise<any[]>;
+declare function serial<T>(tasks: T[], function_: (task: T) => Promise<any> | any): Promise<any>;
+/** @deprecated */
+declare function serialCaller(hooks: HookCallback[], arguments_?: any[]): Promise<void>;
+/** @deprecated */
+declare function parallelCaller(hooks: HookCallback[], args?: any[]): Promise<void[]>;
 
 interface CreateDebuggerOptions {
     /** An optional tag to prefix console logs with */

package/dist/index.mjs

@@ -24,42 +24,62 @@ function mergeHooks(...hooks) {
   }
   for (const key in finalHooks) {
     if (finalHooks[key].length > 1) {
-      const arr = finalHooks[key];
-      finalHooks[key] = (...args) => serial(arr, (fn) => fn(...args));
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
     } else {
       finalHooks[key] = finalHooks[key][0];
     }
   }
   return finalHooks;
 }
-function serial(tasks, fn) {
-  return tasks.reduce((promise, task) => promise.then(() => fn(task)), Promise.resolve(null));
+function serial(tasks, function_) {
+  return tasks.reduce(
+    (promise, task) => promise.then(() => function_(task)),
+    Promise.resolve()
+  );
 }
-function serialCaller(hooks, args) {
-  return hooks.reduce((promise, hookFn) => promise.then(() => hookFn.apply(void 0, args)), Promise.resolve(null));
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks, name, ...args) {
+  const task = createTask(name);
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks, name, ...args) {
+  const task = createTask(name);
+  return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+}
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => hookFunction(...arguments_)),
+    Promise.resolve()
+  );
 }
 function parallelCaller(hooks, args) {
-  return Promise.all(hooks.map((hook) => hook.apply(void 0, args)));
+  return Promise.all(hooks.map((hook) => hook(...args)));
 }
 function callEachWith(callbacks, arg0) {
-  for (const cb of callbacks) {
-    cb(arg0);
+  for (const callback of callbacks) {
+    callback(arg0);
   }
 }
 
 class Hookable {
   constructor() {
     this._hooks = {};
-    this._before = null;
-    this._after = null;
-    this._deprecatedMessages = null;
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
     this._deprecatedHooks = {};
     this.hook = this.hook.bind(this);
     this.callHook = this.callHook.bind(this);
     this.callHookWith = this.callHookWith.bind(this);
   }
-  hook(name, fn, opts = {}) {
-    if (!name || typeof fn !== "function") {
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
       return () => {
       };
     }
@@ -69,7 +89,7 @@ class Hookable {
       dep = this._deprecatedHooks[name];
       name = dep.to;
     }
-    if (dep && !opts.allowDeprecated) {
+    if (dep && !options.allowDeprecated) {
       let message = dep.message;
       if (!message) {
         message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
@@ -82,31 +102,42 @@ class Hookable {
         this._deprecatedMessages.add(message);
       }
     }
+    if (!function_.name) {
+      try {
+        Object.defineProperty(function_, "name", {
+          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+          configurable: true
+        });
+      } catch {
+      }
+    }
     this._hooks[name] = this._hooks[name] || [];
-    this._hooks[name].push(fn);
+    this._hooks[name].push(function_);
     return () => {
-      if (fn) {
-        this.removeHook(name, fn);
-        fn = null;
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
       }
     };
   }
-  hookOnce(name, fn) {
+  hookOnce(name, function_) {
     let _unreg;
-    let _fn = (...args) => {
-      _unreg();
-      _unreg = null;
-      _fn = null;
-      return fn(...args);
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
     };
-    _unreg = this.hook(name, _fn);
+    _unreg = this.hook(name, _function);
     return _unreg;
   }
-  removeHook(name, fn) {
+  removeHook(name, function_) {
     if (this._hooks[name]) {
-      const idx = this._hooks[name].indexOf(fn);
-      if (idx !== -1) {
-        this._hooks[name].splice(idx, 1);
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
       }
       if (this._hooks[name].length === 0) {
         delete this._hooks[name];
@@ -129,9 +160,13 @@ class Hookable {
   }
   addHooks(configHooks) {
     const hooks = flatHooks(configHooks);
-    const removeFns = Object.keys(hooks).map((key) => this.hook(key, hooks[key]));
+    const removeFns = Object.keys(hooks).map(
+      (key) => this.hook(key, hooks[key])
+    );
     return () => {
-      removeFns.splice(0, removeFns.length).forEach((unreg) => unreg());
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
     };
   }
   removeHooks(configHooks) {
@@ -140,18 +175,23 @@ class Hookable {
       this.removeHook(key, hooks[key]);
     }
   }
-  callHook(name, ...args) {
-    return this.callHookWith(serialCaller, name, ...args);
+  removeAllHooks() {
+    for (const key in this._hooks) {
+      delete this._hooks[key];
+    }
+  }
+  callHook(name, ...arguments_) {
+    return this.callHookWith(serialTaskCaller, name, ...arguments_);
   }
-  callHookParallel(name, ...args) {
-    return this.callHookWith(parallelCaller, name, ...args);
+  callHookParallel(name, ...arguments_) {
+    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
   }
-  callHookWith(caller, name, ...args) {
-    const event = this._before || this._after ? { name, args, context: {} } : void 0;
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
     if (this._before) {
       callEachWith(this._before, event);
     }
-    const result = caller(this._hooks[name] || [], args);
+    const result = caller(this._hooks[name] || [], arguments_);
     if (result instanceof Promise) {
       return result.finally(() => {
         if (this._after && event) {
@@ -164,21 +204,21 @@ class Hookable {
     }
     return result;
   }
-  beforeEach(fn) {
+  beforeEach(function_) {
     this._before = this._before || [];
-    this._before.push(fn);
+    this._before.push(function_);
     return () => {
-      const index = this._before.indexOf(fn);
+      const index = this._before.indexOf(function_);
       if (index !== -1) {
         this._before.splice(index, 1);
       }
     };
   }
-  afterEach(fn) {
+  afterEach(function_) {
     this._after = this._after || [];
-    this._after.push(fn);
+    this._after.push(function_);
     return () => {
-      const index = this._after.indexOf(fn);
+      const index = this._after.indexOf(function_);
       if (index !== -1) {
         this._after.splice(index, 1);
       }
@@ -228,6 +268,7 @@ function createDebugger(hooks, _options = {}) {
     _idCtr[event.name]--;
   });
   return {
+    /** Stop debugging and remove listeners */
     close: () => {
       unsubscribeBefore();
       unsubscribeAfter();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hookable",
-  "version": "5.4.1",
+  "version": "5.5.0",
   "description": "Awaitable hook system",
   "keywords": [
     "hook",
@@ -13,6 +13,7 @@
   "license": "MIT",
   "exports": {
     "import": "./dist/index.mjs",
+    "types": "./dist/index.d.ts",
     "require": "./dist/index.cjs"
   },
   "main": "./dist/index.cjs",
@@ -22,22 +23,25 @@
     "dist"
   ],
   "devDependencies": {
-    "@nuxtjs/eslint-config-typescript": "^11.0.0",
-    "@vitest/coverage-c8": "^0.24.3",
-    "eslint": "^8.25.0",
-    "expect-type": "^0.14.2",
-    "standard-version": "^9.5.0",
-    "typescript": "latest",
-    "unbuild": "^0.8.2",
-    "vitest": "^0.24.3"
+    "@types/node": "^18.15.0",
+    "@vitest/coverage-c8": "^0.29.2",
+    "changelogen": "^0.5.1",
+    "eslint": "^8.35.0",
+    "eslint-config-unjs": "^0.1.0",
+    "expect-type": "^0.15.0",
+    "prettier": "^2.8.4",
+    "typescript": "^4.9.5",
+    "unbuild": "^1.1.2",
+    "vitest": "^0.29.2"
   },
-  "packageManager": "pnpm@7.13.4",
+  "packageManager": "pnpm@7.29.1",
   "scripts": {
     "build": "unbuild",
     "dev": "vitest",
-    "lint": "eslint --ext .ts src",
+    "lint": "eslint --cache --ext .ts,.js,.mjs,.cjs . && prettier -c src test",
+    "lint:fix": "eslint --cache --ext .ts,.js,.mjs,.cjs . --fix && prettier -c src test -w",
     "prepublish": "pnpm build",
-    "release": "pnpm test && pnpm build && standard-version && git push --follow-tags && pnpm publish",
+    "release": "pnpm test && pnpm build && changelogen --release --push && pnpm publish",
     "test": "pnpm lint && vitest run --coverage",
     "test:types": "tsc --noEmit"
   }