@tally.paws/toolbox 1.2.0

package/dist/index.mjs

@@ -0,0 +1,445 @@
+// src/promises.ts
+function sleep(ms2) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms2);
+  });
+}
+var AsyncQueue = class {
+  queue = Promise.resolve();
+  run(fn) {
+    const res = this.queue.then(fn, fn);
+    this.queue = res.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return res;
+  }
+};
+function deferred() {
+  let resolve = null;
+  let reject = null;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function timeoutPromise(promise, ms2, error = new Error("Timed out")) {
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => setTimeout(() => reject(error), ms2))
+  ]);
+}
+
+// src/functions.ts
+function debounce(fn, delay = 300, options = {}) {
+  let timeout = null;
+  let lastArgs = null;
+  let lastThis;
+  let result;
+  const debounced = function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    const callNow = options.immediate && !timeout;
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      timeout = null;
+      if (!options.immediate && lastArgs) {
+        result = fn.apply(lastThis, lastArgs);
+        lastArgs = null;
+      }
+    }, delay);
+    if (callNow) {
+      result = fn.apply(lastThis, lastArgs);
+      lastArgs = null;
+    }
+    return result;
+  };
+  debounced.cancel = () => {
+    if (timeout) clearTimeout(timeout);
+    timeout = null;
+    lastArgs = null;
+  };
+  debounced.flush = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = null;
+      if (lastArgs) {
+        fn.apply(lastThis, lastArgs);
+        lastArgs = null;
+      }
+    }
+  };
+  return debounced;
+}
+function throttle(fn, interval = 300) {
+  let last = 0;
+  let timeout = null;
+  return function(...args) {
+    const now = Date.now();
+    const remaining = interval - (now - last);
+    if (remaining <= 0) {
+      last = now;
+      fn.apply(this, args);
+    } else if (!timeout) {
+      timeout = setTimeout(() => {
+        last = Date.now();
+        timeout = null;
+        fn.apply(this, args);
+      }, remaining);
+    }
+  };
+}
+function deepEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || typeof b !== "object" || !a || !b) return false;
+  const keysA = Object.keys(a);
+  if (keysA.length !== Object.keys(b).length) return false;
+  return keysA.every((k) => deepEqual(a[k], b[k]));
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return function(...args) {
+    if (!called) {
+      called = true;
+      result = fn.apply(this, args);
+    }
+    return result;
+  };
+}
+function pick(obj, keys) {
+  return Object.fromEntries(keys.map((k) => [k, obj[k]]));
+}
+function omit(obj, keys) {
+  const set = new Set(keys);
+  return Object.fromEntries(
+    Object.entries(obj).filter(([k]) => !set.has(k))
+  );
+}
+async function retry(fn, attempts, delayMs = 0) {
+  let lastError;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (e) {
+      lastError = e;
+      if (delayMs) await sleep(delayMs);
+    }
+  }
+  throw lastError;
+}
+var noop = () => {
+};
+function tryCatch(fn) {
+  try {
+    return [null, fn()];
+  } catch (e) {
+    return [e];
+  }
+}
+function tap(fn) {
+  return (v) => {
+    fn(v);
+    return v;
+  };
+}
+function* range(end) {
+  let start = 0;
+  let step = 1;
+  let e = 0;
+  if (typeof end === "number") {
+    e = end;
+  } else {
+    start = end.start ?? 0;
+    step = end.step ?? 1;
+    e = end.end;
+  }
+  if (step === 0) throw new RangeError("step cannot be 0");
+  if (step > 0) {
+    for (let i = start; i < e; i += step) yield i;
+  } else {
+    for (let i = start; i > e; i += step) yield i;
+  }
+}
+function* cycle(iterable) {
+  const items = [...iterable];
+  if (!items.length) return;
+  while (true) {
+    for (const i of items) yield i;
+  }
+}
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}
+function shuffle(arr) {
+  const a = [...arr];
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a;
+}
+function sample(arr) {
+  if (!arr.length) return void 0;
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function rotate(arr, n) {
+  const len = arr.length;
+  n = (n % len + len) % len;
+  return [...arr.slice(n), ...arr.slice(0, n)];
+}
+
+// src/duration.ts
+var msValues = {
+  ms: 1,
+  s: 1e3,
+  m: 1e3 * 60,
+  h: 1e3 * 60 * 60,
+  d: 1e3 * 60 * 60 * 24
+};
+function durationLong(initialMs = 0) {
+  let total = initialMs;
+  const add = (v, mult) => {
+    total += v * mult;
+    return builder;
+  };
+  const builder = {
+    toMilliseconds: () => total,
+    toSeconds: () => total / msValues.s,
+    toMinutes: () => total / msValues.m,
+    toHours: () => total / msValues.h,
+    toDays: () => total / msValues.d,
+    milliseconds: (v) => add(v, msValues.ms),
+    seconds: (v) => add(v, msValues.s),
+    minutes: (v) => add(v, msValues.m),
+    hours: (v) => add(v, msValues.h),
+    days: (v) => add(v, msValues.d)
+  };
+  return builder;
+}
+function durationShort(initialMs = 0) {
+  let total = initialMs;
+  const add = (v, mult) => {
+    total += v * mult;
+    return builder;
+  };
+  const builder = {
+    toMs: () => total,
+    toS: () => total / msValues.s,
+    toM: () => total / msValues.m,
+    toH: () => total / msValues.h,
+    toD: () => total / msValues.d,
+    ms: (v) => add(v, msValues.ms),
+    s: (v) => add(v, msValues.s),
+    m: (v) => add(v, msValues.m),
+    h: (v) => add(v, msValues.h),
+    d: (v) => add(v, msValues.d)
+  };
+  return builder;
+}
+function cS(unit) {
+  return (v) => durationShort()[unit](v);
+}
+function cL(unit) {
+  return (v) => durationLong()[unit](v);
+}
+var days = cL("days");
+var hours = cL("hours");
+var minutes = cL("minutes");
+var seconds = cL("seconds");
+var milliseconds = cL("milliseconds");
+var d = cS("d");
+var h = cS("h");
+var m = cS("m");
+var s = cS("s");
+var ms = cS("ms");
+
+// src/numbers.ts
+function bigIntPower(one, two) {
+  if (two === 0n) return 1n;
+  const powerTwo = bigIntPower(one, two / 2n);
+  if (two % 2n === 0n) return powerTwo * powerTwo;
+  return one * powerTwo * powerTwo;
+}
+function convertBase(value, sourceBase, outBase, chars = convertBase.defaultChars) {
+  const range2 = [...chars];
+  if (sourceBase < 2 || sourceBase > range2.length)
+    throw new RangeError(`sourceBase must be between 2 and ${range2.length}`);
+  if (outBase < 2 || outBase > range2.length)
+    throw new RangeError(`outBase must be between 2 and ${range2.length}`);
+  const outBaseBig = BigInt(outBase);
+  let decValue = [...value].toReversed().reduce((carry, digit, loopIndex) => {
+    const biggestBaseIndex = range2.indexOf(digit);
+    if (biggestBaseIndex === -1 || biggestBaseIndex > sourceBase - 1)
+      throw new ReferenceError(
+        `Invalid digit ${digit} for base ${sourceBase}.`
+      );
+    return carry + BigInt(biggestBaseIndex) * bigIntPower(BigInt(sourceBase), BigInt(loopIndex));
+  }, 0n);
+  let output = "";
+  while (decValue > 0) {
+    output = `${range2[Number(decValue % outBaseBig)] ?? ""}${output}`;
+    decValue = (decValue - decValue % outBaseBig) / outBaseBig;
+  }
+  return output || "0";
+}
+convertBase.defaultChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-/=[];',.";
+convertBase.MAX_BASE = convertBase.defaultChars.length;
+function clamp(number, min, max) {
+  return Math.max(min, Math.min(max, number));
+}
+function randInt(min, max, inclusive = true) {
+  if (min > max) {
+    throw new RangeError("RandInt: min cannot be greater than max");
+  }
+  return Math.floor(Math.random() * (max - min + +inclusive)) + min;
+}
+function chance(probability) {
+  return Math.random() < probability;
+}
+function roundTo(n, decimals) {
+  const f = 10 ** decimals;
+  return Math.round(n * f) / f;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function inRange(n, min, max) {
+  return n >= min && n <= max;
+}
+
+// src/class.ts
+var TimedMap = class {
+  constructor(defaultTtlMs) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  defaultTtlMs;
+  map = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  set(key, value, ttlMs = this.defaultTtlMs) {
+    this.map.set(key, value);
+    const timer = setTimeout(() => {
+      this.map.delete(key);
+      this.timers.delete(key);
+    }, ttlMs);
+    this.timers.set(key, timer);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  clear() {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+    this.map.clear();
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  delete(key) {
+    const timer = this.timers.get(key);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(key);
+    return this.map.delete(key);
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var AccessMap = class {
+  constructor(defaultTtlMs) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  defaultTtlMs;
+  map = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  set(key, value, ttlMs = this.defaultTtlMs) {
+    this.map.set(key, value);
+    this.resetTimer(key, ttlMs);
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  clear() {
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+    this.map.clear();
+  }
+  get(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.resetTimer(key);
+    }
+    return value;
+  }
+  delete(key) {
+    const timer = this.timers.get(key);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(key);
+    return this.map.delete(key);
+  }
+  get size() {
+    return this.map.size;
+  }
+  resetTimer(key, ttlMs = this.defaultTtlMs) {
+    const timer = this.timers.get(key);
+    if (timer) clearTimeout(timer);
+    const newTimer = setTimeout(() => {
+      this.map.delete(key);
+      this.timers.delete(key);
+    }, ttlMs);
+    this.timers.set(key, newTimer);
+  }
+};
+export {
+  AccessMap,
+  AsyncQueue,
+  TimedMap,
+  bigIntPower,
+  chance,
+  chunk,
+  clamp,
+  convertBase,
+  cycle,
+  d,
+  days,
+  debounce,
+  deepEqual,
+  deferred,
+  h,
+  hours,
+  inRange,
+  lerp,
+  m,
+  milliseconds,
+  minutes,
+  ms,
+  noop,
+  omit,
+  once,
+  pick,
+  randInt,
+  range,
+  retry,
+  rotate,
+  roundTo,
+  s,
+  sample,
+  seconds,
+  shuffle,
+  sleep,
+  tap,
+  throttle,
+  timeoutPromise,
+  tryCatch
+};
+//! days(12).h(5).s(4).toS();
+//! d(12).hours(5).seconds(4).toS();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@tally.paws/toolbox",
+  "version": "1.2.0",
+  "description": "Core utils and helpers for nodejs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts"
+  },
+  "files": [
+    "dist", "README.md"
+  ],
+  "keywords": ["utility", "debounce", "sleep"],
+  "author": "",
+  "license": "ISC"
+}