mcard-js 2.1.49 → 2.1.50

package/dist/chunk-VJPXJVEH.js

@@ -0,0 +1,299 @@
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  DEFAULT_PAGE_SIZE
+} from "./chunk-ETJWXHKZ.js";
+
+// src/monads/Maybe.ts
+var Maybe = class _Maybe {
+  constructor(_value, _isNothing) {
+    this._value = _value;
+    this._isNothing = _isNothing;
+  }
+  /**
+   * Create a Just (has value)
+   */
+  static just(value) {
+    return new _Maybe(value, false);
+  }
+  /**
+   * Create a Nothing (no value)
+   */
+  static nothing() {
+    return new _Maybe(null, true);
+  }
+  /**
+   * Check if this is Nothing
+   */
+  get isNothing() {
+    return this._isNothing;
+  }
+  /**
+   * Check if this is Just
+   */
+  get isJust() {
+    return !this._isNothing;
+  }
+  /**
+   * Get the value (throws if Nothing)
+   */
+  get value() {
+    if (this._isNothing) {
+      throw new Error("Cannot get value from Nothing");
+    }
+    return this._value;
+  }
+  /**
+   * Monadic bind - chain operations
+   * Short-circuits on Nothing
+   */
+  bind(fn) {
+    if (this._isNothing) {
+      return _Maybe.nothing();
+    }
+    return fn(this._value);
+  }
+  /**
+   * Map a function over the value
+   */
+  map(fn) {
+    if (this._isNothing) {
+      return _Maybe.nothing();
+    }
+    return _Maybe.just(fn(this._value));
+  }
+  /**
+   * Get value or default
+   */
+  getOrElse(defaultValue) {
+    return this._isNothing ? defaultValue : this._value;
+  }
+};
+
+// src/model/CardCollection.ts
+var CardCollection = class {
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  // =========== Standard Operations ===========
+  /**
+   * Add a card to the collection
+   * Handles duplicates (same content, same hash) and collisions (diff content, same hash)
+   */
+  async add(card) {
+    const existingCard = await this.engine.get(card.hash);
+    if (existingCard) {
+      const isDuplicate = this.areContentsEqual(existingCard.content, card.content);
+      if (isDuplicate) {
+        const { generateDuplicationEvent } = await import("./EventProducer-VFDOM5W2.js");
+        const eventStr = generateDuplicationEvent(card);
+        const eventCard = await MCard.create(eventStr);
+        await this.engine.add(eventCard);
+        return card.hash;
+      } else {
+        const { generateCollisionEvent } = await import("./EventProducer-VFDOM5W2.js");
+        const eventStr = await generateCollisionEvent(card);
+        const eventCard = await MCard.create(eventStr);
+        await this.engine.add(eventCard);
+        const eventObj = JSON.parse(eventStr);
+        const nextAlgo = eventObj.upgraded_function;
+        if (!nextAlgo) {
+          throw new Error("Failed to determine next hash algorithm for collision");
+        }
+        const upgradedCard = await MCard.create(card.content, nextAlgo);
+        return this.engine.add(upgradedCard);
+      }
+    }
+    return this.engine.add(card);
+  }
+  areContentsEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  /**
+   * Get a card by hash
+   */
+  async get(hash) {
+    return this.engine.get(hash);
+  }
+  /**
+   * Delete a card by hash
+   */
+  async delete(hash) {
+    return this.engine.delete(hash);
+  }
+  /**
+   * Get a page of cards
+   */
+  async getPage(pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    return this.engine.getPage(pageNumber, pageSize);
+  }
+  /**
+   * Count total cards
+   */
+  async count() {
+    return this.engine.count();
+  }
+  // =========== Handle Operations ===========
+  /**
+   * Add a card and register a handle for it
+   */
+  async addWithHandle(card, handle) {
+    const hash = await this.add(card);
+    await this.engine.registerHandle(handle, hash);
+    return hash;
+  }
+  /**
+   * Get card by handle
+   */
+  async getByHandle(handle) {
+    return this.engine.getByHandle(handle);
+  }
+  /**
+   * Resolve handle to hash
+   */
+  async resolveHandle(handle) {
+    return this.engine.resolveHandle(handle);
+  }
+  /**
+   * Update handle to point to new card
+   */
+  async updateHandle(handle, newCard) {
+    const hash = await this.add(newCard);
+    await this.engine.updateHandle(handle, hash);
+    return hash;
+  }
+  /**
+   * Get version history for a handle
+   */
+  async getHandleHistory(handle) {
+    return this.engine.getHandleHistory(handle);
+  }
+  // =========== Monadic Operations ===========
+  /**
+   * Monadic get - returns Maybe<MCard>
+   */
+  async getM(hash) {
+    const card = await this.get(hash);
+    return card ? Maybe.just(card) : Maybe.nothing();
+  }
+  /**
+   * Monadic getByHandle - returns Maybe<MCard>
+   */
+  async getByHandleM(handle) {
+    const card = await this.getByHandle(handle);
+    return card ? Maybe.just(card) : Maybe.nothing();
+  }
+  /**
+   * Monadic resolveHandle - returns Maybe<string>
+   */
+  async resolveHandleM(handle) {
+    const hash = await this.resolveHandle(handle);
+    return hash ? Maybe.just(hash) : Maybe.nothing();
+  }
+  /**
+   * Resolve handle and get card in one monadic operation
+   */
+  async resolveAndGetM(handle) {
+    const maybeHash = await this.resolveHandleM(handle);
+    if (maybeHash.isNothing) return Maybe.nothing();
+    return this.getM(maybeHash.value);
+  }
+  /**
+   * Prune version history for a handle.
+   * @param handle The handle string.
+   * @param options Options for pruning (olderThan date, or deleteAll).
+   * @returns Number of deleted entries.
+   */
+  async pruneHandleHistory(handle, options = {}) {
+    if (this.engine.pruneHandleHistory) {
+      return this.engine.pruneHandleHistory(handle, options);
+    }
+    return 0;
+  }
+  // =========== Search & Bulk Operations ===========
+  async clear() {
+    return this.engine.clear();
+  }
+  async searchByString(query, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    return this.engine.search(query, pageNumber, pageSize);
+  }
+  async searchByContent(query, pageNumber = 1, pageSize = DEFAULT_PAGE_SIZE) {
+    return this.engine.search(query, pageNumber, pageSize);
+  }
+  async searchByHash(hashPrefix) {
+    return this.engine.searchByHash(hashPrefix);
+  }
+  async getAllMCardsRaw() {
+    return this.engine.getAll();
+  }
+  async getAllCards(pageSize = DEFAULT_PAGE_SIZE, processCallback) {
+    const cards = [];
+    let pageNumber = 1;
+    let total = 0;
+    while (true) {
+      const page = await this.getPage(pageNumber, pageSize);
+      if (!page.items || page.items.length === 0) break;
+      for (const card of page.items) {
+        if (processCallback) {
+          processCallback(card);
+        }
+        cards.push(card);
+      }
+      total = page.totalItems;
+      if (!page.hasNext) break;
+      pageNumber++;
+    }
+    return { cards, total };
+  }
+  async printAllCards() {
+    const cards = await this.getAllMCardsRaw();
+    cards.forEach((card) => {
+      console.log(`Hash: ${card.hash}`);
+      try {
+        const text = new TextDecoder().decode(card.content);
+        const preview = text.slice(0, 100).replace(/\n/g, " ");
+        console.log(`Content: ${preview}${text.length > 100 ? "..." : ""}`);
+      } catch {
+        console.log(`Content (binary): ${card.content.length} bytes`);
+      }
+      console.log("---");
+    });
+  }
+  // =========== Handle Management Operations ===========
+  /**
+   * List all registered handles with their current hashes.
+   */
+  async getAllHandles() {
+    return this.engine.getAllHandles();
+  }
+  /**
+   * Remove a handle and all its history entries.
+   * Does NOT delete the underlying card(s).
+   */
+  async removeHandle(handle) {
+    return this.engine.removeHandle(handle);
+  }
+  /**
+   * Rename a handle atomically: updates handle registry and all history entries.
+   */
+  async renameHandle(oldHandle, newHandle) {
+    return this.engine.renameHandle(oldHandle, newHandle);
+  }
+  /**
+   * Delete a single history entry by handle + previousHash, stitching the chain.
+   */
+  async deleteHistoryEntry(handle, previousHash) {
+    return this.engine.deleteHistoryEntry(handle, previousHash);
+  }
+};
+
+export {
+  Maybe,
+  CardCollection
+};

