@mohasinac/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,527 @@
+"use strict";
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CacheManager: () => CacheManager,
+  EventBus: () => EventBus,
+  Logger: () => Logger,
+  Queue: () => Queue,
+  StorageManager: () => StorageManager,
+  cacheManager: () => cacheManager,
+  eventBus: () => eventBus,
+  logger: () => logger,
+  storageManager: () => storageManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Logger.ts
+var Logger = class _Logger {
+  constructor(options) {
+    this.logs = [];
+    this.levelPriority = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3
+    };
+    var _a, _b, _c, _d, _e;
+    const fileUrl = (_a = options == null ? void 0 : options.logFileUrl) != null ? _a : (options == null ? void 0 : options.enableFileLogging) ? "/api/logs/write" : void 0;
+    this.options = {
+      minLevel: (_b = options == null ? void 0 : options.minLevel) != null ? _b : "debug",
+      enableConsole: (_c = options == null ? void 0 : options.enableConsole) != null ? _c : true,
+      enableStorage: (_d = options == null ? void 0 : options.enableStorage) != null ? _d : false,
+      logFileUrl: fileUrl,
+      maxEntries: (_e = options == null ? void 0 : options.maxEntries) != null ? _e : 1e3,
+      sanitizer: options == null ? void 0 : options.sanitizer
+    };
+  }
+  /** Get singleton instance */
+  static getInstance(options) {
+    if (!_Logger.instance) {
+      _Logger.instance = new _Logger(options);
+    }
+    return _Logger.instance;
+  }
+  /** Set or update the data sanitizer (e.g., for PII redaction). */
+  static setSanitizer(fn) {
+    _Logger.getInstance().options.sanitizer = fn;
+  }
+  shouldLog(level) {
+    return this.levelPriority[level] >= this.levelPriority[this.options.minLevel];
+  }
+  addLog(level, message, data) {
+    if (!this.shouldLog(level)) return;
+    const sanitized = data && this.options.sanitizer ? this.options.sanitizer(data) : data;
+    const entry = {
+      level,
+      message,
+      timestamp: /* @__PURE__ */ new Date(),
+      data: sanitized
+    };
+    this.logs.push(entry);
+    if (this.logs.length > this.options.maxEntries) {
+      this.logs.shift();
+    }
+    if (this.options.enableConsole) {
+      this.logToConsole(entry);
+    }
+    if (this.options.enableStorage && typeof window !== "undefined") {
+      this.saveToStorage();
+    }
+    if (this.options.logFileUrl && level === "error") {
+      this.writeToFile(entry).catch(() => {
+      });
+    }
+  }
+  logToConsole(entry) {
+    const prefix = `[${entry.level.toUpperCase()}] ${entry.timestamp.toISOString()}`;
+    const message = `${prefix} ${entry.message}`;
+    switch (entry.level) {
+      case "debug":
+        console.debug(message, entry.data);
+        break;
+      case "info":
+        console.info(message, entry.data);
+        break;
+      case "warn":
+        console.warn(message, entry.data);
+        break;
+      case "error":
+        console.error(message, entry.data);
+        break;
+    }
+  }
+  saveToStorage() {
+    try {
+      localStorage.setItem("app_logs", JSON.stringify(this.logs));
+    } catch (e) {
+    }
+  }
+  async writeToFile(entry) {
+    if (typeof window === "undefined" || !this.options.logFileUrl) return;
+    try {
+      await fetch(this.options.logFileUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          level: entry.level,
+          message: entry.message,
+          timestamp: entry.timestamp.toISOString(),
+          data: entry.data
+        })
+      });
+    } catch (e) {
+    }
+  }
+  debug(message, data) {
+    this.addLog("debug", message, data);
+  }
+  info(message, data) {
+    this.addLog("info", message, data);
+  }
+  warn(message, data) {
+    this.addLog("warn", message, data);
+  }
+  error(message, data) {
+    this.addLog("error", message, data);
+  }
+  getLogs(level) {
+    if (level) return this.logs.filter((log) => log.level === level);
+    return [...this.logs];
+  }
+  clear() {
+    this.logs = [];
+    if (this.options.enableStorage && typeof window !== "undefined") {
+      localStorage.removeItem("app_logs");
+    }
+  }
+  export() {
+    return JSON.stringify(this.logs, null, 2);
+  }
+  getStats() {
+    return {
+      debug: this.logs.filter((l) => l.level === "debug").length,
+      info: this.logs.filter((l) => l.level === "info").length,
+      warn: this.logs.filter((l) => l.level === "warn").length,
+      error: this.logs.filter((l) => l.level === "error").length
+    };
+  }
+};
+var logger = Logger.getInstance();
+
+// src/Queue.ts
+var qLogger = Logger.getInstance();
+var Queue = class {
+  constructor(options) {
+    this.tasks = [];
+    this.running = 0;
+    this.results = /* @__PURE__ */ new Map();
+    this.errors = /* @__PURE__ */ new Map();
+    var _a, _b;
+    this.concurrency = (_a = options == null ? void 0 : options.concurrency) != null ? _a : 1;
+    this.autoStart = (_b = options == null ? void 0 : options.autoStart) != null ? _b : true;
+  }
+  /** Add a task to the queue */
+  add(id, fn, priority = 0) {
+    this.tasks.push({ id, fn, priority });
+    this.tasks.sort((a, b) => {
+      var _a, _b;
+      return ((_a = b.priority) != null ? _a : 0) - ((_b = a.priority) != null ? _b : 0);
+    });
+    if (this.autoStart) {
+      this.process();
+    }
+  }
+  process() {
+    while (this.running < this.concurrency && this.tasks.length > 0) {
+      const task = this.tasks.shift();
+      if (!task) break;
+      this.running++;
+      task.fn().then((result) => {
+        this.results.set(task.id, result);
+      }).catch((error) => {
+        this.errors.set(task.id, error);
+      }).finally(() => {
+        this.running--;
+        this.process();
+      }).catch((err) => {
+        qLogger.error("Queue.process error in finally", { err });
+      });
+    }
+  }
+  start() {
+    this.process();
+  }
+  pause() {
+    this.autoStart = false;
+  }
+  resume() {
+    this.autoStart = true;
+    this.process();
+  }
+  clear() {
+    this.tasks = [];
+    this.results.clear();
+    this.errors.clear();
+  }
+  getResult(id) {
+    return this.results.get(id);
+  }
+  getError(id) {
+    return this.errors.get(id);
+  }
+  size() {
+    return this.tasks.length;
+  }
+  getRunning() {
+    return this.running;
+  }
+  isEmpty() {
+    return this.tasks.length === 0 && this.running === 0;
+  }
+  async waitForCompletion() {
+    while (!this.isEmpty()) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  getStats() {
+    return {
+      pending: this.tasks.length,
+      running: this.running,
+      completed: this.results.size,
+      failed: this.errors.size
+    };
+  }
+};
+
+// src/StorageManager.ts
+var sLogger = Logger.getInstance();
+var _StorageManager = class _StorageManager {
+  constructor(prefix = "app_") {
+    this.prefix = prefix;
+  }
+  /**
+   * Get-or-create a StorageManager for the given prefix.
+   * Each prefix returns an independent instance.
+   */
+  static getInstance(prefix = "") {
+    if (!_StorageManager.instances.has(prefix)) {
+      _StorageManager.instances.set(prefix, new _StorageManager(prefix));
+    }
+    return _StorageManager.instances.get(prefix);
+  }
+  getStorage(type) {
+    try {
+      if (typeof window === "undefined") return null;
+      const storage = type === "local" ? window.localStorage : window.sessionStorage;
+      return storage != null ? storage : null;
+    } catch (e) {
+      return null;
+    }
+  }
+  generateKey(key) {
+    return `${this.prefix}${key}`;
+  }
+  set(key, value, options) {
+    var _a;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return false;
+    try {
+      storage.setItem(this.generateKey(key), JSON.stringify(value));
+      return true;
+    } catch (error) {
+      sLogger.error("StorageManager.set error", { error });
+      return false;
+    }
+  }
+  get(key, options) {
+    var _a;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return null;
+    try {
+      const item = storage.getItem(this.generateKey(key));
+      if (item === null) return null;
+      return JSON.parse(item);
+    } catch (error) {
+      sLogger.error("StorageManager.get error", { error });
+      return null;
+    }
+  }
+  remove(key, options) {
+    var _a;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return false;
+    try {
+      storage.removeItem(this.generateKey(key));
+      return true;
+    } catch (error) {
+      sLogger.error("StorageManager.remove error", { error });
+      return false;
+    }
+  }
+  clear(options) {
+    var _a;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return false;
+    try {
+      const keys = Object.keys(storage);
+      keys.forEach((k) => {
+        if (k.startsWith(this.prefix)) storage.removeItem(k);
+      });
+      return true;
+    } catch (error) {
+      sLogger.error("StorageManager.clear error", { error });
+      return false;
+    }
+  }
+  has(key, options) {
+    return this.get(key, options) !== null;
+  }
+  keys(options) {
+    var _a;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return [];
+    const result = [];
+    for (let i = 0; i < storage.length; i++) {
+      const k = storage.key(i);
+      if (k == null ? void 0 : k.startsWith(this.prefix)) {
+        result.push(k.slice(this.prefix.length));
+      }
+    }
+    return result;
+  }
+  size(options) {
+    var _a, _b;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return 0;
+    let bytes = 0;
+    for (let i = 0; i < storage.length; i++) {
+      const k = storage.key(i);
+      if (k == null ? void 0 : k.startsWith(this.prefix)) {
+        const v = storage.getItem(k);
+        bytes += k.length + ((_b = v == null ? void 0 : v.length) != null ? _b : 0);
+      }
+    }
+    return bytes;
+  }
+  isAvailable(type = "local") {
+    const storage = this.getStorage(type);
+    if (!storage) return false;
+    try {
+      const testKey = "__storage_test__";
+      storage.setItem(testKey, "1");
+      storage.removeItem(testKey);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  getAll(options) {
+    var _a;
+    const storage = this.getStorage((_a = options == null ? void 0 : options.type) != null ? _a : "local");
+    if (!storage) return {};
+    const result = {};
+    for (let i = 0; i < storage.length; i++) {
+      const k = storage.key(i);
+      if (k == null ? void 0 : k.startsWith(this.prefix)) {
+        const v = this.get(k.slice(this.prefix.length), options);
+        if (v !== null) result[k.slice(this.prefix.length)] = v;
+      }
+    }
+    return result;
+  }
+};
+/** Per-prefix instance map — prevents namespace collisions */
+_StorageManager.instances = /* @__PURE__ */ new Map();
+var StorageManager = _StorageManager;
+var storageManager = StorageManager.getInstance("");
+
+// src/EventBus.ts
+var logger2 = Logger.getInstance();
+var EventBus = class _EventBus {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  static getInstance() {
+    if (!_EventBus.instance) {
+      _EventBus.instance = new _EventBus();
+    }
+    return _EventBus.instance;
+  }
+  on(event, callback) {
+    if (!this.events.has(event)) {
+      this.events.set(event, []);
+    }
+    this.events.get(event).push(callback);
+    return { unsubscribe: () => this.off(event, callback) };
+  }
+  once(event, callback) {
+    const wrapped = (...args) => {
+      callback(...args);
+      this.off(event, wrapped);
+    };
+    return this.on(event, wrapped);
+  }
+  off(event, callback) {
+    const callbacks = this.events.get(event);
+    if (!callbacks) return;
+    const idx = callbacks.indexOf(callback);
+    if (idx > -1) callbacks.splice(idx, 1);
+    if (callbacks.length === 0) this.events.delete(event);
+  }
+  emit(event, ...args) {
+    const callbacks = this.events.get(event);
+    if (!callbacks) return;
+    callbacks.forEach((cb) => {
+      try {
+        cb(...args);
+      } catch (error) {
+        logger2.error(`EventBus: error in handler for "${event}"`, { error });
+      }
+    });
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.events.delete(event);
+    } else {
+      this.events.clear();
+    }
+  }
+  listenerCount(event) {
+    var _a, _b;
+    return (_b = (_a = this.events.get(event)) == null ? void 0 : _a.length) != null ? _b : 0;
+  }
+  eventNames() {
+    return Array.from(this.events.keys());
+  }
+  hasListeners(event) {
+    return this.listenerCount(event) > 0;
+  }
+};
+var eventBus = EventBus.getInstance();
+
+// src/CacheManager.ts
+var CacheManager = class _CacheManager {
+  constructor(maxSize = 100) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  static getInstance(maxSize) {
+    if (!_CacheManager.instance) {
+      _CacheManager.instance = new _CacheManager(maxSize);
+    }
+    return _CacheManager.instance;
+  }
+  set(key, value, options) {
+    if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) this.cache.delete(firstKey);
+    }
+    this.cache.set(key, { value, timestamp: Date.now(), ttl: options == null ? void 0 : options.ttl });
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return null;
+    if (entry.ttl && Date.now() - entry.timestamp > entry.ttl) {
+      this.cache.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  has(key) {
+    return this.get(key) !== null;
+  }
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  keys() {
+    return Array.from(this.cache.keys());
+  }
+  cleanExpired() {
+    let cleaned = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.ttl && Date.now() - entry.timestamp > entry.ttl) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+};
+var cacheManager = CacheManager.getInstance();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CacheManager,
+  EventBus,
+  Logger,
+  Queue,
+  StorageManager,
+  cacheManager,
+  eventBus,
+  logger,
+  storageManager
+});