Added checking of typings.

Author: uhop

ts-check/fns.ts

@@ -0,0 +1,65 @@
+import audit from "../src/audit.js";
+import throttle from "../src/throttle.js";
+import sample from "../src/sample.js";
+import debounce from "../src/debounce.js";
+import sleep from "../src/sleep.js";
+import whenDomLoaded from "../src/when-dom-loaded.js";
+import whenLoaded from "../src/when-loaded.js";
+
+const main = async () => {
+  // audit
+  {
+    const fn = () => {};
+    const auditedFn = audit(fn, 20);
+
+    auditedFn(1);
+    auditedFn(2);
+  }
+
+  // throttle
+  {
+    const fn = () => {};
+    const throttledFn = throttle(fn, 20);
+
+    throttledFn(1);
+    throttledFn(2);
+  }
+
+  // sample
+  {
+    const fn = () => {};
+    const sampledFn = sample(fn, 20);
+
+    sampledFn(1);
+    sampledFn(2);
+  }
+
+  // debounce
+  {
+    const fn = () => {};
+    const debouncedFn = debounce(fn, 20);
+
+    debouncedFn(1);
+    debouncedFn(2);
+  }
+
+  // sleep
+  {
+    await sleep(20);
+    await sleep(new Date(Date.now() + 20));
+  }
+
+  // whenDomLoaded
+  {
+    const fn = () => {};
+    whenDomLoaded(fn);
+  }
+
+  // whenLoaded
+  {
+    const fn = () => {};
+    whenLoaded(fn);
+  }
+};
+
+main();

ts-check/frame-queue.ts

@@ -0,0 +1,11 @@
+import {frameQueue} from '../src/FrameQueue.js';
+
+const main = async () => {
+  frameQueue.pause();
+  const task = frameQueue.enqueue(() => {});
+  frameQueue.resume();
+  frameQueue.dequeue(task);
+  if (!frameQueue.isEmpty) frameQueue.clear();
+};
+
+main();

ts-check/idle-queue.ts

@@ -0,0 +1,11 @@
+import {idleQueue} from '../src/IdleQueue.js';
+
+const main = async () => {
+  idleQueue.pause();
+  const task = idleQueue.enqueue(() => {});
+  idleQueue.resume();
+  idleQueue.dequeue(task);
+  if (!idleQueue.isEmpty) idleQueue.clear();
+};
+
+main();

ts-check/page-watcher.ts

@@ -0,0 +1,11 @@
+import {pageWatcher} from '../src/PageWatcher.js';
+
+const main = async () => {
+  pageWatcher.pause();
+  const task = pageWatcher.enqueue(() => {});
+  pageWatcher.resume();
+  pageWatcher.dequeue(task);
+  if (!pageWatcher.isEmpty) pageWatcher.clear();
+};
+
+main();

ts-check/retainer.ts

@@ -0,0 +1,19 @@
+import Retainer from '../src/Retainer.js';
+
+const main = async () => {
+  const retainer = new Retainer({
+    create: () => Promise.resolve(1),
+    destroy: () => Promise.resolve(),
+    retentionPeriod: 1_000,
+  });
+  
+  const value1 = await retainer.get();
+  void value1;
+  await retainer.release();
+
+  const value2 = await retainer.get();
+  void value2;
+  await retainer.release(true);
+};
+
+main();

ts-check/scheduler.ts

@@ -0,0 +1,15 @@
+import {scheduler, repeat} from '../src/Scheduler.js';
+
+const main = async () => {
+  scheduler.pause();
+  const task = scheduler.enqueue(() => {}, 10);
+  scheduler.resume();
+  scheduler.dequeue(task);
+  if (!scheduler.isEmpty) scheduler.clear();
+
+  scheduler.enqueue(repeat(() => {}, 10), 50);
+  
+  await scheduler.schedule(100);
+};
+
+main();

ts-check/throttler.ts

@@ -0,0 +1,21 @@
+import Throttler from '../src/Throttler.js';
+import sleep from '../src/sleep.js';
+
+const main = async () => {
+  const throttler = new Throttler();
+
+  await throttler.wait('a');
+  await throttler.wait('b');
+  await throttler.wait('a');
+
+  if (throttler.isVacuuming) throttler.stopVacuum();
+  throttler.startVacuum();
+
+  const lastSeen = throttler.getLastSeen('a');
+  void lastSeen;
+
+  const delay = throttler.getDelay('a');
+  await sleep(delay);
+};
+
+main();