package/dist/chunk-VW3KBDK5.js

@@ -0,0 +1,74 @@
+// src/storage/EngineRegistry.ts
+var EngineType = /* @__PURE__ */ ((EngineType2) => {
+  EngineType2["INDEXED_DB"] = "indexeddb";
+  EngineType2["SQLITE_NODE"] = "sqlite-node";
+  EngineType2["SQLITE_WASM"] = "sqlite-wasm";
+  return EngineType2;
+})(EngineType || {});
+var ENGINE_INFO = {
+  ["indexeddb" /* INDEXED_DB */]: {
+    type: "indexeddb" /* INDEXED_DB */,
+    displayName: "IndexedDB",
+    environment: "browser",
+    package: null,
+    description: "Browser-native IndexedDB key-value store"
+  },
+  ["sqlite-node" /* SQLITE_NODE */]: {
+    type: "sqlite-node" /* SQLITE_NODE */,
+    displayName: "SQLite (Node.js)",
+    environment: "node",
+    package: "better-sqlite3",
+    description: "SQLite via native better-sqlite3 bindings"
+  },
+  ["sqlite-wasm" /* SQLITE_WASM */]: {
+    type: "sqlite-wasm" /* SQLITE_WASM */,
+    displayName: "SQLite (WASM)",
+    environment: "browser",
+    package: "sql.js",
+    description: "SQLite via sql.js WebAssembly"
+  }
+};
+async function createEngine(type, options = {}) {
+  switch (type) {
+    case "indexeddb" /* INDEXED_DB */: {
+      const { IndexedDBEngine } = await import("./IndexedDBEngine-RD4447IS.js");
+      const engine = new IndexedDBEngine();
+      await engine.init();
+      return engine;
+    }
+    case "sqlite-node" /* SQLITE_NODE */: {
+      const { SqliteNodeEngine } = await import("./storage/SqliteNodeEngine.js");
+      return SqliteNodeEngine.create(options.dbPath || ":memory:");
+    }
+    case "sqlite-wasm" /* SQLITE_WASM */: {
+      const { SqliteWasmEngine } = await import("./storage/SqliteWasmEngine.js");
+      const engine = new SqliteWasmEngine();
+      await engine.init(options.wasmUrl, options.existingData);
+      return engine;
+    }
+    default: {
+      const validTypes = Object.values(EngineType).join(", ");
+      throw new Error(
+        `Unknown engine type: "${type}". Valid types: ${validTypes}`
+      );
+    }
+  }
+}
+function getAvailableEngines() {
+  return Object.values(EngineType);
+}
+function getEngineInfo(type) {
+  return ENGINE_INFO[type];
+}
+function getEnginesByEnvironment(env) {
+  return Object.values(ENGINE_INFO).filter((info) => info.environment === env);
+}
+
+export {
+  EngineType,
+  ENGINE_INFO,
+  createEngine,
+  getAvailableEngines,
+  getEngineInfo,
+  getEnginesByEnvironment
+};

