refactor: more explicit types

Author: pi0

.gitignore

@@ -8,3 +8,4 @@ types
 *.log*
 *.env*
 !vitest.config.ts
+tsconfig.tsbuildinfo

src/debugger.ts

@@ -1,4 +1,4 @@
-import type { Hookable } from "./hookable";
+import type { Hookable } from "./hookable.ts";
 
 export interface CreateDebuggerOptions {
   /** An optional tag to prefix console logs with */
@@ -29,7 +29,10 @@ const isBrowser = typeof window !== "undefined";
 export function createDebugger(
   hooks: Hookable<any>,
   _options: CreateDebuggerOptions = {},
-) {
+): {
+  /** Stop debugging and remove listeners */
+  close: () => void;
+} {
   const options = <CreateDebuggerOptions>{
     inspect: isBrowser,
     group: isBrowser,

src/hookable.ts

@@ -3,13 +3,14 @@ import {
   parallelTaskCaller,
   serialTaskCaller,
   callEachWith,
-} from "./utils";
+} from "./utils.ts";
+
 import type {
   DeprecatedHook,
   NestedHooks,
   HookCallback,
   HookKeys,
-} from "./types";
+} from "./types.ts";
 
 type InferCallback<HT, HN extends keyof HT> = HT[HN] extends HookCallback
   ? HT[HN]
@@ -49,7 +50,7 @@ export class Hookable<
     name: NameT,
     function_: InferCallback<HooksT, NameT>,
     options: { allowDeprecated?: boolean } = {},
-  ) {
+  ): () => void {
     if (!name || typeof function_ !== "function") {
       return () => {};
     }
@@ -103,7 +104,7 @@ export class Hookable<
   hookOnce<NameT extends HookNameT>(
     name: NameT,
     function_: InferCallback<HooksT, NameT>,
-  ) {
+  ): () => void {
     let _unreg: (() => void) | undefined;
     let _function: ((...arguments_: any) => any) | undefined = (
       ...arguments_: any
@@ -122,7 +123,7 @@ export class Hookable<
   removeHook<NameT extends HookNameT>(
     name: NameT,
     function_: InferCallback<HooksT, NameT>,
-  ) {
+  ): void {
     if (this._hooks[name]) {
       const index = this._hooks[name].indexOf(function_);
 
@@ -139,7 +140,7 @@ export class Hookable<
   deprecateHook<NameT extends HookNameT>(
     name: NameT,
     deprecated: HookKeys<HooksT> | DeprecatedHook<HooksT>,
-  ) {
+  ): void {
     this._deprecatedHooks[name] =
       typeof deprecated === "string" ? { to: deprecated } : deprecated;
     const _hooks = this._hooks[name] || [];
@@ -151,14 +152,14 @@ export class Hookable<
 
   deprecateHooks(
     deprecatedHooks: Partial<Record<HookNameT, DeprecatedHook<HooksT>>>,
-  ) {
+  ): void {
     Object.assign(this._deprecatedHooks, deprecatedHooks);
     for (const name in deprecatedHooks) {
       this.deprecateHook(name, deprecatedHooks[name] as DeprecatedHook<HooksT>);
     }
   }
 
-  addHooks(configHooks: NestedHooks<HooksT>) {
+  addHooks(configHooks: NestedHooks<HooksT>): () => void {
     const hooks = flatHooks<HooksT>(configHooks);
     // @ts-ignore
     const removeFns = Object.keys(hooks).map((key) =>
@@ -174,15 +175,15 @@ export class Hookable<
     };
   }
 
-  removeHooks(configHooks: NestedHooks<HooksT>) {
+  removeHooks(configHooks: NestedHooks<HooksT>): void {
     const hooks = flatHooks<HooksT>(configHooks);
     for (const key in hooks) {
       // @ts-ignore
       this.removeHook(key, hooks[key]);
     }
   }
 
-  removeAllHooks() {
+  removeAllHooks(): void {
     for (const key in this._hooks) {
       delete this._hooks[key];
     }
@@ -239,7 +240,7 @@ export class Hookable<
     return result;
   }
 
-  beforeEach(function_: (event: InferSpyEvent<HooksT>) => void) {
+  beforeEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void {
     this._before = this._before || [];
     this._before.push(function_);
     return () => {
@@ -252,7 +253,7 @@ export class Hookable<
     };
   }
 
-  afterEach(function_: (event: InferSpyEvent<HooksT>) => void) {
+  afterEach(function_: (event: InferSpyEvent<HooksT>) => void): () => void {
     this._after = this._after || [];
     this._after.push(function_);
     return () => {

src/index.ts

@@ -1,10 +1,13 @@
-export { Hookable, createHooks } from "./hookable";
+export { Hookable, createHooks } from "./hookable.ts";
+
 export {
   flatHooks,
   mergeHooks,
   parallelCaller,
   serial,
   serialCaller,
-} from "./utils";
-export * from "./debugger";
-export * from "./types";
+} from "./utils.ts";
+
+export * from "./debugger.ts";
+
+export * from "./types.ts";

src/utils.ts

@@ -1,4 +1,4 @@
-import type { NestedHooks, HookCallback } from "./types";
+import type { NestedHooks, HookCallback } from "./types.ts";
 
 export function flatHooks<T>(
   configHooks: NestedHooks<T>,
@@ -49,7 +49,7 @@ export function mergeHooks<T>(...hooks: NestedHooks<T>[]): T {
 export function serial<T>(
   tasks: T[],
   function_: (task: T) => Promise<any> | any,
-) {
+): Promise<any> {
   // eslint-disable-next-line unicorn/no-array-reduce
   return tasks.reduce(
     (promise, task) => promise.then(() => function_(task)),
@@ -58,13 +58,26 @@ export function serial<T>(
 }
 
 // https://developer.chrome.com/blog/devtools-modern-web-debugging/#linked-stack-traces
-type CreateTask = typeof console.createTask;
+
+type CreateTask = (name?: string) => {
+  run: (function_: () => Promise<any> | any) => Promise<any> | any;
+};
+
+declare global {
+  interface Console {
+    createTask?: CreateTask;
+  }
+}
+
 const defaultTask: ReturnType<CreateTask> = { run: (function_) => function_() };
 const _createTask: CreateTask = () => defaultTask;
 const createTask =
   console.createTask === undefined ? _createTask : console.createTask;
 
-export function serialTaskCaller(hooks: HookCallback[], args: any[]) {
+export function serialTaskCaller(
+  hooks: HookCallback[],
+  args: any[],
+): Promise<any> {
   const name = args.shift();
   const task = createTask(name);
   // eslint-disable-next-line unicorn/no-array-reduce
@@ -75,14 +88,20 @@ export function serialTaskCaller(hooks: HookCallback[], args: any[]) {
   );
 }
 
-export function parallelTaskCaller(hooks: HookCallback[], args: any[]) {
+export function parallelTaskCaller(
+  hooks: HookCallback[],
+  args: any[],
+): Promise<any> {
   const name = args.shift();
   const task = createTask(name);
   return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
 }
 
 /** @deprecated */
-export function serialCaller(hooks: HookCallback[], arguments_?: any[]) {
+export function serialCaller(
+  hooks: HookCallback[],
+  arguments_?: any[],
+): Promise<any> {
   // eslint-disable-next-line unicorn/no-array-reduce
   return hooks.reduce(
     (promise, hookFunction) =>
@@ -92,11 +111,17 @@ export function serialCaller(hooks: HookCallback[], arguments_?: any[]) {
 }
 
 /** @deprecated */
-export function parallelCaller(hooks: HookCallback[], args?: any[]) {
+export function parallelCaller(
+  hooks: HookCallback[],
+  args?: any[],
+): Promise<any> {
   return Promise.all(hooks.map((hook) => hook(...(args || []))));
 }
 
-export function callEachWith(callbacks: Array<(arg0: any) => any>, arg0?: any) {
+export function callEachWith(
+  callbacks: Array<(arg0: any) => any>,
+  arg0?: any,
+): void {
   // eslint-disable-next-line unicorn/no-useless-spread
   for (const callback of [...callbacks]) {
     callback(arg0);

test/debuger.test.ts

@@ -7,7 +7,7 @@ import {
   expect,
   vi,
 } from "vitest";
-import { createDebugger, Hookable } from "../src/index";
+import { createDebugger, Hookable } from "../src/index.ts";
 
 const consoleMethods = [
   "time",

test/hookable.test.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { describe, test, beforeEach, expect, vi } from "vitest";
-import { createHooks, flatHooks, mergeHooks } from "../src/index";
+import { createHooks, flatHooks, mergeHooks } from "../src/index.ts";
 
 describe("core: hookable", () => {
   beforeEach(() => {

test/types.test.ts

@@ -1,7 +1,7 @@
 import { describe, test } from "vitest";
 import { expectTypeOf } from "expect-type";
-import { createHooks } from "../src";
-import type { HookCallback } from "../src/types";
+import { createHooks } from "../src/index.ts";
+import type { HookCallback } from "../src/types.ts";
 
 describe("hook types", () => {
   test("correctly handles non-nested hooks", () => {
@@ -55,11 +55,11 @@ describe("hook types", () => {
 
     // should both be valid
     hooks.addHooks({
-      namespace: { foo: (_arg) => {} },
+      namespace: { foo: (_arg: any) => {} },
       bar: (_arg) => {},
       "namespace:foo": () => {},
     });
-    hooks.addHooks({ namespace: { nothing: (_arg) => {} } });
+    hooks.addHooks({ namespace: { nothing: (_arg: any) => {} } });
     hooks.addHooks({ nothing: (_arg) => {} });
   });
 

tsconfig.json

@@ -1,9 +1,21 @@
 {
   "compilerOptions": {
     "target": "ESNext",
-    "module": "ESNext",
-    "esModuleInterop": true,
-    "moduleResolution": "Node",
-    "outDir": "dist",
-  }
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "resolveJsonModule": true,
+    "esModuleInterop": false,
+    "allowSyntheticDefaultImports": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "composite": true,
+    "allowImportingTsExtensions": true,
+    "isolatedDeclarations": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitOverride": true,
+    "noEmit": true
+  },
+  "include": ["src", "test"]
 }