@splendidlabz/utils 1.11.2 → 1.11.4

package/dist/cjs/node/index.cjs

@@ -1,7 +1,13 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -10,24 +16,281 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/index.js
 var node_exports = {};
+__export(node_exports, {
+  PKCE: () => PKCE,
+  __dirname: () => __dirname,
+  createCache: () => createCache,
+  dirname: () => dirname,
+  fileCache: () => fileCache,
+  getCodeChallenge: () => getCodeChallenge,
+  getLastModifiedTime: () => getLastModifiedTime,
+  getLatestModifiedTime: () => getLatestModifiedTime,
+  randomString: () => randomString,
+  removeFirstSlash: () => removeFirstSlash,
+  sanitize: () => sanitize2,
+  sha256Hash: () => sha256Hash,
+  uuid: () => uuid
+});
 module.exports = __toCommonJS(node_exports);
-__reExport(node_exports, require("./dirname.js"), module.exports);
-__reExport(node_exports, require("./file-cache.js"), module.exports);
-__reExport(node_exports, require("./hash.js"), module.exports);
-__reExport(node_exports, require("./pkce.js"), module.exports);
-__reExport(node_exports, require("./random-string.js"), module.exports);
-__reExport(node_exports, require("./sanitize.js"), module.exports);
-__reExport(node_exports, require("./uuid.js"), module.exports);
+
+// src/node/dirname.js
+var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function __dirname(url) {
+  if (!url) throw Error("Please provide 'import.meta.url' to dirname");
+  return import_node_path.default.dirname((0, import_node_url.fileURLToPath)(url));
+}
+function dirname(url) {
+  return __dirname(url);
+}
+
+// src/node/file-cache.js
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_glob = require("glob");
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/lib/objects/nested-property.js
+function getNestedValue(object, path3) {
+  return path3.split(".").reduce((acc, part) => acc?.[part], object);
+}
+
+// src/lib/arrays/sort.js
+function sort(array, { props = null, reverse = false } = {}) {
+  const clone = array.slice();
+  if (props === null) {
+    return clone.sort((a, b) => {
+      const comparison = compareValues(a, b);
+      return reverse ? -comparison : comparison;
+    });
+  }
+  const properties = Array.isArray(props) ? props : [props];
+  return clone.sort((a, b) => {
+    for (const property of properties) {
+      const aValue = getNestedValue(a, property);
+      const bValue = getNestedValue(b, property);
+      if (aValue === bValue) continue;
+      if (aValue == null) return 1;
+      if (bValue == null) return -1;
+      const comparison = compareValues(aValue, bValue);
+      return reverse ? -comparison : comparison;
+    }
+    return 0;
+  });
+}
+function compareValues(a, b) {
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") return a.localeCompare(b);
+  const aDate = new Date(a);
+  const bDate = new Date(b);
+  const aTime = aDate.getTime();
+  const bTime = bDate.getTime();
+  if (!isNaN(aTime) && !isNaN(bTime)) return aTime - bTime;
+  return String(a).localeCompare(String(b));
+}
+
+// src/node/file-cache.js
+function resolveDirPath(dirPath) {
+  return import_node_path2.default.isAbsolute(dirPath) ? dirPath : import_node_path2.default.join(process.cwd(), dirPath);
+}
+async function createCache(dir) {
+  const absDirpath = resolveDirPath(dir);
+  await import_promises.default.mkdir(absDirpath, { recursive: true });
+  return {
+    async cacheAt(file) {
+      if (file) {
+        const absFilepath = import_node_path2.default.join(absDirpath, file);
+        try {
+          const stat = await import_promises.default.stat(absFilepath);
+          return stat.mtimeMs;
+        } catch (error) {
+          return 0;
+        }
+      } else {
+        return getLastModifiedTime(absDirpath + "/**/*");
+      }
+    },
+    getAbsPath(file) {
+      return import_node_path2.default.join(absDirpath, file);
+    },
+    async hasFile(file) {
+      const absFilepath = import_node_path2.default.join(absDirpath, file);
+      try {
+        await import_promises.default.stat(absFilepath);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    async loadFile(file) {
+      try {
+        const absFilepath = import_node_path2.default.join(absDirpath, file);
+        return import_promises.default.readFile(absFilepath);
+      } catch (error) {
+        console.warn(`File not found: ${file}`);
+      }
+    },
+    async saveFile(file, data) {
+      const absfilepath = import_node_path2.default.join(absDirpath, file);
+      await import_promises.default.writeFile(absfilepath, data);
+    },
+    async loadJSON(file) {
+      const data = await this.loadFile(file);
+      try {
+        return JSON.parse(data.toString());
+      } catch (err) {
+        console.warn(`Error parsing JSON: ${file}`);
+        return {};
+      }
+    },
+    async saveJSON(file, data) {
+      await this.saveFile(file, JSON.stringify(data));
+    }
+  };
+}
+async function fileCache({ dir, file }) {
+  const absDirpath = resolveDirPath(dir);
+  await import_promises.default.mkdir(absDirpath, { recursive: true });
+  const cachePath = import_node_path2.default.join(absDirpath, `${file}`);
+  let modifiedAt = 0;
+  try {
+    const stat = await import_promises.default.stat(cachePath);
+    modifiedAt = stat.mtimeMs;
+  } catch (error) {
+  }
+  return {
+    modifiedAt,
+    async load() {
+      return import_promises.default.readFile(cachePath);
+    },
+    async save(data) {
+      await import_promises.default.writeFile(cachePath, data);
+    },
+    async loadJSON() {
+      const data = await import_promises.default.readFile(cachePath);
+      return JSON.parse(data.toString());
+    },
+    async saveJSON(data) {
+      await import_promises.default.writeFile(cachePath, JSON.stringify(data));
+    }
+  };
+}
+async function getLastModifiedTime(globPath) {
+  let files;
+  if (typeof globPath === "string") {
+    files = await (0, import_glob.glob)(removeFirstSlash(globPath));
+  }
+  if (Array.isArray(globPath)) {
+    const a = await Promise.all(
+      globPath.map((path3) => (0, import_glob.glob)(removeFirstSlash(path3)))
+    );
+    files = a.flat();
+  }
+  const stats = await Promise.all(files.map((file) => import_promises.default.stat(file)));
+  const timestamps = stats.map((stat) => Number(stat.mtimeMs));
+  const sorted = sort(timestamps, { props: "mtimeMs", reverse: true });
+  return sorted[0] || 0;
+}
+async function getLatestModifiedTime(globPath) {
+  console.warn(
+    "`getLatestModifiedTime` has been renamed to `getLastModifiedTime` and will be deprecated in future versions. Please use `getLastModifiedTime` instead."
+  );
+  return getLastModifiedTime(globPath);
+}
+function removeFirstSlash(x) {
+  return x.startsWith("/") ? x.slice(1) : x;
+}
+
+// src/node/hash.js
+var import_node_crypto = __toESM(require("crypto"), 1);
+function sha256Hash(string) {
+  return import_node_crypto.default.createHash("sha256").update(string).digest("hex");
+}
+
+// src/node/pkce.js
+var import_node_crypto3 = __toESM(require("crypto"), 1);
+
+// src/node/random-string.js
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return import_node_crypto2.default.randomBytes(bytesNeeded).toString("base64").slice(0, length);
+}
+
+// src/node/pkce.js
+async function PKCE() {
+  const codeVerifier = await randomString();
+  const codeChallenge = await getCodeChallenge(codeVerifier);
+  return {
+    state: await randomString(),
+    code_verifier: codeVerifier,
+    code_challenge: codeChallenge,
+    code_challenge_method: "S256"
+  };
+}
+function getCodeChallenge(verifier) {
+  const hash = import_node_crypto3.default.createHash("sha256").update(verifier).digest();
+  return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// src/node/sanitize.js
+var import_sanitize_html = __toESM(require("sanitize-html"), 1);
+
+// src/lib/form/sanitize.js
+function sanitize(value, options = {}) {
+  const { sanitizer, ...rest } = options;
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  if (typeof value === "string") return sanitizer(value, rest);
+  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest });
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        key,
+        sanitize(val, { sanitizer, ...rest })
+      ])
+    );
+  }
+  return value;
+}
+function sanitizeArray(arr, { sanitizer, ...rest }) {
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  return arr.map((item) => sanitize(item, { sanitizer, ...rest }));
+}
+
+// src/node/sanitize.js
+function sanitize2(value, options = {}) {
+  return sanitize(value, { sanitizer: import_sanitize_html.default, ...options });
+}
+
+// src/node/uuid.js
+var import_crypto = __toESM(require("crypto"), 1);
+function uuid() {
+  return import_crypto.default.randomUUID();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ...require("./dirname.js"),
-  ...require("./file-cache.js"),
-  ...require("./hash.js"),
-  ...require("./pkce.js"),
-  ...require("./random-string.js"),
-  ...require("./sanitize.js"),
-  ...require("./uuid.js")
+  PKCE,
+  __dirname,
+  createCache,
+  dirname,
+  fileCache,
+  getCodeChallenge,
+  getLastModifiedTime,
+  getLatestModifiedTime,
+  randomString,
+  removeFirstSlash,
+  sanitize,
+  sha256Hash,
+  uuid
 });