package/dist/chunk-XETU7TV4.js

@@ -0,0 +1,112 @@
+import {
+  AbstractSqlEngine,
+  CORE_SCHEMAS
+} from "./chunk-GIKMCG4D.js";
+import {
+  MCard
+} from "./chunk-GGQCF7ZK.js";
+import {
+  DEFAULT_SQLJS_WASM_URL
+} from "./chunk-ETJWXHKZ.js";
+
+// src/storage/engines/SqliteWasmEngine.ts
+var SqliteWasmEngine = class extends AbstractSqlEngine {
+  db = null;
+  SQL = null;
+  /**
+   * Initialize the database
+   * @param wasmUrl URL to sql-wasm.wasm file (optional, defaults to CDN)
+   * @param existingData Optional existing database as Uint8Array
+   */
+  async init(wasmUrl, existingData) {
+    const initSqlJs = (await import("sql.js")).default;
+    const SQL = await initSqlJs({
+      locateFile: (file) => wasmUrl || `${DEFAULT_SQLJS_WASM_URL}${file}`
+    });
+    this.SQL = SQL;
+    this.db = existingData ? new SQL.Database(existingData) : new SQL.Database();
+    this.db.run(CORE_SCHEMAS.card);
+    this.db.run(CORE_SCHEMAS.handleRegistry);
+    this.db.run(CORE_SCHEMAS.handleHistory);
+    this.db.run(CORE_SCHEMAS.handleIndex);
+  }
+  ensureDb() {
+    if (!this.db) throw new Error("Database not initialized. Call init() first.");
+    return this.db;
+  }
+  // ======================================================================
+  // AbstractSqlEngine primitives
+  // ======================================================================
+  async queryRows(sql, ...params) {
+    const db = this.ensureDb();
+    const stmt = db.prepare(sql);
+    if (params.length > 0) stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push(row);
+    }
+    stmt.free();
+    return results;
+  }
+  async execSql(sql, ...params) {
+    const db = this.ensureDb();
+    if (params.length === 0) {
+      db.run(sql);
+    } else {
+      db.run(sql, params);
+    }
+    return 0;
+  }
+  // ======================================================================
+  // Row → MCard conversion (sql.js returns Uint8Array for BLOBs)
+  // ======================================================================
+  rowToCard(row) {
+    const rawContent = row.content;
+    const content = rawContent instanceof Uint8Array ? rawContent : typeof rawContent === "string" ? new TextEncoder().encode(rawContent) : new Uint8Array(0);
+    return MCard.fromData(content, String(row.hash), String(row.g_time));
+  }
+  // ======================================================================
+  // sql.js-specific helpers
+  // ======================================================================
+  /**
+   * Export database as Uint8Array (for persistence)
+   */
+  export() {
+    return this.ensureDb().export();
+  }
+  /**
+   * Get raw sql.js Database for use with VectorStore adapter.
+   */
+  getRawDb() {
+    return this.ensureDb();
+  }
+  // =========== pruneHandleHistory override (needs count before delete) ===========
+  async pruneHandleHistory(handle, options = {}) {
+    const { validateHandle } = await import("./Handle-3N4QOA3U.js");
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    if (options.deleteAll) {
+      const stmt = db.prepare("SELECT COUNT(*) FROM handle_history WHERE handle = ?");
+      stmt.bind([normalized]);
+      stmt.step();
+      const count = stmt.get()[0];
+      stmt.free();
+      db.run("DELETE FROM handle_history WHERE handle = ?", [normalized]);
+      return count;
+    } else if (options.olderThan) {
+      const stmt = db.prepare("SELECT COUNT(*) FROM handle_history WHERE handle = ? AND changed_at < ?");
+      stmt.bind([normalized, options.olderThan]);
+      stmt.step();
+      const count = stmt.get()[0];
+      stmt.free();
+      db.run("DELETE FROM handle_history WHERE handle = ? AND changed_at < ?", [normalized, options.olderThan]);
+      return count;
+    }
+    return 0;
+  }
+};
+
+export {
+  SqliteWasmEngine
+};