kontroll 1.1.2 → 1.2.0

package/dist/index.d.mts

@@ -1,16 +1,17 @@
+//#region src/index.d.ts
 type Fn<T = void> = () => T;
 type FnWithArgs<T = void> = (...args: any) => T;
-interface KontrollStore {
-    [x: PropertyKey]: KontrollInstance;
+export interface KontrollStore {
+  [x: PropertyKey]: KontrollInstance;
 }
-interface KontrollInstance {
-    timer: ReturnType<typeof setTimeout>;
-    callback: Fn<any | Promise<any>>;
-    trailing?: [FnWithArgs, ...any];
-    finishing?: boolean;
+export interface KontrollInstance {
+  timer: ReturnType<typeof setTimeout>;
+  callback: Fn<any | Promise<any>>;
+  trailing?: [FnWithArgs, ...any];
+  finishing?: boolean;
 }
-declare function clear(callback: Fn): void;
-declare function clear(key: keyof KontrollStore): void;
+export declare function clear(callback: Fn): void;
+export declare function clear(key: keyof KontrollStore): void;
 /**
  * Returns the {@link KontrollInstance} for the given key, if exists.
  *
@@ -26,21 +27,21 @@ declare function clear(key: keyof KontrollStore): void;
  * // Result: `KontrollInstance` ({ timer: Timeout, callback: <fn>, finishing: true })
  * ```
  */
-declare function getInstance(key: keyof KontrollStore): KontrollInstance | undefined;
-type KontrollClearer = Fn;
-interface KontrollBaseOptions {
-    /**
-     * Specify a known key if needed
-     * @default string // .toString() of the inputted callback
-     */
-    key?: keyof KontrollStore;
+export declare function getInstance(key: keyof KontrollStore): KontrollInstance | undefined;
+export type KontrollClearer = Fn;
+export interface KontrollBaseOptions {
+  /**
+   * Specify a known key if needed
+   * @default string // .toString() of the inputted callback
+   */
+  key?: keyof KontrollStore;
 }
-interface KontrollCountdownOptions extends KontrollBaseOptions {
-    /**
-     * Replaces the current timed callback
-     * @default false
-     */
-    replace?: boolean;
+export interface KontrollCountdownOptions extends KontrollBaseOptions {
+  /**
+   * Replaces the current timed callback
+   * @default false
+   */
+  replace?: boolean;
 }
 /**
  * Countdown for a period of ms then execute the first/replaced callback, based on `options.replace`.
@@ -69,13 +70,13 @@ interface KontrollCountdownOptions extends KontrollBaseOptions {
  * // Result: 2
  * ```
  */
-declare function countdown(ms: number, callback: Fn, { key, replace }?: KontrollCountdownOptions): KontrollClearer;
-interface KontrollDebounceOptions extends KontrollBaseOptions {
-    /**
-     * Avoiding initial wait for first call
-     * @default false
-     */
-    leading?: boolean;
+export declare function countdown(ms: number, callback: Fn, { key, replace }?: KontrollCountdownOptions): KontrollClearer;
+export interface KontrollDebounceOptions extends KontrollBaseOptions {
+  /**
+   * Avoiding initial wait for first call
+   * @default false
+   */
+  leading?: boolean;
 }
 /**
  * Creates a timer that will execute the callback upon finish, calls while the timer haven't finished recreates the timer.
@@ -107,13 +108,13 @@ interface KontrollDebounceOptions extends KontrollBaseOptions {
  * // Result: 3
  * ```
  */
-declare function debounce(ms: number, callback: Fn, { key, leading }?: KontrollDebounceOptions): KontrollClearer;
-interface KontrollThrottleOptions extends KontrollBaseOptions {
-    /**
-     * Perform additional execution with last received arguments
-     * @default false
-     */
-    trailing?: boolean;
+export declare function debounce(ms: number, callback: Fn, { key, leading }?: KontrollDebounceOptions): KontrollClearer;
+export interface KontrollThrottleOptions extends KontrollBaseOptions {
+  /**
+   * Perform additional execution with last received arguments
+   * @default false
+   */
+  trailing?: boolean;
 }
 /**
  * Executes the callback, and bypass any subsequent calls for a period of ms.
@@ -153,7 +154,6 @@ interface KontrollThrottleOptions extends KontrollBaseOptions {
  * ```
  *
  */
-declare function throttle(ms: number, callback: Fn, { key, trailing }?: KontrollThrottleOptions): KontrollClearer;
-
-export { clear, countdown, debounce, getInstance, throttle };
-export type { KontrollBaseOptions, KontrollClearer, KontrollCountdownOptions, KontrollDebounceOptions, KontrollInstance, KontrollStore, KontrollThrottleOptions };
+export declare function throttle(ms: number, callback: Fn, { key, trailing }?: KontrollThrottleOptions): KontrollClearer;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";KAAK,GAAG,kBAAkB;KACrB,WAAW,gBAAgB,cAAc;iBAE7B;GACd,GAAG,cAAc;;iBAGH;EACf,OAAO,kBAAkB;EACzB,UAAU,SAAS;EACnB,YAAY;EACZ;;wBAKc,MAAM,UAAU;wBAChB,MAAM,WAAW;;;;;;;;;;;;;;;;wBAwBjB,YAAY,WAAW,gBAAgB;YAI3C,kBAAkB;iBAqCb;;;;;EAKf,YAAY;;iBAGG,iCAAiC;;;;;EAKhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA6Bc,UAAU,YAAY,UAAU,MAAM,KAA2B,YAAW,2BAA6B;iBAWxG,gCAAgC;;;;;EAK/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgCc,SAAS,YAAY,UAAU,MAAM,KAA2B,YAAW,0BAA4B;iBAWtG,gCAAgC;;;;;EAK/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAwCc,SAAS,YAAY,UAAU,MAAM,KAA2B,aAAY,0BAA4B"}

package/dist/index.mjs

@@ -1 +1,176 @@
-const t={};function c(n){const e=typeof n=="function"?n.toString():n;t[e]&&(clearTimeout(t[e].timer),delete t[e])}function a(n){return t[n]}function u(n){return()=>{c(n)}}async function s(n){if(t[n]){t[n].finishing=!0;const e=t[n].trailing;await t[n].callback(),c(n),e&&e[0](...e.slice(1))}}function o(n,e,i){if(t[i]?.finishing)return u(i);const r=setTimeout(()=>{s(i)},n);return t[i]={timer:r,callback:e},u(i)}function g(n,e,{key:i=e.toString(),replace:r}={}){return t[i]?(r&&(t[i].callback=e),u(i)):o(n,e,i)}function k(n,e,{key:i=e.toString(),leading:r}={}){if(t[i]&&!t[i].finishing)c(i);else if(r)return f(n,e,{key:i});return o(n,e,i)}function f(n,e,{key:i=e.toString(),trailing:r}={}){if(t[i])return r&&(t[i].trailing=[f,n,e,{key:i}]),u(i);const l=e();return o(n,()=>l,i)}export{c as clear,g as countdown,k as debounce,a as getInstance,f as throttle};
+//#region src/index.ts
+const keyStore = {};
+function clear(keyable) {
+	const key = typeof keyable === "function" ? keyable.toString() : keyable;
+	if (keyStore[key]) {
+		clearTimeout(keyStore[key].timer);
+		delete keyStore[key];
+	}
+}
+/**
+* Returns the {@link KontrollInstance} for the given key, if exists.
+* 
+* Could be useful to check if a promise is executing and not settled.
+* 
+* ---
+* 
+* Example
+* ```
+* debounce(1, async => await sleep(1000), { key: '1sec' })
+* // 500ms passed
+* getInstance('1sec')
+* // Result: `KontrollInstance` ({ timer: Timeout, callback: <fn>, finishing: true })
+* ```
+*/
+function getInstance(key) {
+	return keyStore[key];
+}
+function createClearFn(key) {
+	return () => {
+		clear(key);
+	};
+}
+async function finish(key) {
+	if (keyStore[key]) {
+		keyStore[key].finishing = true;
+		const trailing = keyStore[key].trailing;
+		await keyStore[key].callback();
+		clear(key);
+		if (trailing) trailing[0](...trailing.slice(1));
+	}
+}
+function createTimeout(ms, callback, key) {
+	if (keyStore[key]?.finishing) return createClearFn(key);
+	const timer = setTimeout(() => {
+		finish(key);
+	}, ms);
+	keyStore[key] = {
+		timer,
+		callback
+	};
+	return createClearFn(key);
+}
+/**
+* Countdown for a period of ms then execute the first/replaced callback, based on `options.replace`.
+* 
+* Calls while the timer haven't finished are dropped.
+* 
+* ---
+* 
+* Example
+* ```
+* countdown(1000, doSum(1), { key: 'eg' })
+* // 500ms passed
+* countdown(1000, doSum(2))
+* // 500ms passed
+* // Result: 1
+* ```
+* 
+* ---
+* 
+* Example with `options.replace=true`:
+* ```
+* countdown(1000, doSum(1))
+* // 500ms passed
+* countdown(1000, doSum(2), { replace: true })
+* // 500ms passed
+* // Result: 2
+* ```
+*/
+function countdown(ms, callback, { key = callback.toString(), replace } = {}) {
+	if (keyStore[key]) {
+		if (replace) keyStore[key].callback = callback;
+		return createClearFn(key);
+	}
+	return createTimeout(ms, callback, key);
+}
+/**
+* Creates a timer that will execute the callback upon finish, calls while the timer haven't finished recreates the timer.
+* 
+* If `options.leading`, execute callback immediately for initial call.
+* 
+* ---
+* 
+* Example:
+* ```
+* debounce(1000, doSum(1))
+* // 500ms passed
+* debounce(1000, doSum(2))
+* // 1000ms passed
+* // Result: 2
+* ```
+* 
+* ---
+* 
+* Example with `options.leading`:
+* ```
+* debounce(1000, doSum(1), { leading: true })
+* // Result: 1
+* // 500ms passed
+* debounce(1000, doSum(2), { leading: true }) // leading doesn't matter anymore in this timer scope
+* // 500ms passed
+* debounce(1000, doSum(3))
+* // 1000ms passed
+* // Result: 3
+* ```
+*/
+function debounce(ms, callback, { key = callback.toString(), leading } = {}) {
+	if (keyStore[key] && !keyStore[key].finishing) clear(key);
+	else if (leading) return throttle(ms, callback, { key });
+	return createTimeout(ms, callback, key);
+}
+/**
+* Executes the callback, and bypass any subsequent calls for a period of ms.
+* 
+* Calls while the timer haven't finished are dropped.
+* 
+* If `options.trailing` and calls while the timer haven't finished are received,
+* 
+* an additional execution with last received arguments is performed.
+* 
+* ---
+* 
+* Example:
+* ```
+* throttle(1000, doSum(1))
+* // Result: 1
+* // 500ms passed
+* throttle(1000, doSum(2))
+* // 9999ms passed
+* // (Nothing)
+* ```
+* 
+* ---
+* 
+* Example with `options.trailing`:
+* ```
+* throttle(1000, doSum(1))
+* // Result: 1
+* // 500ms passed
+* throttle(1000, doSum(2), { trailing: true })
+* // 500ms passed
+* // Result: 2
+* // A timer is also created, so calls after that are still dropped:
+* throttle(1000, doSum(3))
+* // 9999ms passed
+* // (Nothing)
+* ```
+* 
+*/
+function throttle(ms, callback, { key = callback.toString(), trailing } = {}) {
+	if (keyStore[key]) {
+		if (trailing) keyStore[key].trailing = [
+			throttle,
+			ms,
+			callback,
+			{ key }
+		];
+		return createClearFn(key);
+	}
+	const r = callback();
+	return createTimeout(ms, () => r, key);
+}
+//#endregion
+export { clear, countdown, debounce, getInstance, throttle };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["type Fn<T = void> = () => T\ntype FnWithArgs<T = void> = (...args: any) => T\n\nexport interface KontrollStore {\n  [x: PropertyKey]: KontrollInstance\n}\n\nexport interface KontrollInstance {\n  timer: ReturnType<typeof setTimeout>\n  callback: Fn<any | Promise<any>>\n  trailing?: [FnWithArgs, ...any]\n  finishing?: boolean\n}\n\nconst keyStore: KontrollStore = {}\n\nexport function clear(callback: Fn): void\nexport function clear(key: keyof KontrollStore): void\nexport function clear(keyable: Fn | keyof KontrollStore) {\n  const key = typeof keyable === 'function' ? keyable.toString() : keyable\n  if (keyStore[key]) {\n    clearTimeout(keyStore[key].timer)\n    delete keyStore[key]\n  }\n}\n\n/**\n * Returns the {@link KontrollInstance} for the given key, if exists.\n * \n * Could be useful to check if a promise is executing and not settled.\n * \n * ---\n * \n * Example\n * ```\n * debounce(1, async => await sleep(1000), { key: '1sec' })\n * // 500ms passed\n * getInstance('1sec')\n * // Result: `KontrollInstance` ({ timer: Timeout, callback: <fn>, finishing: true })\n * ```\n */\nexport function getInstance(key: keyof KontrollStore): KontrollInstance | undefined {\n  return keyStore[key]\n}\n\nexport type KontrollClearer = Fn\nfunction createClearFn(key: keyof KontrollStore): KontrollClearer {\n  return () => { clear(key) }\n}\n\nasync function finish(key: keyof KontrollStore) {\n  if (keyStore[key]) {\n    keyStore[key].finishing = true\n    const trailing = keyStore[key].trailing\n\n    await keyStore[key].callback()\n\n    clear(key)\n\n    if (trailing)\n      trailing[0](...trailing.slice(1))\n  }\n}\n\nfunction createTimeout(ms: number, callback: Fn, key: keyof KontrollStore) {\n  if (keyStore[key]?.finishing)\n    return createClearFn(key)\n\n  const timer = setTimeout(\n    () => { finish(key) },\n    ms,\n  )\n\n  keyStore[key] = {\n    timer,\n    callback,\n  }\n\n  return createClearFn(key)\n}\n\n// TODO: do .toString() have big performance overhead?, maybe implements a WeakMap?\nexport interface KontrollBaseOptions {\n  /**\n   * Specify a known key if needed\n   * @default string // .toString() of the inputted callback\n   */\n  key?: keyof KontrollStore\n}\n\nexport interface KontrollCountdownOptions extends KontrollBaseOptions {\n  /**\n   * Replaces the current timed callback\n   * @default false\n   */\n  replace?: boolean\n}\n/**\n * Countdown for a period of ms then execute the first/replaced callback, based on `options.replace`.\n * \n * Calls while the timer haven't finished are dropped.\n * \n * ---\n * \n * Example\n * ```\n * countdown(1000, doSum(1), { key: 'eg' })\n * // 500ms passed\n * countdown(1000, doSum(2))\n * // 500ms passed\n * // Result: 1\n * ```\n * \n * ---\n * \n * Example with `options.replace=true`:\n * ```\n * countdown(1000, doSum(1))\n * // 500ms passed\n * countdown(1000, doSum(2), { replace: true })\n * // 500ms passed\n * // Result: 2\n * ```\n */\nexport function countdown(ms: number, callback: Fn, { key = callback.toString(), replace }: KontrollCountdownOptions = {}) {\n  if (keyStore[key]) {\n    if (replace)\n      keyStore[key].callback = callback\n\n    return createClearFn(key)\n  }\n\n  return createTimeout(ms, callback, key)\n}\n\nexport interface KontrollDebounceOptions extends KontrollBaseOptions {\n  /**\n   * Avoiding initial wait for first call\n   * @default false\n   */\n  leading?: boolean\n}\n/**\n * Creates a timer that will execute the callback upon finish, calls while the timer haven't finished recreates the timer.\n * \n * If `options.leading`, execute callback immediately for initial call.\n * \n * ---\n * \n * Example:\n * ```\n * debounce(1000, doSum(1))\n * // 500ms passed\n * debounce(1000, doSum(2))\n * // 1000ms passed\n * // Result: 2\n * ```\n * \n * ---\n * \n * Example with `options.leading`:\n * ```\n * debounce(1000, doSum(1), { leading: true })\n * // Result: 1\n * // 500ms passed\n * debounce(1000, doSum(2), { leading: true }) // leading doesn't matter anymore in this timer scope\n * // 500ms passed\n * debounce(1000, doSum(3))\n * // 1000ms passed\n * // Result: 3\n * ```\n */\nexport function debounce(ms: number, callback: Fn, { key = callback.toString(), leading }: KontrollDebounceOptions = {}) {\n  if (keyStore[key] && !keyStore[key].finishing) { clear(key) }\n  else {\n    // if no pending call and leading: true, execute function immediately\n    if (leading)\n      return throttle(ms, callback, { key })\n  }\n\n  return createTimeout(ms, callback, key)\n}\n\nexport interface KontrollThrottleOptions extends KontrollBaseOptions {\n  /**\n   * Perform additional execution with last received arguments\n   * @default false\n   */\n  trailing?: boolean\n}\n/**\n * Executes the callback, and bypass any subsequent calls for a period of ms.\n * \n * Calls while the timer haven't finished are dropped.\n * \n * If `options.trailing` and calls while the timer haven't finished are received,\n * \n * an additional execution with last received arguments is performed.\n * \n * ---\n * \n * Example:\n * ```\n * throttle(1000, doSum(1))\n * // Result: 1\n * // 500ms passed\n * throttle(1000, doSum(2))\n * // 9999ms passed\n * // (Nothing)\n * ```\n * \n * ---\n * \n * Example with `options.trailing`:\n * ```\n * throttle(1000, doSum(1))\n * // Result: 1\n * // 500ms passed\n * throttle(1000, doSum(2), { trailing: true })\n * // 500ms passed\n * // Result: 2\n * // A timer is also created, so calls after that are still dropped:\n * throttle(1000, doSum(3))\n * // 9999ms passed\n * // (Nothing)\n * ```\n * \n */\nexport function throttle(ms: number, callback: Fn, { key = callback.toString(), trailing }: KontrollThrottleOptions = {}) {\n  if (keyStore[key]) {\n    if (trailing)\n      keyStore[key].trailing = [throttle, ms, callback, { key }]\n\n    return createClearFn(key)\n  }\n\n  const r = callback()\n\n  return createTimeout(ms, () => r, key)\n}\n"],"mappings":";AAcA,MAAM,WAA0B,CAAC;AAIjC,SAAgB,MAAM,SAAmC;CACvD,MAAM,MAAM,OAAO,YAAY,aAAa,QAAQ,SAAS,IAAI;CACjE,IAAI,SAAS,MAAM;EACjB,aAAa,SAAS,IAAI,CAAC,KAAK;EAChC,OAAO,SAAS;CAClB;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,YAAY,KAAwD;CAClF,OAAO,SAAS;AAClB;AAGA,SAAS,cAAc,KAA2C;CAChE,aAAa;EAAE,MAAM,GAAG;CAAE;AAC5B;AAEA,eAAe,OAAO,KAA0B;CAC9C,IAAI,SAAS,MAAM;EACjB,SAAS,IAAI,CAAC,YAAY;EAC1B,MAAM,WAAW,SAAS,IAAI,CAAC;EAE/B,MAAM,SAAS,IAAI,CAAC,SAAS;EAE7B,MAAM,GAAG;EAET,IAAI,UACF,SAAS,EAAE,CAAC,GAAG,SAAS,MAAM,CAAC,CAAC;CACpC;AACF;AAEA,SAAS,cAAc,IAAY,UAAc,KAA0B;CACzE,IAAI,SAAS,IAAI,EAAE,WACjB,OAAO,cAAc,GAAG;CAE1B,MAAM,QAAQ,iBACN;EAAE,OAAO,GAAG;CAAE,GACpB,EACF;CAEA,SAAS,OAAO;EACd;EACA;CACF;CAEA,OAAO,cAAc,GAAG;AAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,UAAU,IAAY,UAAc,EAAE,MAAM,SAAS,SAAS,GAAG,YAAsC,CAAC,GAAG;CACzH,IAAI,SAAS,MAAM;EACjB,IAAI,SACF,SAAS,IAAI,CAAC,WAAW;EAE3B,OAAO,cAAc,GAAG;CAC1B;CAEA,OAAO,cAAc,IAAI,UAAU,GAAG;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,SAAS,IAAY,UAAc,EAAE,MAAM,SAAS,SAAS,GAAG,YAAqC,CAAC,GAAG;CACvH,IAAI,SAAS,QAAQ,CAAC,SAAS,IAAI,CAAC,WAAa,MAAM,GAAG;MAGxD,IAAI,SACF,OAAO,SAAS,IAAI,UAAU,EAAE,IAAI,CAAC;CAGzC,OAAO,cAAc,IAAI,UAAU,GAAG;AACxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,SAAS,IAAY,UAAc,EAAE,MAAM,SAAS,SAAS,GAAG,aAAsC,CAAC,GAAG;CACxH,IAAI,SAAS,MAAM;EACjB,IAAI,UACF,SAAS,IAAI,CAAC,WAAW;GAAC;GAAU;GAAI;GAAU,EAAE,IAAI;EAAC;EAE3D,OAAO,cAAc,GAAG;CAC1B;CAEA,MAAM,IAAI,SAAS;CAEnB,OAAO,cAAc,UAAU,GAAG,GAAG;AACvC"}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "kontroll",
   "type": "module",
-  "version": "1.1.2",
+  "version": "1.2.0",
+  "packageManager": "pnpm@12.4.1",
   "description": "kontroll (\"control\") is a tiny, dead-simple package for function behavior controls like debounce, countdown, throttle (limit).",
   "author": "NamesMT <dangquoctrung123@gmail.com>",
   "license": "MIT",
@@ -24,6 +25,9 @@
     "rate"
   ],
   "sideEffects": false,
+  "imports": {
+    "#src/*": "./src/*"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.mts",
@@ -38,38 +42,37 @@
     "dist"
   ],
   "engines": {
-    "node": ">=18.0.0"
-  },
-  "devDependencies": {
-    "@antfu/eslint-config": "^4.12.0",
-    "@types/node": "^22.14.0",
-    "@vitest/coverage-v8": "^3.1.1",
-    "eslint": "^9.24.0",
-    "lint-staged": "^15.5.0",
-    "simple-git-hooks": "^2.12.1",
-    "tsx": "^4.19.3",
-    "typescript": "^5.8.3",
-    "unbuild": "^3.5.0",
-    "vitest": "^3.1.1"
-  },
-  "simple-git-hooks": {
-    "pre-commit": "pnpm lint-staged"
-  },
-  "lint-staged": {
-    "*": "eslint"
+    "node": ">=22.0.0"
   },
   "scripts": {
     "start": "NODE_ENV=dev tsx src/index.ts",
     "watch": "NODE_ENV=dev tsx watch src/index.ts",
-    "stub": "unbuild --stub",
     "dev": "pnpm run watch",
-    "play": "pnpm run stub && pnpm run --filter playground dev",
-    "play:useBuild": "pnpm run build && pnpm run --filter playground dev",
     "lint": "eslint .",
     "test": "vitest",
     "test:types": "tsc --noEmit --skipLibCheck",
     "check": "pnpm lint && pnpm test:types && vitest run --coverage",
-    "build": "unbuild",
-    "release": "pnpm dlx changelogen@latest --release --push --publish"
+    "build": "tsdown",
+    "release": "pnpm dlx changelogen@latest --release --push --publish",
+    "prepare": "simple-git-hooks",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^4.19.0",
+    "@types/node": "^22.20.2",
+    "@vitest/coverage-v8": "^3.2.7",
+    "eslint": "^9.39.5",
+    "lint-staged": "^15.5.2",
+    "simple-git-hooks": "^2.14.0",
+    "tsdown": "^0.23.0",
+    "tsx": "^4.23.13",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.7"
+  },
+  "simple-git-hooks": {
+    "pre-commit": "pnpm lint-staged"
+  },
+  "lint-staged": {
+    "*": "eslint"
   }
-}
+}

package/dist/index.d.ts

@@ -1,159 +0,0 @@
-type Fn<T = void> = () => T;
-type FnWithArgs<T = void> = (...args: any) => T;
-interface KontrollStore {
-    [x: PropertyKey]: KontrollInstance;
-}
-interface KontrollInstance {
-    timer: ReturnType<typeof setTimeout>;
-    callback: Fn<any | Promise<any>>;
-    trailing?: [FnWithArgs, ...any];
-    finishing?: boolean;
-}
-declare function clear(callback: Fn): void;
-declare function clear(key: keyof KontrollStore): void;
-/**
- * Returns the {@link KontrollInstance} for the given key, if exists.
- *
- * Could be useful to check if a promise is executing and not settled.
- *
- * ---
- *
- * Example
- * ```
- * debounce(1, async => await sleep(1000), { key: '1sec' })
- * // 500ms passed
- * getInstance('1sec')
- * // Result: `KontrollInstance` ({ timer: Timeout, callback: <fn>, finishing: true })
- * ```
- */
-declare function getInstance(key: keyof KontrollStore): KontrollInstance | undefined;
-type KontrollClearer = Fn;
-interface KontrollBaseOptions {
-    /**
-     * Specify a known key if needed
-     * @default string // .toString() of the inputted callback
-     */
-    key?: keyof KontrollStore;
-}
-interface KontrollCountdownOptions extends KontrollBaseOptions {
-    /**
-     * Replaces the current timed callback
-     * @default false
-     */
-    replace?: boolean;
-}
-/**
- * Countdown for a period of ms then execute the first/replaced callback, based on `options.replace`.
- *
- * Calls while the timer haven't finished are dropped.
- *
- * ---
- *
- * Example
- * ```
- * countdown(1000, doSum(1), { key: 'eg' })
- * // 500ms passed
- * countdown(1000, doSum(2))
- * // 500ms passed
- * // Result: 1
- * ```
- *
- * ---
- *
- * Example with `options.replace=true`:
- * ```
- * countdown(1000, doSum(1))
- * // 500ms passed
- * countdown(1000, doSum(2), { replace: true })
- * // 500ms passed
- * // Result: 2
- * ```
- */
-declare function countdown(ms: number, callback: Fn, { key, replace }?: KontrollCountdownOptions): KontrollClearer;
-interface KontrollDebounceOptions extends KontrollBaseOptions {
-    /**
-     * Avoiding initial wait for first call
-     * @default false
-     */
-    leading?: boolean;
-}
-/**
- * Creates a timer that will execute the callback upon finish, calls while the timer haven't finished recreates the timer.
- *
- * If `options.leading`, execute callback immediately for initial call.
- *
- * ---
- *
- * Example:
- * ```
- * debounce(1000, doSum(1))
- * // 500ms passed
- * debounce(1000, doSum(2))
- * // 1000ms passed
- * // Result: 2
- * ```
- *
- * ---
- *
- * Example with `options.leading`:
- * ```
- * debounce(1000, doSum(1), { leading: true })
- * // Result: 1
- * // 500ms passed
- * debounce(1000, doSum(2), { leading: true }) // leading doesn't matter anymore in this timer scope
- * // 500ms passed
- * debounce(1000, doSum(3))
- * // 1000ms passed
- * // Result: 3
- * ```
- */
-declare function debounce(ms: number, callback: Fn, { key, leading }?: KontrollDebounceOptions): KontrollClearer;
-interface KontrollThrottleOptions extends KontrollBaseOptions {
-    /**
-     * Perform additional execution with last received arguments
-     * @default false
-     */
-    trailing?: boolean;
-}
-/**
- * Executes the callback, and bypass any subsequent calls for a period of ms.
- *
- * Calls while the timer haven't finished are dropped.
- *
- * If `options.trailing` and calls while the timer haven't finished are received,
- *
- * an additional execution with last received arguments is performed.
- *
- * ---
- *
- * Example:
- * ```
- * throttle(1000, doSum(1))
- * // Result: 1
- * // 500ms passed
- * throttle(1000, doSum(2))
- * // 9999ms passed
- * // (Nothing)
- * ```
- *
- * ---
- *
- * Example with `options.trailing`:
- * ```
- * throttle(1000, doSum(1))
- * // Result: 1
- * // 500ms passed
- * throttle(1000, doSum(2), { trailing: true })
- * // 500ms passed
- * // Result: 2
- * // A timer is also created, so calls after that are still dropped:
- * throttle(1000, doSum(3))
- * // 9999ms passed
- * // (Nothing)
- * ```
- *
- */
-declare function throttle(ms: number, callback: Fn, { key, trailing }?: KontrollThrottleOptions): KontrollClearer;
-
-export { clear, countdown, debounce, getInstance, throttle };
-export type { KontrollBaseOptions, KontrollClearer, KontrollCountdownOptions, KontrollDebounceOptions, KontrollInstance, KontrollStore, KontrollThrottleOptions };