mcard-js 2.1.41 → 2.1.43

package/dist/chunk-UFW2VW2D.js

@@ -1,266 +0,0 @@
-import {
-  createPage,
-  validateHandle
-} from "./chunk-NZ6OQ7UT.js";
-import {
-  MCard
-} from "./chunk-5BIDGXA6.js";
-
-// src/storage/IndexedDBEngine.ts
-import { openDB } from "idb";
-var IndexedDBEngine = class {
-  db = null;
-  dbName;
-  constructor(dbName = "mcard-db") {
-    this.dbName = dbName;
-  }
-  /**
-   * Initialize the database connection
-   */
-  async init() {
-    this.db = await openDB(this.dbName, 1, {
-      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) {
-    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) {
-    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
-};