qznt 1.0.0 → 1.0.2

package/dist/index.d.ts

@@ -178,6 +178,20 @@ declare const date: {
     parse: typeof parse;
 };
 
+interface ReadDirOptions {
+    /** Whether to scan subdirectories. [default: true] */
+    recursive?: boolean;
+}
+/**
+ * Recursively (or shallowly) scans a directory and returns an array of relative file paths.
+ * @param path The path to the directory.
+ * @param options Options for the readDir function.
+ */
+declare function readDir(path: string, options?: ReadDirOptions): string[];
+declare const fs: {
+    readDir: typeof readDir;
+};
+
 type AlphaCasing = "lower" | "upper" | "mixed";
 interface RndStrOptions {
     casing?: AlphaCasing;
@@ -299,15 +313,9 @@ declare function debounce<T extends (...args: any[]) => any>(fn: T, wait: number
  * window.addEventListener('scroll', handleScroll);
  */
 declare function throttle<T extends (...args: any[]) => any>(fn: T, limit: number): (...args: Parameters<T>) => void;
-/**
- * Returns a promise that resolves after the given number of milliseconds.
- * @param ms The time to wait in milliseconds.
- */
-declare function wait(ms: number): Promise<boolean>;
 declare const timing: {
     debounce: typeof debounce;
     throttle: typeof throttle;
-    wait: typeof wait;
 };
 
 type ToRecordContext<T, V> = {
@@ -446,8 +454,14 @@ declare class Loop<T = any> extends TypedEmitterBase<T> {
  * @param delay Initial delay in milliseconds. [default: 500ms]
  */
 declare function retry<T>(fn: () => Promise<T>, retries?: number, delay?: number): Promise<T>;
+/**
+ * Returns a promise that resolves after the given number of milliseconds.
+ * @param ms The time to wait in milliseconds.
+ */
+declare function wait(ms: number): Promise<boolean>;
 declare const async: {
     retry: typeof retry;
+    wait: typeof wait;
 };
 
 /**
@@ -542,6 +556,14 @@ declare const is: {
     today: typeof today;
 };
 
+/**
+ * Clamps a number within a specified range.
+ * @param num The number to check.
+ * @param min The minimum or maximum value of the range.
+ * @param max The maximum value of the range (optional).
+ */
+declare function clamp(num: number, max: number): number;
+declare function clamp(num: number, min: number, max: number): number;
 /**
  * Calculates the interpolation factor (0-1) of a value between two points.
  * @param start - The starting value (0%).
@@ -599,8 +621,9 @@ declare function secs(num: number): number;
  * @param selector Function that selects the item's weight.
  * @param ignoreNaN If true, NaN values will not throw an error.
  */
-declare function sum<T>(array: T[], selector: (item: T) => number, ignoreNaN?: boolean): number;
+declare function sum<T>(array: T[], selector?: (item: T) => number): number;
 declare const math: {
+    clamp: typeof clamp;
     invLerp: typeof invLerp;
     lerp: typeof lerp;
     ms: typeof ms;
@@ -610,18 +633,6 @@ declare const math: {
     sum: typeof sum;
 };
 
-/**
- * Clamps a number within a specified range.
- * @param num The number to check.
- * @param min The minimum or maximum value of the range.
- * @param max The maximum value of the range (optional).
- */
-declare function clamp(num: number, max: number): number;
-declare function clamp(num: number, min: number, max: number): number;
-declare const num: {
-    clamp: typeof clamp;
-};
-
 /**
  * Retrieves a nested property.
  * @param obj The object to process.
@@ -702,7 +713,7 @@ declare const str: {
     toTitleCase: typeof toTitleCase;
 };
 
-declare const $: {
+declare const qznt: {
     Pipe: typeof Pipe;
     Storage: typeof Storage;
     Cache: typeof Cache;
@@ -737,7 +748,6 @@ declare const $: {
             immediate?: boolean;
         }) => DebouncedFunction<T>;
         throttle: <T extends (...args: any[]) => any>(fn: T, limit: number) => (...args: Parameters<T>) => void;
-        wait: (ms: number) => Promise<boolean>;
     };
     obj: {
         get: <T = any>(obj: Record<string, any>, path: string, defaultValue?: T) => T;
@@ -752,20 +762,18 @@ declare const $: {
         pick: <T extends object, K extends keyof T>(obj: T, keys: K[]) => Pick<T, K>;
         omit: <T extends object, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
     };
-    num: {
+    math: {
         clamp: {
             (num: number, max: number): number;
             (num: number, min: number, max: number): number;
         };
-    };
-    math: {
         invLerp: (start: number, end: number, value: number) => number;
         lerp: (start: number, end: number, t: number) => number;
         ms: (num: number) => number;
         percent: (a: number, b: number, round?: boolean) => number;
         remap: (value: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
         secs: (num: number) => number;
-        sum: <T>(array: T[], selector: (item: T) => number, ignoreNaN?: boolean) => number;
+        sum: <T>(array: T[], selector?: (item: T) => number) => number;
     };
     is: {
         defined: <T>(val: T | undefined | null) => val is T;
@@ -779,6 +787,9 @@ declare const $: {
         string: (val: unknown) => val is string;
         today: (date: number | Date) => boolean;
     };
+    fs: {
+        readDir: (path: string, options?: ReadDirOptions) => string[];
+    };
     format: {
         currency: (num: number, options?: {
             currency?: string;
@@ -805,6 +816,7 @@ declare const $: {
     };
     async: {
         retry: <T>(fn: () => Promise<T>, retries?: number, delay?: number) => Promise<T>;
+        wait: (ms: number) => Promise<boolean>;
     };
     arr: {
         chunk: <T>(array: ReadonlyArray<T>, size: number) => T[][];
@@ -825,7 +837,7 @@ declare const $: {
         unique: <T>(array: T[], key: (item: T) => any) => T[];
     };
 };
-declare const qznt: {
+declare const $: {
     Pipe: typeof Pipe;
     Storage: typeof Storage;
     Cache: typeof Cache;
@@ -860,7 +872,6 @@ declare const qznt: {
             immediate?: boolean;
         }) => DebouncedFunction<T>;
         throttle: <T extends (...args: any[]) => any>(fn: T, limit: number) => (...args: Parameters<T>) => void;
-        wait: (ms: number) => Promise<boolean>;
     };
     obj: {
         get: <T = any>(obj: Record<string, any>, path: string, defaultValue?: T) => T;
@@ -875,20 +886,18 @@ declare const qznt: {
         pick: <T extends object, K extends keyof T>(obj: T, keys: K[]) => Pick<T, K>;
         omit: <T extends object, K extends keyof T>(obj: T, keys: K[]) => Omit<T, K>;
     };
-    num: {
+    math: {
         clamp: {
             (num: number, max: number): number;
             (num: number, min: number, max: number): number;
         };
-    };
-    math: {
         invLerp: (start: number, end: number, value: number) => number;
         lerp: (start: number, end: number, t: number) => number;
         ms: (num: number) => number;
         percent: (a: number, b: number, round?: boolean) => number;
         remap: (value: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
         secs: (num: number) => number;
-        sum: <T>(array: T[], selector: (item: T) => number, ignoreNaN?: boolean) => number;
+        sum: <T>(array: T[], selector?: (item: T) => number) => number;
     };
     is: {
         defined: <T>(val: T | undefined | null) => val is T;
@@ -902,6 +911,9 @@ declare const qznt: {
         string: (val: unknown) => val is string;
         today: (date: number | Date) => boolean;
     };
+    fs: {
+        readDir: (path: string, options?: ReadDirOptions) => string[];
+    };
     format: {
         currency: (num: number, options?: {
             currency?: string;
@@ -928,6 +940,7 @@ declare const qznt: {
     };
     async: {
         retry: <T>(fn: () => Promise<T>, retries?: number, delay?: number) => Promise<T>;
+        wait: (ms: number) => Promise<boolean>;
     };
     arr: {
         chunk: <T>(array: ReadonlyArray<T>, size: number) => T[][];
@@ -949,4 +962,4 @@ declare const qznt: {
     };
 };
 
-export { type AlphaCasing, type AnyFunc, Cache, type DateOptions, type DebouncedFunction, type DeepPartial, Loop, type MemoizedFunction, type ParseOptions, Pipe, type RndStrOptions, type SequentialMapContext, Storage, type ToRecordContext, type TypedEmitter, arr, async, date, $ as default, fn, format, is, math, num, obj, qznt, rnd, str, timing, to };
+export { $, type AlphaCasing, type AnyFunc, Cache, type DateOptions, type DebouncedFunction, type DeepPartial, Loop, type MemoizedFunction, type ParseOptions, Pipe, type ReadDirOptions, type RndStrOptions, type SequentialMapContext, Storage, type ToRecordContext, type TypedEmitter, arr, async, date, qznt as default, fn, format, fs, is, math, obj, rnd, str, timing, to };

package/dist/index.js

@@ -286,8 +286,16 @@ async function retry(fn2, retries = 3, delay = 500) {
     return await new Promise((resolve) => setTimeout(resolve, delay + jitter));
   }
 }
+function wait(ms2) {
+  return new Promise(
+    (resolve) => setTimeout(() => {
+      resolve(true);
+    }, ms2)
+  );
+}
 var async = {
-  retry
+  retry,
+  wait
 };
 
 // src/fn.ts
@@ -408,17 +416,17 @@ var format_exports = {};
 __export(format_exports, {
   format: () => format
 });
-function currency(num2, options = {}) {
+function currency(num, options = {}) {
   return new Intl.NumberFormat(options.locale, {
     style: "currency",
     currency: options.currency
-  }).format(num2);
+  }).format(num);
 }
-function number(num2, options = {}) {
+function number(num, options = {}) {
   return new Intl.NumberFormat(options.locale, {
     minimumFractionDigits: options.precision,
     maximumFractionDigits: options.precision
-  }).format(num2);
+  }).format(num);
 }
 function memory(bytes, decimals = 1, units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]) {
   if (bytes <= 0) return `0 ${units[0]}`;
@@ -426,8 +434,8 @@ function memory(bytes, decimals = 1, units = ["B", "KB", "MB", "GB", "TB", "PB",
   const val = bytes / Math.pow(1024, i);
   return `${val.toFixed(i === 0 ? 0 : decimals)} ${units[i]}`;
 }
-function ordinal(num2, locale) {
-  const _num = Number(num2);
+function ordinal(num, locale) {
+  const _num = Number(num);
   if (isNaN(_num)) throw new TypeError("Invalid input");
   const pr = new Intl.PluralRules(locale, { type: "ordinal" });
   const rule = pr.select(_num);
@@ -440,12 +448,12 @@ function ordinal(num2, locale) {
   const suffix = suffixes[rule] || "th";
   return _num.toLocaleString(locale) + suffix;
 }
-function compactNumber(num2, locale) {
+function compactNumber(num, locale) {
   return new Intl.NumberFormat(locale, {
     notation: "compact",
     compactDisplay: "short",
     maximumFractionDigits: 1
-  }).format(num2);
+  }).format(num);
 }
 var format = {
   currency,
@@ -455,6 +463,41 @@ var format = {
   compactNumber
 };
 
+// src/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  fs: () => fs
+});
+import _fs from "fs";
+import { join } from "path";
+function readDir(path2, options = {}) {
+  const { recursive = true } = options;
+  if (!_fs.existsSync(path2)) return [];
+  if (!recursive) {
+    return _fs.readdirSync(path2).filter((fn2) => {
+      return _fs.statSync(join(path2, fn2)).isFile();
+    });
+  }
+  const walk = (dir, base = "") => {
+    const results = [];
+    const entries = _fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = base ? join(base, entry.name) : entry.name;
+      const fullPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        results.push(...walk(fullPath, relativePath));
+      } else if (entry.isFile()) {
+        results.push(relativePath);
+      }
+    }
+    return results;
+  };
+  return walk(path2);
+}
+var fs = {
+  readDir
+};
+
 // src/is.ts
 var is_exports = {};
 __export(is_exports, {
@@ -469,11 +512,11 @@ function empty(val) {
   if (object(val)) return Object.keys(val).length === 0;
   return false;
 }
-function inRange(num2, a, b) {
+function inRange(num, a, b) {
   let min = b !== void 0 ? a : 0;
   let max = b !== void 0 ? b : a;
   if (min > max) [min, max] = [max, min];
-  return num2 >= min && num2 <= max;
+  return num >= min && num <= max;
 }
 function object(val) {
   return val !== null && typeof val === "object" && !Array.isArray(val);
@@ -508,6 +551,12 @@ var math_exports = {};
 __export(math_exports, {
   math: () => math
 });
+function clamp(num, a, b) {
+  let min = b !== void 0 ? a : 0;
+  let max = b !== void 0 ? b : a;
+  if (min > max) [min, max] = [max, min];
+  return Math.max(min, Math.min(num, max));
+}
 function invLerp(start, end, value) {
   if (start === end) return 0;
   return (value - start) / (end - start);
@@ -515,8 +564,8 @@ function invLerp(start, end, value) {
 function lerp(start, end, t) {
   return start + (end - start) * t;
 }
-function ms(num2) {
-  return Math.floor(num2 * 1e3);
+function ms(num) {
+  return Math.floor(num * 1e3);
 }
 function percent(a, b, round = true) {
   const result = a / b * 100;
@@ -526,17 +575,20 @@ function remap(value, inMin, inMax, outMin, outMax) {
   const t = invLerp(inMin, inMax, value);
   return lerp(outMin, outMax, t);
 }
-function secs(num2) {
-  return Math.floor(num2 / 1e3);
+function secs(num) {
+  return Math.floor(num / 1e3);
 }
-function sum(array, selector, ignoreNaN) {
-  return array.map(selector).reduce((a, b) => {
-    const invalid = isNaN(b) && !ignoreNaN;
-    if (invalid) throw new TypeError(`sum: '${b}' is not a valid number.`);
+function sum(array, selector) {
+  const _array = selector ? array.map(selector) : array;
+  if (!_array.every((v) => typeof v === "number")) {
+    throw new TypeError(`sum: Array must only contain numbers.`);
+  }
+  return _array.reduce((a, b) => {
     return (isNaN(b) ? 0 : b) < 0 ? a - -b : a + (b || 0);
   }, 0);
 }
 var math = {
+  clamp,
   invLerp,
   lerp,
   ms,
@@ -546,21 +598,6 @@ var math = {
   sum
 };
 
-// src/num.ts
-var num_exports = {};
-__export(num_exports, {
-  num: () => num
-});
-function clamp(num2, a, b) {
-  let min = b !== void 0 ? a : 0;
-  let max = b !== void 0 ? b : a;
-  if (min > max) [min, max] = [max, min];
-  return Math.max(min, Math.min(num2, max));
-}
-var num = {
-  clamp
-};
-
 // src/obj.ts
 var obj_exports = {};
 __export(obj_exports, {
@@ -738,17 +775,9 @@ function throttle(fn2, limit) {
     }
   };
 }
-function wait(ms2) {
-  return new Promise(
-    (resolve) => setTimeout(() => {
-      resolve(true);
-    }, ms2)
-  );
-}
 var timing = {
   debounce,
-  throttle,
-  wait
+  throttle
 };
 
 // src/to.ts
@@ -782,16 +811,16 @@ function Pipe(value, ...fns) {
 }
 
 // src/Storage.ts
-import fs from "fs";
+import fs2 from "fs";
 import path from "path";
 var Storage = class {
   isNode = typeof window === "undefined";
   filePath = null;
   memoryCache = /* @__PURE__ */ new Map();
   loadFromFile() {
-    if (this.filePath && fs.existsSync(this.filePath)) {
+    if (this.filePath && fs2.existsSync(this.filePath)) {
       try {
-        const data = JSON.parse(fs.readFileSync(this.filePath, "utf-8"));
+        const data = JSON.parse(fs2.readFileSync(this.filePath, "utf-8"));
         Object.entries(data).forEach(([k, v]) => this.memoryCache.set(k, JSON.stringify(v)));
       } catch (err) {
         console.error(`Store: Failed to load file '${this.filePath}'`, err);
@@ -802,7 +831,7 @@ var Storage = class {
     if (this.isNode && this.filePath) {
       const out = {};
       this.memoryCache.forEach((v, k) => out[k] = JSON.parse(v));
-      fs.writeFileSync(this.filePath, JSON.stringify(out, null, 2));
+      fs2.writeFileSync(this.filePath, JSON.stringify(out, null, 2));
     }
   }
   /**
@@ -1014,15 +1043,15 @@ var Loop = class extends TypedEmitterBase {
 };
 
 // src/index.ts
-var $ = {
+var qznt = {
   ...arr_exports,
   ...async_exports,
   ...fn_exports,
   ...date_exports,
   ...format_exports,
+  ...fs_exports,
   ...is_exports,
   ...math_exports,
-  ...num_exports,
   ...obj_exports,
   ...timing_exports,
   ...rnd_exports,
@@ -1033,9 +1062,10 @@ var $ = {
   Cache,
   Loop
 };
-var qznt = $;
-var index_default = $;
+var $ = qznt;
+var index_default = qznt;
 export {
+  $,
   Cache,
   Loop,
   Pipe,
@@ -1046,11 +1076,10 @@ export {
   index_default as default,
   fn,
   format,
+  fs,
   is,
   math,
-  num,
   obj,
-  qznt,
   rnd,
   str2 as str,
   timing,