cynx-lib 1.3.41 → 1.3.43

package/utils/utils/uid.cjs

@@ -0,0 +1,187 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var uid_exports = {};
+__export(uid_exports, {
+  ALPHABETS: () => ALPHABETS,
+  createSequence: () => createSequence,
+  customAlphabet: () => customAlphabet,
+  default: () => uid_default,
+  genUid: () => genUid,
+  getRandomBytes: () => getRandomBytes,
+  isValidUID: () => isValidUID,
+  isValidUUID: () => isValidUUID,
+  nanoid: () => nanoid,
+  prefixedId: () => prefixedId,
+  seqId: () => seqId,
+  shortId: () => shortId,
+  timestampId: () => timestampId,
+  uid: () => uid,
+  uuid: () => uuid,
+  uuidv4: () => uuidv4
+});
+module.exports = __toCommonJS(uid_exports);
+const ALPHABETS = {
+  urlSafe: "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLFGQZ_rich5hexURL",
+  alphanumeric: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  lowercase: "0123456789abcdefghijklmnopqrstuvwxyz",
+  uppercase: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  numeric: "0123456789",
+  hex: "0123456789abcdef",
+  // Human-friendly alphabet without lookalikes (no 0, O, I, l, 1)
+  noLookalikes: "346789ABCDEFGHJKLMNPQRTUVWXYabcdefghijkmnpqrtwxyz"
+};
+function getCrypto() {
+  if (typeof globalThis !== "undefined" && globalThis.crypto) {
+    return globalThis.crypto;
+  }
+  if (typeof window !== "undefined" && window.crypto) {
+    return window.crypto;
+  }
+  if (typeof self !== "undefined" && self.crypto) {
+    return self.crypto;
+  }
+  return null;
+}
+function getRandomBytes(size = 16) {
+  const bytes = new Uint8Array(size);
+  const cryptoObj = getCrypto();
+  if (cryptoObj && typeof cryptoObj.getRandomValues === "function") {
+    cryptoObj.getRandomValues(bytes);
+    return bytes;
+  }
+  for (let i = 0; i < size; i++) {
+    const timeJitter = (Date.now() + (typeof performance !== "undefined" ? performance.now() : 0)) * 1e3 % 256;
+    bytes[i] = (Math.floor(Math.random() * 256) ^ Math.floor(timeJitter)) & 255;
+  }
+  return bytes;
+}
+function uuid() {
+  const cryptoObj = getCrypto();
+  if (cryptoObj && typeof cryptoObj.randomUUID === "function") {
+    return cryptoObj.randomUUID();
+  }
+  const bytes = getRandomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  let out = "";
+  for (let i = 0; i < 16; i++) {
+    if (i === 4 || i === 6 || i === 8 || i === 10) out += "-";
+    out += bytes[i].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+const uuidv4 = uuid;
+function customAlphabet(alphabet = ALPHABETS.urlSafe, defaultSize = 21) {
+  const mask = (2 << 31 - Math.clz32(alphabet.length - 1 | 1)) - 1;
+  const step = Math.ceil(1.6 * mask * defaultSize / alphabet.length);
+  return function generate(size = defaultSize) {
+    let id = "";
+    while (true) {
+      const bytes = getRandomBytes(step);
+      for (let i = 0; i < step; i++) {
+        const byte = bytes[i] & mask;
+        if (alphabet[byte]) {
+          id += alphabet[byte];
+          if (id.length === size) return id;
+        }
+      }
+    }
+  };
+}
+function uid(size = 12, alphabet = ALPHABETS.urlSafe) {
+  if (alphabet === ALPHABETS.urlSafe) {
+    const bytes = getRandomBytes(size);
+    let id = "";
+    const len = alphabet.length;
+    for (let i = 0; i < size; i++) {
+      id += alphabet[bytes[i] % len];
+    }
+    return id;
+  }
+  return customAlphabet(alphabet, size)(size);
+}
+const nanoid = (size = 21) => uid(size, ALPHABETS.urlSafe);
+const genUid = (size = 12) => uid(size, ALPHABETS.urlSafe);
+function shortId(size = 8) {
+  return uid(size, ALPHABETS.alphanumeric);
+}
+function prefixedId(prefix = "id", size = 12, alphabet = ALPHABETS.alphanumeric) {
+  return `${prefix}_${uid(size, alphabet)}`;
+}
+function createSequence(prefix = "cynx") {
+  let counter = 0;
+  return function next(customPrefix = prefix) {
+    counter += 1;
+    return `${customPrefix}_${counter}`;
+  };
+}
+const seqId = createSequence("cynx");
+function timestampId(prefix = "") {
+  const ts = Date.now().toString(36);
+  const rand = uid(8, ALPHABETS.lowercase);
+  return prefix ? `${prefix}_${ts}_${rand}` : `${ts}_${rand}`;
+}
+function isValidUUID(str) {
+  if (typeof str !== "string") return false;
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(str);
+}
+function isValidUID(str, { minLength = 1, maxLength = 128, alphabet } = {}) {
+  if (typeof str !== "string") return false;
+  if (str.length < minLength || str.length > maxLength) return false;
+  if (alphabet) {
+    const chars = new Set(alphabet);
+    for (const char of str) {
+      if (!chars.has(char)) return false;
+    }
+  }
+  return true;
+}
+var uid_default = {
+  uuid,
+  uuidv4,
+  uid,
+  nanoid,
+  shortId,
+  prefixedId,
+  timestampId,
+  createSequence,
+  seqId,
+  customAlphabet,
+  getRandomBytes,
+  isValidUUID,
+  isValidUID,
+  ALPHABETS
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALPHABETS,
+  createSequence,
+  customAlphabet,
+  genUid,
+  getRandomBytes,
+  isValidUID,
+  isValidUUID,
+  nanoid,
+  prefixedId,
+  seqId,
+  shortId,
+  timestampId,
+  uid,
+  uuid,
+  uuidv4
+});