@utilix-tech/sdk 0.1.0

package/dist/tools/generators.cjs

@@ -0,0 +1,521 @@
+'use strict';
+
+var crypto = require('crypto');
+var QRCode = require('qrcode');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var QRCode__default = /*#__PURE__*/_interopDefault(QRCode);
+
+// src/tools/generators.ts
+function getRandomUint8Array(count) {
+  const buf = new Uint8Array(count);
+  crypto.randomFillSync(buf);
+  return buf;
+}
+function getRandomUint32() {
+  const buf = new Uint32Array(1);
+  crypto.randomFillSync(buf);
+  return buf[0];
+}
+function generateV4() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  const bytes = crypto.randomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytes.toString("hex");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+function generateV7() {
+  const ms = Date.now();
+  const hi = Math.floor(ms / 4294967296) & 65535;
+  const lo = ms >>> 0;
+  const rand2 = getRandomUint8Array(10);
+  rand2[0] = rand2[0] & 15 | 112;
+  rand2[2] = rand2[2] & 63 | 128;
+  const hex = (n, len) => n.toString(16).padStart(len, "0");
+  return [
+    hex(hi, 4) + hex(lo >>> 16 & 65535, 4),
+    hex(lo & 65535, 4),
+    hex(rand2[0], 2) + hex(rand2[1], 2),
+    hex(rand2[2], 2) + hex(rand2[3], 2),
+    Array.from(rand2.slice(4)).map((b) => hex(b, 2)).join("")
+  ].join("-");
+}
+function generateUuid(version) {
+  const value = version === "v4" ? generateV4() : generateV7();
+  const timestamp = version === "v7" ? Date.now() : 0;
+  return { value, version, timestamp };
+}
+function generateBulk(version, count) {
+  return Array.from({ length: count }, () => generateUuid(version));
+}
+function isValidUuid(uuid) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(uuid.trim());
+}
+function parseUuidVersion(uuid) {
+  if (!isValidUuid(uuid)) return null;
+  const vChar = uuid.replace(/-/g, "")[12];
+  return vChar ? `v${vChar}` : null;
+}
+var ULID_REGEX = /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/;
+var CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var DECODE_MAP = {};
+for (let i = 0; i < CROCKFORD.length; i++) {
+  DECODE_MAP[CROCKFORD[i]] = i;
+}
+function getRandomBytesForUlid(count) {
+  const buf = crypto.randomBytes(count);
+  return Array.from(buf);
+}
+function generateUlid() {
+  let ms = Date.now();
+  const tsChars = new Array(10);
+  for (let i = 9; i >= 0; i--) {
+    tsChars[i] = CROCKFORD[ms % 32];
+    ms = Math.floor(ms / 32);
+  }
+  const bytes = getRandomBytesForUlid(10);
+  const randChars = new Array(16);
+  for (let i = 0; i < 16; i++) {
+    const bitPos = i * 5;
+    const byteIdx = Math.floor(bitPos / 8);
+    const bitOffset = bitPos % 8;
+    let val;
+    if (bitOffset <= 3) {
+      val = bytes[byteIdx] >> 3 - bitOffset & 31;
+    } else {
+      const bitsFromFirst = 8 - bitOffset;
+      const bitsFromSecond = 5 - bitsFromFirst;
+      const firstPart = (bytes[byteIdx] & (1 << bitsFromFirst) - 1) << bitsFromSecond;
+      const secondPart = byteIdx + 1 < bytes.length ? bytes[byteIdx + 1] >> 8 - bitsFromSecond : 0;
+      val = firstPart | secondPart;
+    }
+    randChars[i] = CROCKFORD[val];
+  }
+  return tsChars.join("") + randChars.join("");
+}
+function generateBulkUlids(count) {
+  return Array.from({ length: count }, () => generateUlid());
+}
+function parseUlid(ulid) {
+  if (!isValidUlid(ulid)) {
+    return { valid: false, error: "Invalid ULID format" };
+  }
+  const tsStr = ulid.slice(0, 10);
+  let ms = 0;
+  for (let i = 0; i < 10; i++) {
+    ms = ms * 32 + DECODE_MAP[tsStr[i]];
+  }
+  return {
+    valid: true,
+    timestamp: ms,
+    date: new Date(ms).toISOString()
+  };
+}
+function isValidUlid(ulid) {
+  return ULID_REGEX.test(ulid);
+}
+var SYMBOL_CHARS = "!@#$%^&*()_+-=[]{}|;:,.<>?";
+var AMBIGUOUS_CHARS = "Il1O0";
+var DEFAULT_OPTIONS = {
+  length: 16,
+  uppercase: true,
+  lowercase: true,
+  numbers: true,
+  symbols: true,
+  excludeAmbiguous: false
+};
+function getRandomIndex(max) {
+  return getRandomUint32() % max;
+}
+function pickRandom(charset) {
+  return charset[getRandomIndex(charset.length)];
+}
+function generatePassword(options) {
+  const UPPERCASE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const LOWERCASE = "abcdefghijklmnopqrstuvwxyz";
+  const NUMBERS = "0123456789";
+  const charsets = [
+    { chars: UPPERCASE, enabled: options.uppercase },
+    { chars: LOWERCASE, enabled: options.lowercase },
+    { chars: NUMBERS, enabled: options.numbers },
+    { chars: SYMBOL_CHARS, enabled: options.symbols }
+  ];
+  const enabledCharsets = charsets.filter((cs) => cs.enabled);
+  if (enabledCharsets.length === 0) {
+    throw new Error("At least one character set must be selected");
+  }
+  let fullCharset = enabledCharsets.map((cs) => cs.chars).join("");
+  if (options.excludeAmbiguous) {
+    fullCharset = fullCharset.split("").filter((c) => !AMBIGUOUS_CHARS.includes(c)).join("");
+  }
+  while (true) {
+    const passwordChars = [];
+    for (let i = 0; i < options.length; i++) {
+      passwordChars.push(pickRandom(fullCharset));
+    }
+    const password = passwordChars.join("");
+    const hasAll = enabledCharsets.every((cs) => {
+      let chars = cs.chars;
+      if (options.excludeAmbiguous) {
+        chars = chars.split("").filter((c) => !AMBIGUOUS_CHARS.includes(c)).join("");
+      }
+      return chars.length === 0 || password.split("").some((c) => chars.includes(c));
+    });
+    if (hasAll) {
+      return password;
+    }
+  }
+}
+function generateBulkPasswords(options, count) {
+  const passwords = [];
+  for (let i = 0; i < count; i++) {
+    passwords.push(generatePassword(options));
+  }
+  return passwords;
+}
+function checkStrength(password) {
+  let score = 0;
+  if (password.length >= 8) score += 1;
+  if (password.length >= 12) score += 1;
+  if (password.length >= 16) score += 1;
+  if (/[A-Z]/.test(password)) score += 0.5;
+  if (/[a-z]/.test(password)) score += 0.5;
+  if (/[0-9]/.test(password)) score += 0.5;
+  if (new RegExp("[" + SYMBOL_CHARS.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") + "]").test(password))
+    score += 1;
+  score = Math.min(Math.floor(score), 4);
+  const levels = [
+    { label: "Very Weak", color: "#ef4444" },
+    { label: "Weak", color: "#f97316" },
+    { label: "Fair", color: "#eab308" },
+    { label: "Strong", color: "#22c55e" },
+    { label: "Very Strong", color: "#16a34a" }
+  ];
+  return {
+    score,
+    label: levels[score].label,
+    color: levels[score].color
+  };
+}
+var DATA_TYPES = [
+  { value: "name", label: "Full Name", example: "John Smith" },
+  { value: "email", label: "Email Address", example: "john.smith@gmail.com" },
+  { value: "uuid", label: "UUID", example: "550e8400-e29b-41d4-a716-446655440000" },
+  { value: "phone", label: "Phone Number", example: "(555) 123-4567" },
+  { value: "date", label: "Date", example: "2024-03-15" },
+  { value: "number", label: "Number", example: "742" },
+  { value: "boolean", label: "Boolean", example: "true" },
+  { value: "color", label: "Hex Color", example: "#a3f2c1" },
+  { value: "url", label: "URL", example: "https://www.example.com/page" },
+  { value: "ipv4", label: "IPv4 Address", example: "192.168.1.1" },
+  { value: "sentence", label: "Sentence", example: "The quick brown fox jumps over the lazy dog" },
+  { value: "paragraph", label: "Paragraph", example: "Multiple sentences forming a paragraph." }
+];
+var FIRST_NAMES = [
+  "James",
+  "Mary",
+  "John",
+  "Patricia",
+  "Robert",
+  "Jennifer",
+  "Michael",
+  "Linda",
+  "William",
+  "Barbara",
+  "David",
+  "Elizabeth",
+  "Richard",
+  "Susan",
+  "Joseph",
+  "Jessica",
+  "Thomas",
+  "Sarah",
+  "Charles",
+  "Karen",
+  "Christopher",
+  "Lisa",
+  "Daniel",
+  "Nancy",
+  "Matthew",
+  "Betty",
+  "Anthony",
+  "Margaret",
+  "Mark",
+  "Sandra"
+];
+var LAST_NAMES = [
+  "Smith",
+  "Johnson",
+  "Williams",
+  "Brown",
+  "Jones",
+  "Garcia",
+  "Miller",
+  "Davis",
+  "Rodriguez",
+  "Martinez",
+  "Hernandez",
+  "Lopez",
+  "Gonzalez",
+  "Wilson",
+  "Anderson",
+  "Thomas",
+  "Taylor",
+  "Moore",
+  "Jackson",
+  "Martin",
+  "Lee",
+  "Perez",
+  "Thompson",
+  "White",
+  "Harris",
+  "Sanchez",
+  "Clark",
+  "Ramirez",
+  "Lewis",
+  "Robinson"
+];
+var EMAIL_DOMAINS = ["gmail.com", "yahoo.com", "outlook.com", "hotmail.com", "icloud.com"];
+var URL_DOMAINS = ["example", "mysite", "testdomain", "webservice", "apphost", "platform"];
+var URL_TLDS = ["com", "net", "org", "io", "dev"];
+var URL_PATHS = [
+  "home",
+  "about",
+  "contact",
+  "products",
+  "services",
+  "blog",
+  "news",
+  "help",
+  "docs",
+  "api"
+];
+var WORDS = [
+  "the",
+  "quick",
+  "brown",
+  "fox",
+  "jumps",
+  "over",
+  "lazy",
+  "dog",
+  "bright",
+  "sun",
+  "shines",
+  "every",
+  "day",
+  "blue",
+  "sky",
+  "above",
+  "green",
+  "trees",
+  "grow",
+  "tall",
+  "small",
+  "birds",
+  "sing",
+  "sweet",
+  "songs",
+  "fresh",
+  "wind",
+  "blows",
+  "cold",
+  "rain",
+  "falls",
+  "soft",
+  "light",
+  "glows",
+  "deep",
+  "ocean",
+  "waves",
+  "crash",
+  "rocky",
+  "shore",
+  "people",
+  "walk",
+  "through",
+  "quiet",
+  "streets",
+  "busy",
+  "city",
+  "moves",
+  "fast",
+  "time"
+];
+function rand(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function pick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+function hexByte() {
+  return Math.floor(Math.random() * 256).toString(16).padStart(2, "0");
+}
+function generateName() {
+  return `${pick(FIRST_NAMES)} ${pick(LAST_NAMES)}`;
+}
+function generateEmail() {
+  const first = pick(FIRST_NAMES).toLowerCase();
+  const last = pick(LAST_NAMES).toLowerCase();
+  const domain = pick(EMAIL_DOMAINS);
+  const sep = pick([".", "_", ""]);
+  return `${first}${sep}${last}@${domain}`;
+}
+function generateUUID() {
+  const s4 = () => Math.floor(Math.random() * 65536).toString(16).padStart(4, "0");
+  const s8 = () => Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0");
+  const y = (Math.floor(Math.random() * 4) + 8).toString(16);
+  return `${s8()}-${s4()}-4${s4().slice(1)}-${y}${s4().slice(1)}-${s4()}${s8().slice(0, 8)}`;
+}
+function generatePhone() {
+  const area = rand(200, 999);
+  const prefix = rand(200, 999);
+  const line = rand(1e3, 9999);
+  return `(${area}) ${prefix}-${line}`;
+}
+function generateDate(format = "iso") {
+  const year = rand(1970, 2030);
+  const month = rand(1, 12);
+  const day = rand(1, 28);
+  const mm = String(month).padStart(2, "0");
+  const dd = String(day).padStart(2, "0");
+  if (format === "us") return `${mm}/${dd}/${year}`;
+  if (format === "eu") return `${dd}/${mm}/${year}`;
+  return `${year}-${mm}-${dd}`;
+}
+function generateNumber(min = 0, max = 1e3) {
+  return String(rand(min, max));
+}
+function generateBoolean() {
+  return Math.random() < 0.5 ? "true" : "false";
+}
+function generateColor() {
+  return `#${hexByte()}${hexByte()}${hexByte()}`;
+}
+function generateURL() {
+  const domain = pick(URL_DOMAINS);
+  const tld = pick(URL_TLDS);
+  const path = pick(URL_PATHS);
+  return `https://www.${domain}.${tld}/${path}`;
+}
+function generateIPv4() {
+  return `${rand(0, 255)}.${rand(0, 255)}.${rand(0, 255)}.${rand(0, 255)}`;
+}
+function generateSentenceText() {
+  const length = rand(6, 12);
+  const words = [];
+  for (let i = 0; i < length; i++) {
+    words.push(pick(WORDS));
+  }
+  const sentence = words.join(" ");
+  return sentence.charAt(0).toUpperCase() + sentence.slice(1) + ".";
+}
+function generateParagraph() {
+  const count = rand(3, 5);
+  const sentences = [];
+  for (let i = 0; i < count; i++) {
+    sentences.push(generateSentenceText());
+  }
+  return sentences.join(" ");
+}
+function generateSingle(type, options) {
+  switch (type) {
+    case "name":
+      return generateName();
+    case "email":
+      return generateEmail();
+    case "uuid":
+      return generateUUID();
+    case "phone":
+      return generatePhone();
+    case "date":
+      return generateDate(options?.dateFormat ?? "iso");
+    case "number":
+      return generateNumber(options?.min ?? 0, options?.max ?? 1e3);
+    case "boolean":
+      return generateBoolean();
+    case "color":
+      return generateColor();
+    case "url":
+      return generateURL();
+    case "ipv4":
+      return generateIPv4();
+    case "sentence":
+      return generateSentenceText();
+    case "paragraph":
+      return generateParagraph();
+  }
+}
+function generateData(config) {
+  const count = Math.min(Math.max(config.count, 1), 100);
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    results.push(generateSingle(config.type, config.options));
+  }
+  return results;
+}
+var DEFAULT_QR_OPTIONS = {
+  errorLevel: "M",
+  size: 256,
+  margin: 1,
+  darkColor: "#000000",
+  lightColor: "#ffffff"
+};
+async function generateQrSvg(text, options) {
+  const merged = { ...DEFAULT_QR_OPTIONS, ...options };
+  return QRCode__default.default.toString(text, {
+    type: "svg",
+    errorCorrectionLevel: merged.errorLevel,
+    margin: merged.margin,
+    color: {
+      dark: merged.darkColor,
+      light: merged.lightColor
+    }
+  });
+}
+async function generateQrDataUrl(text, options) {
+  const merged = { ...DEFAULT_QR_OPTIONS, ...options };
+  return QRCode__default.default.toDataURL(text, {
+    width: merged.size,
+    errorCorrectionLevel: merged.errorLevel,
+    margin: merged.margin,
+    color: {
+      dark: merged.darkColor,
+      light: merged.lightColor
+    }
+  });
+}
+
+exports.AMBIGUOUS_CHARS = AMBIGUOUS_CHARS;
+exports.DATA_TYPES = DATA_TYPES;
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.DEFAULT_QR_OPTIONS = DEFAULT_QR_OPTIONS;
+exports.SYMBOL_CHARS = SYMBOL_CHARS;
+exports.ULID_REGEX = ULID_REGEX;
+exports.checkStrength = checkStrength;
+exports.generateBulk = generateBulk;
+exports.generateBulkPasswords = generateBulkPasswords;
+exports.generateBulkUlids = generateBulkUlids;
+exports.generateData = generateData;
+exports.generatePassword = generatePassword;
+exports.generateQrDataUrl = generateQrDataUrl;
+exports.generateQrSvg = generateQrSvg;
+exports.generateSingle = generateSingle;
+exports.generateUlid = generateUlid;
+exports.generateUuid = generateUuid;
+exports.generateV4 = generateV4;
+exports.generateV7 = generateV7;
+exports.isValidUlid = isValidUlid;
+exports.isValidUuid = isValidUuid;
+exports.parseUlid = parseUlid;
+exports.parseUuidVersion = parseUuidVersion;

package/dist/tools/generators.d.cts

@@ -0,0 +1 @@
+export { A as AMBIGUOUS_CHARS, D as DATA_TYPES, a as DEFAULT_OPTIONS, b as DEFAULT_QR_OPTIONS, c as DataType, G as GeneratedUuid, P as PasswordOptions, Q as QrErrorLevel, d as QrOptions, e as QrOutputFormat, R as RandomConfig, S as SYMBOL_CHARS, U as ULID_REGEX, f as UuidVersion, h as checkStrength, i as generateBulk, j as generateBulkPasswords, k as generateBulkUlids, l as generateData, m as generatePassword, n as generateQrDataUrl, o as generateQrSvg, p as generateSingle, q as generateUlid, r as generateUuid, s as generateV4, t as generateV7, u as isValidUlid, v as isValidUuid, w as parseUlid, x as parseUuidVersion } from '../generators-BGtRGpJZ.cjs';

package/dist/tools/generators.d.ts

@@ -0,0 +1 @@
+export { A as AMBIGUOUS_CHARS, D as DATA_TYPES, a as DEFAULT_OPTIONS, b as DEFAULT_QR_OPTIONS, c as DataType, G as GeneratedUuid, P as PasswordOptions, Q as QrErrorLevel, d as QrOptions, e as QrOutputFormat, R as RandomConfig, S as SYMBOL_CHARS, U as ULID_REGEX, f as UuidVersion, h as checkStrength, i as generateBulk, j as generateBulkPasswords, k as generateBulkUlids, l as generateData, m as generatePassword, n as generateQrDataUrl, o as generateQrSvg, p as generateSingle, q as generateUlid, r as generateUuid, s as generateV4, t as generateV7, u as isValidUlid, v as isValidUuid, w as parseUlid, x as parseUuidVersion } from '../generators-BGtRGpJZ.js';

package/dist/tools/generators.js

@@ -0,0 +1,2 @@
+export { AMBIGUOUS_CHARS, DATA_TYPES, DEFAULT_OPTIONS, DEFAULT_QR_OPTIONS, SYMBOL_CHARS, ULID_REGEX, checkStrength, generateBulk, generateBulkPasswords, generateBulkUlids, generateData, generatePassword, generateQrDataUrl, generateQrSvg, generateSingle, generateUlid, generateUuid, generateV4, generateV7, isValidUlid, isValidUuid, parseUlid, parseUuidVersion } from '../chunk-2CJSLYWI.js';
+import '../chunk-MLKGABMK.js';