@ix-xs/node-comfort 1.0.4 → 1.0.5

package/src/localStorage.js

@@ -0,0 +1,242 @@
+const fs = require("./fs");
+const checker = require("./checker");
+
+const originalEmitWarning = process.emitWarning;
+process.emitWarning = (warning, ...args) => {
+  if ((warning.name === "ExperimentalWarning" && warning.message.includes("SQLite")) ||
+      (typeof warning === "string" && warning.startsWith("SQLite is an experimental feature"))) {
+    return;
+  }
+  return originalEmitWarning.call(process, warning, ...args);
+};
+
+const { DatabaseSync } = require("node:sqlite");
+
+module.exports = class localStorage {
+  #$;
+  #models = new Map();
+
+  constructor(path = fs.createPath("localStorage/localStorage.sqlite")) {
+    if (path.includes("/")) {
+      const split = path.split("/");
+      const file = split[split.length - 1];
+      const folder = fs.createPath(path.replace(file, ""));
+      fs.createFolder(folder);
+    }
+
+    this.#$ = new DatabaseSync(path);
+    this.#exec("PRAGMA journal_mode = WAL");
+    this.#exec("PRAGMA foreign_keys = ON");
+  }
+
+  #exec(sql, options = []) {
+    try {
+      const stmt = this.#$.prepare(sql);
+      const result = stmt.run(...checker.isArray(options) ? options : [options]);
+      return {
+        changes: result.changes,
+        lastInsertRowid: result.lastInsertRowid,
+      };
+    } catch (error) {
+      throw error;
+    }
+  }
+  #buildCreateSQL(tableName, options) {
+    const columns = Object.entries(options).map(([col, def]) => {
+      let colDef = `${col} ${def.type}`;
+
+      if (def.primaryKey) {
+        colDef += " PRIMARY KEY";
+        if (def.autoincrement) colDef += " AUTOINCREMENT";
+      }
+      if (def.notNull) colDef += " NOT NULL";
+      if (def.unique) colDef += " UNIQUE";
+      if (def.defaultValue !== undefined) colDef += ` DEFAULT ${JSON.stringify(def.defaultValue)}`;
+      if (def.values?.length) {
+        colDef += ` CHECK(${col} IN (${def.values.map(v => JSON.stringify(v)).join(", ")}))`;
+      }
+
+      return colDef;
+    }).join(", ");
+
+    return `CREATE TABLE IF NOT EXISTS ${tableName} (${columns})`;
+  }
+  #defineModel(tableName, options) {
+    if (this.#models.has(tableName)) return;
+
+    const createSQL = this.#buildCreateSQL(tableName, options);
+    this.#exec(createSQL);
+    this.#models.set(tableName, { name: tableName, options });
+  }
+  #buildWhere(where) {
+    if (Object.keys(where).length === 0) {
+      return { where: "", params: [] };
+    }
+
+    const conditions = [];
+    const params = [];
+
+    for (const [key, value] of Object.entries(where)) {
+      conditions.push(`${key} = ?`);
+      params.push(value);
+    }
+
+    return {
+      where: `WHERE ${conditions.join(" AND ")}`,
+      params,
+    };
+  }
+  #getOrderBy(tableName) {
+    const model = this.#models.get(tableName);
+    if (!model) return "id DESC";
+    const firstCol = Object.keys(model.options)[0];
+    return `${firstCol} DESC`;
+  }
+
+  /**
+   * @param {{name: string, options: Record<string, {
+   * type: "TEXT"|"INTEGER"|"REAL"|"BLOB"|"NUMERIC"|"DATE"|"DATETIME"|"TIMESTAMP"|"TIME"|"VARCHAR"|"CHAR"|"CLOB",
+   * primaryKey?: boolean,
+   * unique?: boolean,
+   * notNull: boolean,
+   * defaultValue?: any,
+   * values?: Array<string>
+   * autoincrement?: boolean,
+   * }>}} table
+   */
+  async createTable(table) {
+    try {
+      this.#defineModel(table.name, table.options);
+      return { ok: true };
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   */
+  async deleteTable(tableName) {
+    try {
+      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+
+      this.#exec(`DROP TABLE IF EXISTS ${tableName}`);
+      this.#models.delete(tableName);
+      return { ok: true };
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   */
+  async clearTable(tableName) {
+    try {
+      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+
+      this.#exec(`DELETE FROM ${tableName}`);
+      return { ok: true };
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   * @param {object} [where]
+   */
+  async get(tableName, where) {
+    try {
+      if (!this.#models.has(tableName)) return undefined;
+
+      const whereClause = this.#buildWhere(where);
+      const sql = `SELECT * FROM ${tableName} ${whereClause.where} LIMIT 1`;
+      const stmt = this.#$.prepare(sql);
+      const record = stmt.get(whereClause.params);
+      return record || undefined;
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   * @param {object} [where]
+   * @param {number} [limit]
+   * @param {number} [offset]
+   */
+  async getAll(tableName, where = {}, limit = 50, offset = 0) {
+    try {
+      if (!this.#models.has(tableName)) return [];
+
+      const whereClause = this.#buildWhere(where);
+      const sql = `SELECT * FROM ${tableName} ${whereClause.where} ORDER BY ${this.#getOrderBy(tableName)} LIMIT ? OFFSET ?`;
+      const stmt = this.#$.prepare(sql);
+      const records = stmt.all(...whereClause.params, limit, offset);
+      return records;
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   * @param {*} data
+   * @param {object} [where]
+   */
+  async set(tableName, data, where = null) {
+    try {
+      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+
+      const lookup = where ?? (data.id ? { id: data.id } : null);
+
+      if (lookup) {
+        const columns = Object.keys(data).join(", ");
+        const placeholders = Object.keys(data).map(() => "?").join(", ");
+        const sql = `INSERT OR REPLACE INTO ${tableName} (${columns}) VALUES (${placeholders})`;
+        const stmt = this.#$.prepare(sql);
+        stmt.run(...Object.values(data));
+        return { ok: true };
+      } else {
+        const columns = Object.keys(data).join(", ");
+        const placeholders = Object.keys(data).map(() => "?").join(", ");
+        const sql = `INSERT INTO ${tableName} (${columns}) VALUES (${placeholders})`;
+        const stmt = this.#$.prepare(sql);
+        stmt.run(...Object.values(data));
+        return { ok: true };
+      }
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   * @param {object} where
+   */
+  async delete(tableName, where) {
+    try {
+      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+
+      const whereClause = this.#buildWhere(where);
+      const sql = `DELETE FROM ${tableName} ${whereClause.where}`;
+      const stmt = this.#$.prepare(sql);
+      const result = stmt.run(...whereClause.params);
+      return { ok: true, changes: result.changes };
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+  /**
+   * @param {string} tableName
+   * @param {object} where
+   */
+  async count(tableName, where = {}) {
+    try {
+      if (!this.#models.has(tableName)) return { error: `Table ${tableName} doesn't exist` };
+
+      const whereClause = this.#buildWhere(where);
+      const sql = `SELECT COUNT(*) as total FROM ${tableName} ${whereClause.where}`;
+      const stmt = this.#$.prepare(sql);
+      const result = stmt.get(...whereClause.params);
+      return result.total;
+    } catch (error) {
+      return { error: error.message };
+    }
+  }
+};

package/{core/Logger.js → src/logger.js}

@@ -56,11 +56,9 @@ const _options = {
 const _groups = [];
 
 /**
- * Gets ANSI escape code for style/color.
- * @private
- * @param {string} name - Style or color name.
- * @returns {number|null} ANSI code or null.
- */
+   * @param {string} name
+   * @returns {number|null}
+   */
 const _getCode = (name) => {
   if (_style[name] !== undefined) return _style[name];
   if (_color.fg[name] !== undefined) return _color.fg[name];
@@ -70,12 +68,9 @@ const _getCode = (name) => {
   }
   return null;
 };
-
-/**
- * Parses template tokens into styles and text.
- * @private
- * @param {string} input - Template string.
- * @returns {{codes: number[], text: string}} Parsed result.
+  /**
+ * @param {string} input
+ * @returns {{codes: number[], text: string}}
  */
 const _parse = (input) => {
   const tokens = input.trim().split(/\s+/);
@@ -108,10 +103,7 @@ const _parse = (input) => {
 		.trimStart();
   return { codes, text };
 };
-
-/**
- * Builds ANSI escape sequence from codes.
- * @private
+  /**
  * @param {number[]} codes - ANSI codes.
  * @returns {string} Escape sequence.
  */
@@ -119,7 +111,6 @@ const _build = (codes) => {
   if (codes.length === 0) return "";
   return `${_x}[${codes.join(";")}m`;
 };
-
 const _apply = (str) => {
   const esc_start = _options.delimiters.start.replace(
     /[.*+?^${}()|[\]\\]/g,
@@ -148,9 +139,7 @@ const _apply = (str) => {
     },
   );
 };
-
-/**
- * @private
+  /**
  * @returns {string}
  */
 const _timestamp = () => {
@@ -159,54 +148,17 @@ const _timestamp = () => {
     `<%gray [${new Date().toLocaleTimeString(undefined, { hour12: false })}]%>`,
   );
 };
-
-/**
- * Generates indentation based on group depth.
- * @private
- * @returns {string} Indentation spaces.
+  /**
+ * @returns {string}
  */
 const _indent = () => {
   return "  ".repeat(0 + _groups.length);
 };
 
-/**
- * @module logger
- * @description
- * Beautiful ANSI-colored console logger with grouping, timestamps, and template syntax.
- *
- * Supports 16+ colors, styles (bold, italic, underline), background colors,
- * nested groups with indentation, and customizable delimiters.
- *
- * ## Syntax
- * ```
- * <%red bold This is red and bold%>
- * <%bgBlue whiteBright ERROR%>
- * <%yellowBright [WARN]%>
- * ```
- *
- * Available styles: `normal`, `bold`, `italic`, `underline`, `overline`
- * Colors: `black`, `red`, `green`, `yellow`, `blue`, `magenta`, `cyan`, `white`, `gray`
- * Bright colors: `redBright`, `greenBright`, `yellowBright`, `blueBright`, `magentaBright`, `cyanBright`, `whiteBright`
- * Backgrounds: `bgBlack`, `bgRed`, `bgGreen`, etc.
- *
- * @example
- * const nodeComfort = require("@ix-xs/node-comfort");
- *
- * nodeComfort.log("<%greenBright ✓ Success%> Operation completed!");
- * nodeComfort.group("<%blue Processing files%>").log("File 1").groupEnd();
- * const log = nodeComfort.logify({ users: 42 }); // → ANSI string
- */
 module.exports = {
   /**
-	 * Logs content with colors, timestamp, and group indentation.
-	 * Supports strings, objects (pretty JSON), and chaining.
-	 *
-	 * @param {any} content - Content to log (string, object, or primitive).
-	 * @example
-	 * nodeComfort.log("<%greenBright ✓ Done%>");
-	 * nodeComfort.log({ users: 42, active: true });
-	 * nodeComfort.group("Files").log("Processing...").groupEnd();
-	 */
+ * @param {*} content
+ */
   log(content) {
     let str;
     if (typeof content === "string") {
@@ -239,16 +191,10 @@ module.exports = {
 
     return this;
   },
-
   /**
-	 * Formats content with colors, timestamp, and group indentation (no console output).
-	 *
-	 * @param {any} content - Content to format.
-	 * @returns {string} Formatted string.
-	 * @example
-	 * const msg = nodeComfort.logify("<%redBright ERROR%> Invalid input");
-	 * console.log(msg);
-	 */
+ * @param {any} content - Content to format.
+ * @returns {string} Formatted string.
+ */
   logify(content) {
     let str;
     if (typeof content === "string") {
@@ -262,46 +208,26 @@ module.exports = {
     const prefix = `${_timestamp()}${_indent()}`;
     return _apply(prefix ? `${prefix} ${str}` : str);
   },
-
   /**
-	 * Starts a new log group with ▼ indicator and increased indentation.
-	 *
-	 * @param {string} label - Group label (supports colors).
-	 * @example
-	 * nodeComfort.group("<%yellow Processing%>").log("Step 1").groupEnd();
-	 */
+ * @param {string} label
+ */
   group(label) {
     _groups.push(label);
     const prefix = `${_timestamp()}${_indent()}`;
     console.log(prefix ? `${prefix}▼ ${label}` : `▼ ${label}`);
     return this;
   },
-
-  /**
-	 * Ends current group and reduces indentation.
-	 *
-	 * @example
-	 * nodeComfort.group("Work").groupEnd();
-	 */
   groupEnd() {
     if (_groups.length > 0) _groups.pop();
     return this;
   },
-
   /**
-	 * Configures logger options (delimiters and timestamp).
-	 *
-	 * @param {object} [options] - Logger options.
-	 * @param {object} [options.delimiters] - Template delimiters.
-	 * @param {string} [options.delimiters.start="<%="] - Start delimiter.
-	 * @param {string} [options.delimiters.end="%>"] - End delimiter.
-	 * @param {boolean} [options.timestamp=true] - Show timestamps.
-	 * @example
-	 * nodeComfort.setLogger({
-	 *   delimiters: { start: "{{", end: "}}" },
-	 *   timestamp: false
-	 * }).log("{{ bgGreen new delimiters }}");
-	 */
+ * @param {object} [options]
+ * @param {object} [options.delimiters]
+ * @param {string} [options.delimiters.start="<%="]
+ * @param {string} [options.delimiters.end="%>"]
+ * @param {boolean} [options.timestamp=true]
+ */
   setLogger(options = _options) {
     options = {
       delimiters: {

package/src/utils.js

@@ -0,0 +1,225 @@
+const logger = require("./logger");
+
+module.exports = {
+  /**
+	 * @param {number} ms
+	 */
+  async wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  },
+  /**
+   * Polls a predicate at a given interval and emits events when it matches or times out.
+   *
+   * The predicate is evaluated every `options.interval` milliseconds (default: 50 ms).
+   * Be careful with the default interval: 50 ms is very frequent polling and can be
+   * unnecessarily CPU‑intensive if your predicate or trigger handlers are heavy.
+   * When `options.max` is `null`, the predicate can match indefinitely (infinite triggers),
+   * so you should choose an interval that makes sense for your use‑case.
+   *
+   * @param {boolean|Promise<boolean>|(() => boolean|Promise<boolean>)} predicate
+   *        Condition to evaluate at each tick, or a function returning it.
+   * @param {*} payload
+   *        Value passed to listeners when events are emitted (e.g. an object or message).
+   * @param {object} [options]
+   * @param {number} [options.interval=50]
+   *        Polling interval in milliseconds. Increase this value if your predicate is
+   *        expensive or you expect many triggers without a `max` limit.
+   * @param {number|null} [options.timeout=null]
+   *        Maximum time in milliseconds before emitting a "timeout" event and stopping.
+   *        If `null`, no timeout is applied.
+   * @param {number|null} [options.max=null]
+   *        Maximum number of successful predicate evaluations ("trigger" events) before
+   *        automatically stopping. If `null`, triggers are infinite until `stop()` is called.
+   *
+   * @example
+   * // Basic usage: infinite triggers every 50 ms (default interval) – use with caution.
+   * const task = when(() => true, { message: "Ok" });
+   *
+   * task.on("trigger", (payload) => {
+   *   console.log(payload.message);
+   *   // task.stop(); // stop when you’re done
+   * });
+   *
+   * task.start();
+   *
+   * @example
+   * // Safer usage: limit triggers and/or lower polling frequency.
+   * when(() => true, { message: "Ok" }, { max: 1, interval: 500 }) // one trigger max, every 500 ms
+   *   .on("trigger", (payload) => {
+   *     console.log(payload.message);
+   *   })
+   *   .start();
+   */
+  when(predicate, payload = {}, options) {
+    const interval = options?.interval ?? 50;
+    const timeout = options?.timeout ?? null;
+    const max = options?.max ?? null;
+
+    const listeners = {
+      trigger: new Set(),
+      error: new Set(),
+      timeout: new Set(),
+    };
+
+    let _timer = null;
+    let _timeoutTimer = null;
+    let _stopped = false;
+    let _count = 0;
+
+    function emit(event, p) {
+      for (const fn of listeners[event]) {
+        try {
+          fn(p);
+        } catch (error) {
+          throw error;
+        }
+      }
+    }
+
+    async function evalPredicate() {
+      if (typeof predicate === "function") {
+        return await predicate();
+      }
+      return Boolean(predicate);
+    }
+
+    async function tick() {
+      if (_stopped) return;
+
+      try {
+        const ok = await evalPredicate();
+
+        if (ok) {
+          _count++;
+          emit("trigger", payload);
+
+          if (max != null && _count >= max) {
+            _stopInternal();
+            return;
+          }
+        }
+
+        if (!_stopped) {
+          _timer = setTimeout(tick, interval);
+        }
+      } catch (error) {
+        emit("error", error);
+        if (!_stopped) {
+          _timer = setTimeout(tick, interval);
+        }
+      }
+    }
+
+    function _stopInternal() {
+      _stopped = true;
+      if (_timer) {
+        clearTimeout(_timer);
+        _timer = null;
+      }
+      if (_timeoutTimer) {
+        clearTimeout(_timeoutTimer);
+        _timeoutTimer = null;
+      }
+    }
+
+    const _ = {
+      start() {
+        if (_stopped) return _;
+
+        if (!_timer) {
+          _timer = setTimeout(tick, 0);
+        }
+
+        if (timeout != null && !_timeoutTimer) {
+          _timeoutTimer = setTimeout(() => {
+            if (_stopped) return;
+            emit("timeout", payload);
+            _stopInternal();
+          }, timeout);
+        }
+
+        return _;
+      },
+      stop() {
+        _stopInternal();
+        return _;
+      },
+      /**
+       * @typedef { "error" | "trigger" | "timeout" } EventNames
+       * @typedef {{
+       * error: (error) => void|Promise<void>,
+       * trigger: (payload) => void|Promise<void>,
+       * timeout: (payload) => void|Promise<void>,
+       * }} EventHandlers
+       */
+      /**
+       * @template {EventNames} E
+			 * @param {E} event
+			 * @param {EventHandlers[E]} handler
+			 */
+      on(event, handler) {
+        listeners[event]?.add(handler);
+        return _;
+      },
+    };
+
+    return _;
+  },
+  dontCrash() {
+    const defaults = {
+      error: (error) => {
+        logger.log(`<% red [@ix-xs/node-comfort] Process Error %>\n<% gray ${error.stack ?? error} %>`);
+      },
+      exit: (code) => {
+        logger.log(`<% yellow [@ix-xs/node-comfort] Process Exit %>\n→ Code: <% gray ${code} %>`);
+      },
+      sig: (signal) => {
+        logger.log(`<% yellow [@ix-xs/node-comfort] Process SIG* %>\n→ Signal: <% gray ${signal} %>`);
+        process.exit(0);
+      },
+      beforeExit: (code) => {},
+    };
+
+    const _ = {
+      /**
+			 * @template { "error" | "exit" | "sig" | "beforeExit" } E
+			 * @param { E } event
+			 * @param { { error: (error: Error | unknown) => void | Promise<void>, exit: (code: number) => void | Promise<void>, sig: (signal: "SIGINT" | "SIGTERM" | "SIGQUIT") => void | Promise<void>, beforeExit: (code: number) => void|Promise<void> }[E] } handler
+			 */
+      on(event, handler) {
+        if (event === "error") {
+          process.removeAllListeners("uncaughtException");
+          process.removeAllListeners("unhandledRejection");
+          process.on("uncaughtException", handler ?? defaults.error);
+          process.on("unhandledRejection", handler ?? defaults.error);
+        } else if (event === "exit") {
+          process.removeAllListeners("exit");
+          process.on("exit", handler ?? defaults.exit);
+        } else if (event === "sig") {
+          for (const signal of ["SIGINT", "SIGTERM", "SIGQUIT"]) {
+            process.removeAllListeners(signal);
+            process.on(signal, handler ?? defaults.sig);
+          }
+        } else if (event === "beforeExit") {
+          process.removeAllListeners("beforeExit");
+          process.on("beforeExit", handler ?? defaults.beforeExit);
+        }
+
+        return _;
+      },
+    };
+
+    _.on("error").on("exit").on("sig");
+
+    return _;
+  },
+  /**
+   * @param {*} value
+   */
+  JSONString(value) {
+    return JSON.stringify(value, null, 4);
+  },
+  JSONParse(value) {
+    return JSON.parse(value);
+  },
+};

package/tsconfig.json

@@ -13,6 +13,6 @@
 		"esModuleInterop": true,
 		"resolveJsonModule": true
 	},
-	"include": ["**/*"],
+	"include": ["**/*", "test.js"],
 	"exclude": ["node_modules", "types"]
 }