@splendidlabz/utils 1.5.1 → 1.7.0

package/dist/esm/node/dirname.js

@@ -0,0 +1,14 @@
+// src/node/dirname.js
+import path from "path";
+import { fileURLToPath } from "url";
+function __dirname(url) {
+  if (!url) throw Error("Please provide 'import.meta.url' to dirname");
+  return path.dirname(fileURLToPath(url));
+}
+function dirname(url) {
+  return __dirname(url);
+}
+export {
+  __dirname,
+  dirname
+};

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

@@ -0,0 +1,158 @@
+// src/node/file-cache.js
+import fs from "fs/promises";
+import glob from "glob-promise";
+import path from "path";
+
+// src/lib/objects/nested-property.js
+function getNestedValue(object, path2) {
+  return path2.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 = path.join(process.cwd(), dir);
+  await fs.mkdir(absDirpath, { recursive: true });
+  return {
+    async cacheAt(file) {
+      if (file) {
+        const absFilepath = path.join(absDirpath, file);
+        try {
+          const stat = await fs.stat(absFilepath);
+          return stat.mtimeMs;
+        } catch (error) {
+          return 0;
+        }
+      } else {
+        return getLastModifiedTime(dir + "/**/*");
+      }
+    },
+    getAbsPath(file) {
+      return path.join(absDirpath, file);
+    },
+    async hasFile(file) {
+      const absFilepath = path.join(absDirpath, file);
+      try {
+        await fs.stat(absFilepath);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    async loadFile(file) {
+      try {
+        const absFilepath = path.join(absDirpath, file);
+        return fs.readFile(absFilepath);
+      } catch (error) {
+        console.warn(`File not found: ${file}`);
+      }
+    },
+    async saveFile(file, data) {
+      const absfilepath = path.join(absDirpath, file);
+      await fs.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 fs.mkdir(path.join(process.cwd(), dir), { recursive: true });
+  const cachePath = path.join(process.cwd(), dir, `${file}`);
+  let modifiedAt = 0;
+  try {
+    const stat = await fs.stat(cachePath);
+    modifiedAt = stat.mtimeMs;
+  } catch (error) {
+  }
+  return {
+    modifiedAt,
+    async load() {
+      return fs.readFile(cachePath);
+    },
+    async save(data) {
+      await fs.writeFile(cachePath, data);
+    },
+    async loadJSON() {
+      const data = await fs.readFile(cachePath);
+      return JSON.parse(data.toString());
+    },
+    async saveJSON(data) {
+      await fs.writeFile(cachePath, JSON.stringify(data));
+    }
+  };
+}
+async function getLastModifiedTime(globPath) {
+  let files;
+  if (typeof globPath === "string") {
+    files = await glob(removeFirstSlash(globPath));
+  }
+  if (Array.isArray(globPath)) {
+    const a = await Promise.all(
+      globPath.map((path2) => glob(removeFirstSlash(path2)))
+    );
+    files = a.flat();
+  }
+  const stats = await Promise.all(files.map((file) => fs.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;
+}
+export {
+  createCache,
+  fileCache,
+  getLastModifiedTime,
+  getLatestModifiedTime,
+  removeFirstSlash
+};

package/dist/esm/node/file.js

@@ -0,0 +1,15 @@
+// src/node/file.js
+import fs from "fs/promises";
+import path from "path";
+async function mkdir(path2) {
+  return fs.mkdir(path2, { recursive: true });
+}
+async function copyFile(from, to) {
+  const dir = path.dirname(to);
+  await mkdir(dir);
+  await fs.copyFile(from, to);
+}
+export {
+  copyFile,
+  mkdir
+};

package/dist/esm/node/hash.js

@@ -0,0 +1,8 @@
+// src/node/hash.js
+import crypto from "crypto";
+function sha256Hash(string) {
+  return crypto.createHash("sha256").update(string).digest("hex");
+}
+export {
+  sha256Hash
+};

package/dist/esm/node/index.js

@@ -0,0 +1,243 @@
+// src/node/common.js
+import crypto from "crypto";
+function uuid() {
+  return crypto.randomUUID();
+}
+
+// src/node/dirname.js
+import path from "path";
+import { fileURLToPath } from "url";
+function __dirname(url) {
+  if (!url) throw Error("Please provide 'import.meta.url' to dirname");
+  return path.dirname(fileURLToPath(url));
+}
+function dirname(url) {
+  return __dirname(url);
+}
+
+// src/node/file-cache.js
+import fs from "fs/promises";
+import glob from "glob-promise";
+import path2 from "path";
+
+// 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 = path2.join(process.cwd(), dir);
+  await fs.mkdir(absDirpath, { recursive: true });
+  return {
+    async cacheAt(file) {
+      if (file) {
+        const absFilepath = path2.join(absDirpath, file);
+        try {
+          const stat = await fs.stat(absFilepath);
+          return stat.mtimeMs;
+        } catch (error) {
+          return 0;
+        }
+      } else {
+        return getLastModifiedTime(dir + "/**/*");
+      }
+    },
+    getAbsPath(file) {
+      return path2.join(absDirpath, file);
+    },
+    async hasFile(file) {
+      const absFilepath = path2.join(absDirpath, file);
+      try {
+        await fs.stat(absFilepath);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    },
+    async loadFile(file) {
+      try {
+        const absFilepath = path2.join(absDirpath, file);
+        return fs.readFile(absFilepath);
+      } catch (error) {
+        console.warn(`File not found: ${file}`);
+      }
+    },
+    async saveFile(file, data) {
+      const absfilepath = path2.join(absDirpath, file);
+      await fs.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 fs.mkdir(path2.join(process.cwd(), dir), { recursive: true });
+  const cachePath = path2.join(process.cwd(), dir, `${file}`);
+  let modifiedAt = 0;
+  try {
+    const stat = await fs.stat(cachePath);
+    modifiedAt = stat.mtimeMs;
+  } catch (error) {
+  }
+  return {
+    modifiedAt,
+    async load() {
+      return fs.readFile(cachePath);
+    },
+    async save(data) {
+      await fs.writeFile(cachePath, data);
+    },
+    async loadJSON() {
+      const data = await fs.readFile(cachePath);
+      return JSON.parse(data.toString());
+    },
+    async saveJSON(data) {
+      await fs.writeFile(cachePath, JSON.stringify(data));
+    }
+  };
+}
+async function getLastModifiedTime(globPath) {
+  let files;
+  if (typeof globPath === "string") {
+    files = await glob(removeFirstSlash(globPath));
+  }
+  if (Array.isArray(globPath)) {
+    const a = await Promise.all(
+      globPath.map((path3) => glob(removeFirstSlash(path3)))
+    );
+    files = a.flat();
+  }
+  const stats = await Promise.all(files.map((file) => fs.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
+import crypto2 from "crypto";
+function sha256Hash(string) {
+  return crypto2.createHash("sha256").update(string).digest("hex");
+}
+
+// src/node/pkce.js
+import crypto4 from "crypto";
+
+// src/node/random-string.js
+import crypto3 from "crypto";
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return crypto3.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 = crypto4.createHash("sha256").update(verifier).digest();
+  return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// src/node/sanitize.js
+import sanitizeHtml from "sanitize-html";
+
+// 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: sanitizeHtml, ...options });
+}
+export {
+  PKCE,
+  __dirname,
+  createCache,
+  dirname,
+  fileCache,
+  getLastModifiedTime,
+  getLatestModifiedTime,
+  randomString,
+  removeFirstSlash,
+  sanitize2 as sanitize,
+  sha256Hash,
+  uuid
+};

package/dist/esm/node/pkce.js

@@ -0,0 +1,28 @@
+// src/node/pkce.js
+import crypto2 from "crypto";
+
+// src/node/random-string.js
+import crypto from "crypto";
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return crypto.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 = crypto2.createHash("sha256").update(verifier).digest();
+  return hash.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export {
+  PKCE
+};

package/dist/esm/node/random-string.js

@@ -0,0 +1,9 @@
+// src/node/random-string.js
+import crypto from "crypto";
+function randomString(length = 32) {
+  const bytesNeeded = Math.ceil(length * 3 / 4) + 3;
+  return crypto.randomBytes(bytesNeeded).toString("base64").slice(0, length);
+}
+export {
+  randomString
+};

package/dist/esm/node/sanitize.js

@@ -0,0 +1,31 @@
+// src/node/sanitize.js
+import sanitizeHtml from "sanitize-html";
+
+// 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: sanitizeHtml, ...options });
+}
+export {
+  sanitize2 as sanitize
+};

package/dist/{dom/accessibility.d.ts → types/dom/accessibility.d.cts}

@@ -4,7 +4,7 @@
  * @param {string} [labelledBy] - The aria-labelledby value
  * @returns {boolean} True if the element has an accessible name
  */
-export function hasAccessibleName(label?: string, labelledBy?: string): boolean;
+declare function hasAccessibleName(label?: string, labelledBy?: string): boolean;
 /**
  * Checks if an element has an accessible name and logs a warning/error if it doesn't
  * @param {Object} [options] - Options for checking accessible name
@@ -14,7 +14,7 @@ export function hasAccessibleName(label?: string, labelledBy?: string): boolean;
  * @param {'warn'|'error'} [options.severity='warn'] - Severity level for the message
  * @returns {boolean} True if the element has an accessible name
  */
-export function checkForAccessibleName({ name, ariaLabel, ariaLabelledBy, severity, }?: {
+declare function checkForAccessibleName({ name, ariaLabel, ariaLabelledBy, severity, }?: {
     name?: string;
     ariaLabel?: string;
     ariaLabelledBy?: string;
@@ -25,4 +25,6 @@ export function checkForAccessibleName({ name, ariaLabel, ariaLabelledBy, severi
  * @param {string} value - The ARIA popup value to check
  * @returns {boolean} True if the value is invalid
  */
-export function isInvalidAriaPopup(value: string): boolean;
+declare function isInvalidAriaPopup(value: string): boolean;
+
+export { checkForAccessibleName, hasAccessibleName, isInvalidAriaPopup };

package/dist/types/dom/actions/index.d.cts

@@ -0,0 +1,3 @@
+export { masonry } from './masonry.cjs';
+export { preferHorizontalScroll } from './prefer-horizontal-scroll.cjs';
+export { sticky } from './sticky.cjs';

package/dist/types/dom/actions/masonry.d.cts

@@ -0,0 +1,5 @@
+declare function masonry(node: any): Promise<{
+    destroy(): void;
+}>;
+
+export { masonry };

package/dist/types/dom/actions/prefer-horizontal-scroll.d.cts

@@ -0,0 +1,5 @@
+declare function preferHorizontalScroll(node: any, props?: {}): {
+    destroy(): void;
+};
+
+export { preferHorizontalScroll };

package/dist/types/dom/actions/sticky.d.cts

@@ -0,0 +1,5 @@
+declare function sticky(node: any, props?: {}): {
+    destroy(): void;
+};
+
+export { sticky };

package/dist/{dom/bounding-box.d.ts → types/dom/bounding-box.d.cts}

@@ -15,7 +15,7 @@
  * @property {number} xCenter - The horizontal center coordinate
  * @property {number} yCenter - The vertical center coordinate
  */
-export function boundingBox(element: HTMLElement, { containsPadding }?: {
+declare function boundingBox(element: HTMLElement, { containsPadding }?: {
     containsPadding?: boolean;
 }): any;
 /**
@@ -33,7 +33,9 @@ export function boundingBox(element: HTMLElement, { containsPadding }?: {
  * @property {number} xCenter - The horizontal center coordinate relative to ancestor
  * @property {number} yCenter - The vertical center coordinate relative to ancestor
  */
-export function boundingBoxRelativeToAncestor({ element, ancestorElement }: {
+declare function boundingBoxRelativeToAncestor({ element, ancestorElement }: {
     element: HTMLElement;
     ancestorElement?: HTMLElement;
 }): any;
+
+export { boundingBox, boundingBoxRelativeToAncestor };

package/dist/{dom/clipboard.d.ts → types/dom/clipboard.d.cts}

@@ -2,4 +2,6 @@
  * Copies rich text from an element to the clipboard
  * @param HTMLElement element - Element to copy
  */
-export function copyRichText(element: any): void;
+declare function copyRichText(element: any): void;
+
+export { copyRichText };

package/dist/types/dom/cookie.d.cts

@@ -0,0 +1,7 @@
+declare function getCookie(name: any): any;
+declare namespace cookies {
+    function get(name: any): any;
+    function set(name: any, value: any, days: any): void;
+}
+
+export { cookies, getCookie };

package/dist/types/dom/css-vars.d.cts

@@ -0,0 +1,6 @@
+declare function getCSSValue(element: any, prop: any): string;
+declare function setCSSValue(element: any, prop: any, value: any): void;
+declare function getCSSVar(element: any, prop: any): string;
+declare function setCSSVar(element: any, prop: any, value: any): void;
+
+export { getCSSValue, getCSSVar, setCSSValue, setCSSVar };

package/dist/types/dom/events.d.cts

@@ -0,0 +1,20 @@
+declare function addListeners(listeners: any): void;
+declare function removeListeners(listeners: any): void;
+declare function dispatchEvent(node: any, eventName: any, detail: any, options?: {}): void;
+declare function updateEvent(event: any, updates: any): CustomEvent<any>;
+declare function createListeners(listeners: any): {
+    readonly list: any;
+    add({ node, event, handler }: {
+        node: any;
+        event: any;
+        handler: any;
+    }): void;
+    remove({ node, event, handler }: {
+        node: any;
+        event: any;
+        handler: any;
+    }): void;
+    clear(): void;
+};
+
+export { addListeners, createListeners, dispatchEvent, removeListeners, updateEvent };

package/dist/{dom/focusable.d.ts → types/dom/focusable.d.cts}

@@ -38,9 +38,9 @@
  *   }
  * })
  */
-export function getFocusableElements(container?: HTMLElement): Focusables;
-export function Focusable(container?: HTMLElement): Focusables;
-export type Focusables = {
+declare function getFocusableElements(container?: HTMLElement): Focusables;
+declare function Focusable(container?: HTMLElement): Focusables;
+type Focusables = {
     /**
      * - Number of keyboard focusable elements
      */
@@ -74,3 +74,5 @@ export type Focusables = {
      */
     prev: (arg0: number) => HTMLElement | null;
 };
+
+export { Focusable, type Focusables, getFocusableElements };

package/dist/types/dom/font-size.d.cts

@@ -0,0 +1,7 @@
+declare function getUnit(value: any): any;
+declare function em(element?: HTMLElement, multiple?: number): number;
+declare function rem(multiple?: number): number;
+declare function lh(element?: HTMLElement, multiple?: number): number;
+declare function toPx(value: any, element?: any): number;
+
+export { em, getUnit, lh, rem, toPx };