@ix-xs/node-comfort 1.0.56 → 1.1.0

package/src/localStorage.js

@@ -1,283 +0,0 @@
-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").replaceAll("\\", "/")) {
-    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 = checker.isArray(options)
-        ? stmt.run(...options)
-        : stmt.run(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 (!where || 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 {object} table
-   * @param {string} table.name
-   * @param {Record<string, {
-   * type: "INTEGER"|"TEXT"|"REAL"|"BLOB"|"NUMERIC",
-   * primaryKey?: boolean,
-   * autoincrement?: boolean,
-   * notNull?: boolean,
-   * unique?: boolean,
-   * defaultValue?: *,
-   * values?: Array<*>
-   * }>} table.options
-   */
-  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 {object} data
- * @param {object|null} 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);
-
-      let finalData = data;
-
-      if (lookup) {
-        const existing = await this.get(tableName, lookup);
-
-        if (existing && !existing.error) {
-          finalData = { ...existing, ...data };
-        }
-      }
-
-      const columns = Object.keys(finalData);
-      const placeholders = columns.map(() => "?").join(", ");
-      const sql = `INSERT OR REPLACE INTO ${tableName} (${columns.join(
-        ", ",
-      )}) VALUES (${placeholders})`;
-
-      const stmt = this.#$.prepare(sql);
-      stmt.run(...Object.values(finalData));
-
-      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/src/logger.js

@@ -1,243 +0,0 @@
-const _x = "\x1B";
-const _style = {
-  normal: 0,
-  bold: 1,
-  italic: 3,
-  underline: 4,
-  overline: 9,
-};
-const _color = {
-  fg: {
-    black: 30,
-    red: 31,
-    green: 32,
-    yellow: 33,
-    blue: 34,
-    magenta: 35,
-    cyan: 36,
-    white: 37,
-    gray: 90,
-    redBright: 91,
-    greenBright: 92,
-    yellowBright: 93,
-    blueBright: 94,
-    magentaBright: 95,
-    cyanBright: 96,
-    whiteBright: 97,
-    rgb: 38,
-  },
-  bg: {
-    black: 40,
-    red: 41,
-    green: 42,
-    yellow: 43,
-    blue: 44,
-    magenta: 45,
-    cyan: 46,
-    white: 47,
-    gray: 100,
-    redBright: 101,
-    greenBright: 102,
-    yellowBright: 103,
-    blueBright: 104,
-    magentaBright: 105,
-    cyanBright: 106,
-    whiteBright: 107,
-    rgb: 48,
-  },
-};
-const _options = {
-  delimiters: {
-    start: "<%",
-    end: "%>",
-  },
-  timestamp: true,
-};
-const _groups = [];
-
-/**
-   * @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];
-  if (name.startsWith("bg")) {
-    const bg = name.charAt(2).toLowerCase() + name.slice(3);
-    if (_color.bg[bg] !== undefined) return _color.bg[bg];
-  }
-  return null;
-};
-  /**
- * @param {string} input
- * @returns {{codes: number[], text: string}}
- */
-const _parse = (input) => {
-  const tokens = input.trim().split(/\s+/);
-  const styles = [];
-  const fgs = [];
-  const bgs = [];
-  const txts = [];
-
-  for (const token of tokens) {
-    const code = _getCode(token);
-    if (code === null) {
-      txts.push(token);
-    } else {
-      if (_style[token] !== undefined) {
-        styles.push(code);
-      } else if (token.startsWith("bg")) {
-        bgs.push(code);
-      } else {
-        fgs.push(code);
-      }
-    }
-  }
-
-  const codes = [...styles, ...bgs, ...fgs];
-  const text = input
-		.replace(
-		  /^\s*((redBright|greenBright|yellowBright|blueBright|magentaBright|cyanBright|whiteBright|red|green|yellow|blue|magenta|cyan|white|gray|black|bold|italic|underline|overline|bg\w+|\s+)*)/gi,
-		  "",
-		)
-		.trimStart();
-  return { codes, text };
-};
-  /**
- * @param {number[]} codes - ANSI codes.
- * @returns {string} Escape sequence.
- */
-const _build = (codes) => {
-  if (codes.length === 0) return "";
-  return `${_x}[${codes.join(";")}m`;
-};
-const _apply = (str) => {
-  const esc_start = _options.delimiters.start.replace(
-    /[.*+?^${}()|[\]\\]/g,
-    "\\$&",
-  );
-  const esc_end = _options.delimiters.end.replace(
-    /[.*+?^${}()|[\]\\]/g,
-    "\\$&",
-  );
-
-  return str.replace(
-    new RegExp(`${esc_start}([\\s\\S]*?)${esc_end}`, "g"),
-    (match, content) => {
-      const { codes, text } = _parse(content);
-      if (codes.length === 0 || text === "") return text;
-
-      if (text.includes("\n")) {
-        return text
-					.split(/\\r?\\n/)
-					.filter((line) => line.trim())
-					.map((line) => `${_build(codes)}${line}${_x}[0m`)
-					.join("\\n");
-      }
-
-      return `${_build(codes)}${text}${_x}[0m`;
-    },
-  );
-};
-  /**
- * @returns {string}
- */
-const _timestamp = () => {
-  if (!_options.timestamp) return "";
-  return _apply(
-    `<%gray [${new Date().toLocaleTimeString(undefined, { hour12: false })}]%>`,
-  );
-};
-  /**
- * @returns {string}
- */
-const _indent = () => {
-  return "  ".repeat(0 + _groups.length);
-};
-
-module.exports = {
-  /**
- * @param {*} content
- */
-  log(content) {
-    let str;
-    if (typeof content === "string") {
-      str = content;
-    } else if (typeof content === "object") {
-      str = JSON.stringify(content, null, 2);
-    } else {
-      str = String(content);
-    }
-
-    const prefix = `${_timestamp()}${_indent()}`;
-    const fullStr = prefix ? `${prefix} ${str}` : str;
-
-    const formatted = _apply(fullStr);
-
-    if (formatted.includes("\n")) {
-      const lines = formatted.split("\n");
-
-      if (lines[0].trim()) console.log(lines[0]);
-
-      const indentOnly = _indent();
-      for (let i = 1; i < lines.length; i++) {
-        if (lines[i].trim()) {
-          console.log(`${indentOnly}${lines[i]}`);
-        }
-      }
-    } else {
-      console.log(formatted);
-    }
-
-    return this;
-  },
-  /**
- * @param {any} content - Content to format.
- * @returns {string} Formatted string.
- */
-  logify(content) {
-    let str;
-    if (typeof content === "string") {
-      str = content;
-    } else if (typeof content === "object") {
-      str = JSON.stringify(content, null, 2);
-    } else {
-      str = String(content);
-    }
-
-    const prefix = `${_timestamp()}${_indent()}`;
-    return _apply(prefix ? `${prefix} ${str}` : str);
-  },
-  /**
- * @param {string} label
- */
-  group(label) {
-    _groups.push(label);
-    const prefix = `${_timestamp()}${_indent()}`;
-    console.log(prefix ? `${prefix}▼ ${label}` : `▼ ${label}`);
-    return this;
-  },
-  groupEnd() {
-    if (_groups.length > 0) _groups.pop();
-    return this;
-  },
-  /**
- * @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: {
-        start: options?.delimiters?.start ?? _options.delimiters.start,
-        end: options?.delimiters?.end ?? _options.delimiters.end,
-      },
-      timestamp: options?.timestamp ?? _options.timestamp,
-    };
-    _options.delimiters = options.delimiters;
-    _options.timestamp = options.timestamp;
-    return this;
-  },
-};