mcard-js 2.1.39 → 2.1.40

package/dist/chunk-42VF42KH.js

@@ -0,0 +1,273 @@
+import {
+  createPage
+} from "./chunk-3EIBJPNF.js";
+import {
+  init_Handle,
+  validateHandle
+} from "./chunk-ADV52544.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  INDEXEDDB_DEFAULT_DB_NAME,
+  INDEXEDDB_DEFAULT_DB_VERSION,
+  MCard
+} from "./chunk-3MMMJ7NH.js";
+
+// src/storage/engines/IndexedDBEngine.ts
+import { openDB } from "idb";
+init_Handle();
+var IndexedDBEngine = class {
+  db = null;
+  dbName;
+  constructor(dbName = INDEXEDDB_DEFAULT_DB_NAME) {
+    this.dbName = dbName;
+  }
+  /**
+   * Initialize the database connection
+   */
+  async init() {
+    this.db = await openDB(this.dbName, INDEXEDDB_DEFAULT_DB_VERSION, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains("cards")) {
+          db.createObjectStore("cards", { keyPath: "hash" });
+        }
+        if (!db.objectStoreNames.contains("handles")) {
+          const handleStore = db.createObjectStore("handles", { keyPath: "handle" });
+          handleStore.createIndex("by-hash", "currentHash");
+        }
+        if (!db.objectStoreNames.contains("handleHistory")) {
+          const historyStore = db.createObjectStore("handleHistory", {
+            keyPath: "id",
+            autoIncrement: true
+          });
+          historyStore.createIndex("by-handle", "handle");
+        }
+      }
+    });
+  }
+  ensureDb() {
+    if (!this.db) {
+      throw new Error("Database not initialized. Call init() first.");
+    }
+    return this.db;
+  }
+  // =========== Card Operations ===========
+  async add(card) {
+    const db = this.ensureDb();
+    await db.put("cards", {
+      hash: card.hash,
+      content: card.content,
+      g_time: card.g_time
+    });
+    return card.hash;
+  }
+  async get(hash) {
+    const db = this.ensureDb();
+    const record = await db.get("cards", hash);
+    if (!record) return null;
+    return MCard.fromData(record.content, record.hash, record.g_time);
+  }
+  async delete(hash) {
+    const db = this.ensureDb();
+    await db.delete("cards", hash);
+  }
+  async getPage(pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const totalItems = await db.count("cards");
+    const allCards = await db.getAll("cards");
+    const start = (pageNumber - 1) * pageSize;
+    const pageRecords = allCards.slice(start, start + pageSize);
+    const items = pageRecords.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(items, totalItems, pageNumber, pageSize);
+  }
+  async count() {
+    const db = this.ensureDb();
+    return db.count("cards");
+  }
+  async searchByHash(hashPrefix) {
+    const db = this.ensureDb();
+    const start = hashPrefix;
+    const end = hashPrefix + "\uFFFF";
+    const range = IDBKeyRange.bound(start, end);
+    const records = await db.getAll("cards", range);
+    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+  }
+  async search(query, pageNumber, pageSize = DEFAULT_PAGE_SIZE) {
+    const db = this.ensureDb();
+    const records = await db.getAll("cards");
+    const decoder = new TextDecoder();
+    const filtered = records.filter((r) => {
+      try {
+        const text = decoder.decode(r.content);
+        return text.includes(query);
+      } catch {
+        return false;
+      }
+    });
+    const totalItems = filtered.length;
+    const start = (pageNumber - 1) * pageSize;
+    const pageItems = filtered.slice(start, start + pageSize).map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+    return createPage(pageItems, totalItems, pageNumber, pageSize);
+  }
+  async getAll() {
+    const db = this.ensureDb();
+    const records = await db.getAll("cards");
+    return records.map((r) => MCard.fromData(r.content, r.hash, r.g_time));
+  }
+  async clear() {
+    const db = this.ensureDb();
+    await db.clear("cards");
+    await db.clear("handles");
+    await db.clear("handleHistory");
+  }
+  // =========== Handle Operations ===========
+  async registerHandle(handle, hash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const existing = await db.get("handles", normalized);
+    if (existing) {
+      throw new Error(`Handle '${handle}' already exists.`);
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.put("handles", {
+      handle: normalized,
+      currentHash: hash,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  async resolveHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const record = await db.get("handles", normalized);
+    return record?.currentHash ?? null;
+  }
+  async getByHandle(handle) {
+    const hash = await this.resolveHandle(handle);
+    if (!hash) return null;
+    return this.get(hash);
+  }
+  async updateHandle(handle, newHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const existing = await db.get("handles", normalized);
+    if (!existing) {
+      throw new Error(`Handle '${handle}' not found.`);
+    }
+    const previousHash = existing.currentHash;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await db.add("handleHistory", {
+      handle: normalized,
+      previousHash,
+      changedAt: now
+    });
+    await db.put("handles", {
+      ...existing,
+      currentHash: newHash,
+      updatedAt: now
+    });
+    return previousHash;
+  }
+  async getHandleHistory(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    return records.map((r) => ({ previousHash: r.previousHash, changedAt: r.changedAt })).reverse();
+  }
+  async pruneHandleHistory(handle, options = {}) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    let toDelete;
+    if (options.deleteAll) {
+      toDelete = records;
+    } else if (options.olderThan) {
+      toDelete = records.filter((r) => r.changedAt < options.olderThan);
+    } else {
+      return 0;
+    }
+    const tx = db.transaction("handleHistory", "readwrite");
+    for (const record of toDelete) {
+      await tx.store.delete(record.id);
+    }
+    await tx.done;
+    return toDelete.length;
+  }
+  // =========== Handle Management Operations ===========
+  async getAllHandles() {
+    const db = this.ensureDb();
+    const records = await db.getAll("handles");
+    return records.map((r) => ({ handle: r.handle, hash: r.currentHash }));
+  }
+  async removeHandle(handle) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const keysToTry = normalized !== handle.trim() ? [normalized, handle.trim()] : [normalized];
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    for (const key of keysToTry) {
+      await handleStore.delete(key);
+    }
+    const historyIndex = historyStore.index("by-handle");
+    for (const key of keysToTry) {
+      let cursor = await historyIndex.openCursor(key);
+      while (cursor) {
+        await cursor.delete();
+        cursor = await cursor.continue();
+      }
+    }
+    await tx.done;
+  }
+  async renameHandle(oldHandle, newHandle) {
+    const db = this.ensureDb();
+    const normalizedOld = validateHandle(oldHandle);
+    const normalizedNew = validateHandle(newHandle);
+    if (normalizedOld === normalizedNew) return;
+    const oldEntry = await db.get("handles", normalizedOld);
+    if (!oldEntry) throw new Error(`Handle '${oldHandle}' not found.`);
+    const newEntry = await db.get("handles", normalizedNew);
+    if (newEntry) throw new Error(`Handle '${newHandle}' already exists.`);
+    const tx = db.transaction(["handles", "handleHistory"], "readwrite");
+    const handleStore = tx.objectStore("handles");
+    const historyStore = tx.objectStore("handleHistory");
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    await handleStore.put({
+      ...oldEntry,
+      handle: normalizedNew,
+      updatedAt: now
+    });
+    await handleStore.delete(normalizedOld);
+    const historyIndex = historyStore.index("by-handle");
+    let cursor = await historyIndex.openCursor(normalizedOld);
+    while (cursor) {
+      const record = cursor.value;
+      record.handle = normalizedNew;
+      await cursor.update(record);
+      cursor = await cursor.continue();
+    }
+    await tx.done;
+  }
+  async deleteHistoryEntry(handle, previousHash) {
+    const db = this.ensureDb();
+    const normalized = validateHandle(handle);
+    const records = await db.getAllFromIndex("handleHistory", "by-handle", normalized);
+    const entries = records.sort((a, b) => a.id - b.id);
+    const targetIdx = entries.findIndex((e) => e.previousHash === previousHash);
+    if (targetIdx === -1) return;
+    const target = entries[targetIdx];
+    const successor = entries[targetIdx + 1];
+    const tx = db.transaction("handleHistory", "readwrite");
+    const store = tx.objectStore("handleHistory");
+    if (successor && targetIdx > 0) {
+      const predecessor = entries[targetIdx - 1];
+      successor.previousHash = predecessor.previousHash;
+      await store.put(successor);
+    }
+    await store.delete(target.id);
+    await tx.done;
+  }
+};
+
+export {
+  IndexedDBEngine
+};