package/dist/cjs/node/pkce.cjs

@@ -25,28 +25,40 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/pkce.js
 var pkce_exports = {};
 __export(pkce_exports, {
-  PKCE: () => PKCE
+  PKCE: () => PKCE,
+  getCodeChallenge: () => getCodeChallenge
 });
 module.exports = __toCommonJS(pkce_exports);
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-var import_random_string = require("./random-string.js");
+var import_node_crypto2 = __toESM(require("crypto"), 1);
+
+// src/node/random-string.js
+var import_node_crypto = __toESM(require("crypto"), 1);
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return import_node_crypto.default.randomBytes(bytesNeeded).toString("base64").slice(0, length);
+}
+
+// src/node/pkce.js
 async function PKCE() {
-  const codeVerifier = await (0, import_random_string.randomString)();
+  const codeVerifier = await randomString();
   const codeChallenge = await getCodeChallenge(codeVerifier);
   return {
-    state: await (0, import_random_string.randomString)(),
+    state: await randomString(),
     code_verifier: codeVerifier,
     code_challenge: codeChallenge,
     code_challenge_method: "S256"
   };
 }
-async function getCodeChallenge(verifier) {
-  const hash = import_node_crypto.default.createHash("sha256").update(verifier).digest();
+function getCodeChallenge(verifier) {
+  const hash = import_node_crypto2.default.createHash("sha256").update(verifier).digest();
   return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PKCE
+  PKCE,
+  getCodeChallenge
 });

