@splendidlabz/utils 1.10.2 → 1.10.3

package/dist/cjs/node/index.cjs

@@ -1,13 +1,7 @@
-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))
@@ -16,275 +10,24 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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,
-  getLastModifiedTime: () => getLastModifiedTime,
-  getLatestModifiedTime: () => getLatestModifiedTime,
-  randomString: () => randomString,
-  removeFirstSlash: () => removeFirstSlash,
-  sanitize: () => sanitize2,
-  sha256Hash: () => sha256Hash,
-  uuid: () => uuid
-});
 module.exports = __toCommonJS(node_exports);
-
-// src/node/common.js
-var import_crypto = __toESM(require("crypto"), 1);
-function uuid() {
-  return import_crypto.default.randomUUID();
-}
-
-// 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
-async function createCache(dir) {
-  const absDirpath = import_node_path2.default.join(process.cwd(), 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(dir + "/**/*");
-      }
-    },
-    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 }) {
-  await import_promises.default.mkdir(import_node_path2.default.join(process.cwd(), dir), { recursive: true });
-  const cachePath = import_node_path2.default.join(process.cwd(), dir, `${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"
-  };
-}
-async 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 });
-}
+__reExport(node_exports, require("./common.js"), module.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);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PKCE,
-  __dirname,
-  createCache,
-  dirname,
-  fileCache,
-  getLastModifiedTime,
-  getLatestModifiedTime,
-  randomString,
-  removeFirstSlash,
-  sanitize,
-  sha256Hash,
-  uuid
+  ...require("./common.js"),
+  ...require("./dirname.js"),
+  ...require("./file-cache.js"),
+  ...require("./hash.js"),
+  ...require("./pkce.js"),
+  ...require("./random-string.js"),
+  ...require("./sanitize.js")
 });

package/dist/cjs/node/pkce.cjs

@@ -25,35 +25,25 @@ 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
 });
 module.exports = __toCommonJS(pkce_exports);
-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
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_random_string = require("./random-string.js");
 async function PKCE() {
-  const codeVerifier = await randomString();
+  const codeVerifier = await (0, import_random_string.randomString)();
   const codeChallenge = await getCodeChallenge(codeVerifier);
   return {
-    state: await randomString(),
+    state: await (0, import_random_string.randomString)(),
     code_verifier: codeVerifier,
     code_challenge: codeChallenge,
     code_challenge_method: "S256"
   };
 }
 async function getCodeChallenge(verifier) {
-  const hash = import_node_crypto2.default.createHash("sha256").update(verifier).digest();
+  const hash = import_node_crypto.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:

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

@@ -25,14 +25,12 @@ 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("crypto"), 1);
+var import_node_crypto = __toESM(require("node: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,39 +25,15 @@ 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: () => sanitize2
+  sanitize: () => sanitize
 });
 module.exports = __toCommonJS(sanitize_exports);
 var import_sanitize_html = __toESM(require("sanitize-html"), 1);
-
-// src/lib/form/sanitize.js
+var import_sanitize = require("../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 });
+  return (0, import_sanitize.sanitize)(value, { sanitizer: import_sanitize_html.default, ...options });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/esm/dom/accessibility.js

@@ -1,4 +1,3 @@
-// src/dom/accessibility.js
 function hasAccessibleName(label, labelledBy) {
   if (label || labelledBy) return true;
   return false;