package/dist/chunk-4PDYHPR6.js

@@ -0,0 +1,297 @@
+import {
+  DEFAULT_PAGE_SIZE,
+  MCard
+} from "./chunk-3MMMJ7NH.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-AWD6YMZR.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-AWD6YMZR.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-ADV52544.js

@@ -0,0 +1,95 @@
+import {
+  __esm,
+  __export
+} from "./chunk-PNKVD2UK.js";
+
+// src/model/Handle.ts
+var Handle_exports = {};
+__export(Handle_exports, {
+  ContentHandle: () => ContentHandle,
+  HandleValidationError: () => HandleValidationError,
+  validateHandle: () => validateHandle
+});
+function isValidStartChar(char) {
+  return /^\p{L}$/u.test(char);
+}
+function isValidBodyChar(char) {
+  return /^[\p{L}\p{N}_./ -]$/u.test(char);
+}
+function validateHandle(handle) {
+  if (!handle) {
+    throw new HandleValidationError("Handle cannot be empty.");
+  }
+  const normalized = handle.trim().normalize("NFC");
+  if (normalized.length === 0) {
+    throw new HandleValidationError("Handle cannot be empty after normalization.");
+  }
+  if (normalized.length > MAX_HANDLE_LENGTH) {
+    throw new HandleValidationError(
+      `Handle '${handle}' is too long (${normalized.length} chars). Maximum is ${MAX_HANDLE_LENGTH}.`
+    );
+  }
+  if (!isValidStartChar(normalized[0])) {
+    throw new HandleValidationError(
+      `Invalid handle '${handle}'. Must start with a letter (any language).`
+    );
+  }
+  for (let i = 1; i < normalized.length; i++) {
+    if (!isValidBodyChar(normalized[i])) {
+      throw new HandleValidationError(
+        `Invalid character '${normalized[i]}' at position ${i} in handle '${handle}'.`
+      );
+    }
+  }
+  return normalized;
+}
+var MAX_HANDLE_LENGTH, HandleValidationError, ContentHandle;
+var init_Handle = __esm({
+  "src/model/Handle.ts"() {
+    MAX_HANDLE_LENGTH = 255;
+    HandleValidationError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "HandleValidationError";
+      }
+    };
+    ContentHandle = class {
+      handle;
+      currentHash;
+      createdAt;
+      updatedAt;
+      constructor(handle, currentHash, createdAt, updatedAt) {
+        this.handle = validateHandle(handle);
+        this.currentHash = currentHash;
+        this.createdAt = createdAt ?? /* @__PURE__ */ new Date();
+        this.updatedAt = updatedAt ?? this.createdAt;
+      }
+      /**
+       * Update handle to point to new hash
+       * @returns Previous hash for history tracking
+       */
+      update(newHash) {
+        const previousHash = this.currentHash;
+        this.currentHash = newHash;
+        this.updatedAt = /* @__PURE__ */ new Date();
+        return previousHash;
+      }
+      toObject() {
+        return {
+          handle: this.handle,
+          currentHash: this.currentHash,
+          createdAt: this.createdAt.toISOString(),
+          updatedAt: this.updatedAt.toISOString()
+        };
+      }
+    };
+  }
+});
+
+export {
+  HandleValidationError,
+  validateHandle,
+  ContentHandle,
+  Handle_exports,
+  init_Handle
+};