package/dist/cjs/node/random-string.cjs

@@ -25,12 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/random-string.js
 var random_string_exports = {};
 __export(random_string_exports, {
   randomString: () => randomString
 });
 module.exports = __toCommonJS(random_string_exports);
-var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_crypto = __toESM(require("crypto"), 1);
 function randomString(length = 32) {
   const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
   return import_node_crypto.default.randomBytes(bytesNeeded).toString("base64").slice(0, length);

package/dist/cjs/node/sanitize.cjs

@@ -25,15 +25,39 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/sanitize.js
 var sanitize_exports = {};
 __export(sanitize_exports, {
-  sanitize: () => sanitize
+  sanitize: () => sanitize2
 });
 module.exports = __toCommonJS(sanitize_exports);
 var import_sanitize_html = __toESM(require("sanitize-html"), 1);
-var import_sanitize = require("../lib/form/sanitize.js");
+
+// src/lib/form/sanitize.js
 function sanitize(value, options = {}) {
-  return (0, import_sanitize.sanitize)(value, { sanitizer: import_sanitize_html.default, ...options });
+  const { sanitizer, ...rest } = options;
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  if (typeof value === "string") return sanitizer(value, rest);
+  if (Array.isArray(value)) return sanitizeArray(value, { sanitizer, ...rest });
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, val]) => [
+        key,
+        sanitize(val, { sanitizer, ...rest })
+      ])
+    );
+  }
+  return value;
+}
+function sanitizeArray(arr, { sanitizer, ...rest }) {
+  if (!sanitizer) throw new Error("sanitizer function is required");
+  return arr.map((item) => sanitize(item, { sanitizer, ...rest }));
+}
+
+// src/node/sanitize.js
+function sanitize2(value, options = {}) {
+  return sanitize(value, { sanitizer: import_sanitize_html.default, ...options });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/node/uuid.cjs

@@ -25,6 +25,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/node/uuid.js
 var uuid_exports = {};
 __export(uuid_exports, {
   uuid: () => uuid

package/dist/esm/node/file-cache.js

@@ -1,7 +1,7 @@
 import fs from "fs/promises";
 import { glob } from "glob";
 import path from "node:path";
-import { sort } from "../lib/arrays/index.js";
+import { sort } from "../lib/arrays/sort.js";
 function resolveDirPath(dirPath) {
   return path.isAbsolute(dirPath) ? dirPath : path.join(process.cwd(), dirPath);
 }

package/dist/esm/node/pkce.js

@@ -10,10 +10,11 @@ async function PKCE() {
     code_challenge_method: "S256"
   };
 }
-async function getCodeChallenge(verifier) {
+function getCodeChallenge(verifier) {
   const hash = crypto.createHash("sha256").update(verifier).digest();
   return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
 export {
-  PKCE
+  PKCE,
+  getCodeChallenge
 };

package/dist/types/node/context.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/types/node/index.d.cts

@@ -1,7 +1,7 @@
 export { __dirname, dirname } from './dirname.cjs';
 export { createCache, fileCache, getLastModifiedTime, getLatestModifiedTime, removeFirstSlash } from './file-cache.cjs';
 export { sha256Hash } from './hash.cjs';
-export { PKCE } from './pkce.cjs';
+export { PKCE, getCodeChallenge } from './pkce.cjs';
 export { randomString } from './random-string.cjs';
 export { sanitize } from './sanitize.cjs';
 export { uuid } from './uuid.cjs';

package/dist/types/node/pkce.d.cts

@@ -4,5 +4,11 @@ declare function PKCE(): Promise<{
     code_challenge: string;
     code_challenge_method: string;
 }>;
+/**
+ * Generates code challenge in node
+ * @param {string} verifier
+ * @returns string
+ */
+declare function getCodeChallenge(verifier: string): string;
 
-export { PKCE };
+export { PKCE, getCodeChallenge };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@splendidlabz/utils",
-  "version": "1.11.2",
+  "version": "1.11.4",
   "description": "",
   "type": "module",
   "homepage": "https://splendidlabz.com/docs/utils",
   "sideEffects": false,
+  "files": [
+    "dist"
+  ],
   "main": "./dist/cjs/lib/index.cjs",
   "module": "./dist/esm/lib/index.js",
   "types": "./dist/types/lib/index.d.cts",
@@ -66,7 +69,7 @@
     "statuses": "^2.0.1"
   },
   "devDependencies": {
-    "@splendidlabz/eslint-config": "2.1.0",
+    "@splendidlabz/eslint-config": "2.1.3",
     "jsdom": "^26.0.0",
     "np": "^10.2.0",
     "tsup": "^8.0.0",