@keepkit/core 0.1.0

package/dist/chunk-H4A322SZ.js

@@ -0,0 +1,768 @@
+// src/types.ts
+var KeepStorageError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "KeepStorageError";
+    this.operation = options.operation;
+    this.storageKey = options.storageKey;
+    if (options.cause !== void 0) this.cause = options.cause;
+  }
+};
+var KeepStorageQuotaError = class extends KeepStorageError {
+  constructor(options) {
+    super("KeepKit storage quota was exceeded.", options);
+    this.name = "KeepStorageQuotaError";
+  }
+};
+var KeepStorageAccessError = class extends KeepStorageError {
+  constructor(options) {
+    super("KeepKit could not access the configured storage.", options);
+    this.name = "KeepStorageAccessError";
+  }
+};
+var KeepStorageParseError = class extends KeepStorageError {
+  constructor(options) {
+    super("KeepKit found invalid data in the configured storage.", options);
+    this.name = "KeepStorageParseError";
+  }
+};
+function normalizeKeepTags(tags) {
+  if (!tags) return void 0;
+  const normalized = [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
+  return normalized.length > 0 ? normalized : void 0;
+}
+
+// src/storage/sync.ts
+var DEFAULT_SYNC_QUEUE_KEY = "keepkit:sync-queue";
+var DEFAULT_SYNC_QUEUE_DATABASE = "keepkit-sync";
+var DEFAULT_SYNC_QUEUE_STORE = "sync-queue";
+var LocalStorageSyncQueueAdapter = class {
+  constructor(options = {}) {
+    this.key = options.key ?? DEFAULT_SYNC_QUEUE_KEY;
+    this.storage = options.storage ?? getBrowserStorage();
+  }
+  async getAll() {
+    if (!this.storage) return [];
+    const raw = this.storage.getItem(this.key);
+    if (!raw) return [];
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch (cause) {
+      throw Object.assign(new Error("KeepKit sync queue contains invalid JSON."), { cause });
+    }
+    if (!Array.isArray(value) || !value.every(isSyncOperation)) {
+      throw new Error("KeepKit sync queue contains invalid operations.");
+    }
+    return value;
+  }
+  async setMany(operations) {
+    if (!this.storage) return;
+    this.storage.setItem(this.key, JSON.stringify(operations));
+  }
+  async remove(operationIds) {
+    const ids = new Set(operationIds);
+    const current = await this.getAll();
+    await this.setMany(current.filter((operation) => !ids.has(operation.operationId)));
+  }
+  async clear() {
+    this.storage?.removeItem(this.key);
+  }
+};
+var IndexedDBSyncQueueAdapter = class {
+  constructor(options = {}) {
+    this.databaseName = options.databaseName ?? DEFAULT_SYNC_QUEUE_DATABASE;
+    this.storeName = options.storeName ?? DEFAULT_SYNC_QUEUE_STORE;
+    this.version = options.version ?? 1;
+    this.indexedDB = options.indexedDB ?? getBrowserIndexedDB();
+  }
+  async getAll() {
+    const database = await this.open();
+    if (!database) return [];
+    const transaction = database.transaction(this.storeName, "readonly");
+    const value = await requestToPromise(transaction.objectStore(this.storeName).getAll());
+    if (!Array.isArray(value) || !value.every(isSyncOperation)) {
+      throw new Error("KeepKit sync queue contains invalid operations.");
+    }
+    return value;
+  }
+  async setMany(operations) {
+    const database = await this.open();
+    if (!database) return;
+    const transaction = database.transaction(this.storeName, "readwrite");
+    const store = transaction.objectStore(this.storeName);
+    for (const operation of operations) store.put(operation);
+    await transactionToPromise(transaction);
+  }
+  async remove(operationIds) {
+    const database = await this.open();
+    if (!database) return;
+    const transaction = database.transaction(this.storeName, "readwrite");
+    const store = transaction.objectStore(this.storeName);
+    for (const operationId of new Set(operationIds)) store.delete(operationId);
+    await transactionToPromise(transaction);
+  }
+  async clear() {
+    const database = await this.open();
+    if (!database) return;
+    const transaction = database.transaction(this.storeName, "readwrite");
+    transaction.objectStore(this.storeName).clear();
+    await transactionToPromise(transaction);
+  }
+  open() {
+    if (!this.indexedDB) return Promise.resolve(void 0);
+    if (!this.databasePromise) {
+      this.databasePromise = new Promise((resolve, reject) => {
+        let request;
+        try {
+          request = this.indexedDB?.open(this.databaseName, this.version);
+        } catch (cause) {
+          reject(cause);
+          return;
+        }
+        request.onupgradeneeded = () => {
+          if (!request.result.objectStoreNames.contains(this.storeName)) {
+            request.result.createObjectStore(this.storeName, { keyPath: "operationId" });
+          }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => reject(request.error ?? new Error("IndexedDB open was blocked."));
+      });
+    }
+    return this.databasePromise.catch((cause) => {
+      this.databasePromise = void 0;
+      throw cause;
+    });
+  }
+};
+var SyncStorageAdapter = class {
+  constructor(options) {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.dataListeners = /* @__PURE__ */ new Set();
+    this.queueItems = [];
+    this.queueLoaded = false;
+    this.state = { status: "idle", pendingCount: 0, conflictIds: [] };
+    this.getSyncState = () => this.state;
+    this.subscribeSync = (listener) => {
+      this.listeners.add(listener);
+      return () => this.listeners.delete(listener);
+    };
+    this.subscribe = (listener) => {
+      this.dataListeners.add(listener);
+      const unsubscribeLocal = this.local.subscribe?.(listener) ?? (() => void 0);
+      return () => {
+        this.dataListeners.delete(listener);
+        unsubscribeLocal();
+      };
+    };
+    this.local = options.local;
+    this.remote = options.remote;
+    this.queue = options.queue ?? (getBrowserIndexedDB() ? new IndexedDBSyncQueueAdapter({
+      databaseName: options.queueDatabaseName
+    }) : new LocalStorageSyncQueueAdapter({
+      key: options.queueKey ?? `${DEFAULT_SYNC_QUEUE_KEY}:${options.local.storageKey ?? "default"}`
+    }));
+    this.clientId = options.clientId ?? createId();
+    this.now = options.now ?? Date.now;
+    this.resolveConflict = options.resolveConflict;
+    this.storageKey = this.local.storageKey;
+    if (typeof window !== "undefined") {
+      this.onlineHandler = () => void this.flushSync();
+      window.addEventListener("online", this.onlineHandler);
+    }
+  }
+  getAll() {
+    return this.local.getAll();
+  }
+  async set(item) {
+    const operation = this.createOperation("upsert", item.id, item);
+    await this.enqueueBeforeLocalWrite(operation);
+    try {
+      await this.local.set(item);
+    } catch (cause) {
+      await this.removeQueued(operation.operationId);
+      throw cause;
+    }
+    this.notifyDataListeners();
+    this.setPendingState();
+  }
+  async setMany(items) {
+    const operations = items.map((item) => this.createOperation("upsert", item.id, item));
+    await this.enqueueManyBeforeLocalWrite(operations);
+    try {
+      if (this.local.setMany) await this.local.setMany(items);
+      else for (const item of items) await this.local.set(item);
+    } catch (cause) {
+      await this.removeQueued(operations.map((operation) => operation.operationId));
+      throw cause;
+    }
+    this.notifyDataListeners();
+    this.setPendingState();
+  }
+  async remove(id) {
+    const operation = this.createOperation("remove", id);
+    await this.enqueueBeforeLocalWrite(operation);
+    try {
+      await this.local.remove(id);
+    } catch (cause) {
+      await this.removeQueued(operation.operationId);
+      throw cause;
+    }
+    this.notifyDataListeners();
+    this.setPendingState();
+  }
+  async removeMany(ids) {
+    const operations = [...new Set(ids)].map((id) => this.createOperation("remove", id));
+    await this.enqueueManyBeforeLocalWrite(operations);
+    try {
+      if (this.local.removeMany) await this.local.removeMany(ids);
+      else for (const id of ids) await this.local.remove(id);
+    } catch (cause) {
+      await this.removeQueued(operations.map((operation) => operation.operationId));
+      throw cause;
+    }
+    this.notifyDataListeners();
+    this.setPendingState();
+  }
+  async clear() {
+    const items = await this.local.getAll();
+    await this.removeMany(items.map((item) => item.id));
+    await this.local.clear();
+  }
+  async merge(localItems) {
+    const merged = this.local.merge ? await this.local.merge(localItems) : await mergeLocalItems(localItems, this.local);
+    await this.setMany(localItems);
+    return merged;
+  }
+  async flushSync() {
+    if (this.flushPromise) return this.flushPromise;
+    this.flushPromise = this.runFlush().finally(() => {
+      this.flushPromise = void 0;
+    });
+    return this.flushPromise;
+  }
+  dispose() {
+    if (this.onlineHandler) window.removeEventListener("online", this.onlineHandler);
+    this.listeners.clear();
+    this.dataListeners.clear();
+  }
+  async runFlush() {
+    await this.loadQueue();
+    if (!await this.pullRemote()) return;
+    if (this.queueItems.length === 0) {
+      this.updateState({ status: "synced", pendingCount: 0, error: void 0 });
+      return;
+    }
+    this.updateState({ status: "syncing", error: void 0 });
+    for (const operation of [...this.queueItems]) {
+      try {
+        const result = await this.remote.push(operation);
+        if (result.type === "conflict") {
+          const local = operation.item;
+          const resolved = this.resolveConflict ? await this.resolveConflict(local, result.remote, {
+            operation,
+            remoteRevision: result.revision
+          }) : void 0;
+          if (!resolved) {
+            this.updateState({
+              status: "conflict",
+              conflictIds: [.../* @__PURE__ */ new Set([...this.state.conflictIds, operation.id])]
+            });
+            continue;
+          }
+          const retry = this.createOperation("upsert", resolved.id, {
+            ...resolved,
+            revision: result.revision ?? resolved.revision
+          });
+          await this.local.set(retry.item);
+          await this.replaceQueued(operation, retry);
+          continue;
+        }
+        if (result.item) {
+          await this.local.set({
+            ...result.item,
+            ...result.revision ? { revision: result.revision } : {}
+          });
+          this.notifyDataListeners();
+        }
+        await this.removeQueued(operation.operationId);
+        this.updateState({
+          status: this.queueItems.length > 0 ? "syncing" : "synced",
+          lastSyncedAt: this.now(),
+          conflictIds: this.state.conflictIds.filter((id) => id !== operation.id)
+        });
+      } catch (error) {
+        this.updateState({ status: "error", error });
+        return;
+      }
+    }
+    if (this.queueItems.length === 0) this.updateState({ status: "synced", pendingCount: 0 });
+  }
+  createOperation(type, id, item) {
+    return {
+      operationId: `${this.clientId}:${this.now()}:${createId()}`,
+      type,
+      id,
+      ...item ? { item } : {},
+      createdAt: this.now(),
+      ...item?.revision ? { baseRevision: item.revision } : {}
+    };
+  }
+  async enqueueBeforeLocalWrite(operation) {
+    await this.enqueueManyBeforeLocalWrite([operation]);
+  }
+  async enqueueManyBeforeLocalWrite(operations) {
+    await this.loadQueue();
+    const next = [...this.queueItems];
+    for (const operation of operations) {
+      for (let index = next.length - 1; index >= 0; index -= 1) {
+        if (next[index]?.id !== operation.id) continue;
+        next.splice(index, 1);
+      }
+      next.push(operation);
+    }
+    await this.persistQueue(next);
+    this.updateState({ status: "pending", pendingCount: this.queueItems.length });
+  }
+  async loadQueue() {
+    if (this.queueLoaded) return;
+    if (!this.queueLoadPromise) {
+      this.queueLoadPromise = this.queue.getAll().then((items) => {
+        this.queueItems = items;
+        this.queueLoaded = true;
+      });
+    }
+    await this.queueLoadPromise;
+  }
+  async persistQueue(next) {
+    const previousIds = new Set(this.queueItems.map((operation) => operation.operationId));
+    const nextIds = new Set(next.map((operation) => operation.operationId));
+    const removed = [...previousIds].filter((id) => !nextIds.has(id));
+    if (removed.length > 0) await this.queue.remove(removed);
+    if (next.length > 0) await this.queue.setMany(next);
+    this.queueItems = next;
+  }
+  async removeQueued(operationIds) {
+    await this.loadQueue();
+    const ids = new Set(typeof operationIds === "string" ? [operationIds] : operationIds);
+    await this.queue.remove([...ids]);
+    this.queueItems = this.queueItems.filter((operation) => !ids.has(operation.operationId));
+    this.setPendingState();
+  }
+  async replaceQueued(previous, next) {
+    await this.persistQueue(
+      this.queueItems.map(
+        (operation) => operation.operationId === previous.operationId ? next : operation
+      )
+    );
+    this.setPendingState();
+  }
+  setPendingState() {
+    this.updateState({
+      status: this.queueItems.length > 0 ? "pending" : "synced",
+      pendingCount: this.queueItems.length
+    });
+  }
+  async pullRemote() {
+    if (!this.remote.pull) return true;
+    try {
+      const remoteItems = await this.remote.pull();
+      const pendingIds = new Set(this.queueItems.map((operation) => operation.id));
+      const localItems = await this.local.getAll();
+      const localById = new Map(localItems.map((item) => [item.id, item]));
+      const incoming = remoteItems.filter((item) => {
+        const current = localById.get(item.id);
+        return !pendingIds.has(item.id) && (!current || item.updatedAt >= current.updatedAt);
+      });
+      if (incoming.length === 0) return true;
+      if (this.local.setMany) await this.local.setMany(incoming);
+      else for (const item of incoming) await this.local.set(item);
+      this.notifyDataListeners();
+      return true;
+    } catch (error) {
+      this.updateState({ status: "error", error });
+      return false;
+    }
+  }
+  notifyDataListeners() {
+    for (const listener of this.dataListeners) listener();
+  }
+  updateState(next) {
+    this.state = {
+      ...this.state,
+      ...next,
+      pendingCount: next.pendingCount ?? this.queueItems.length
+    };
+    for (const listener of this.listeners) listener();
+  }
+};
+async function mergeLocalItems(localItems, target) {
+  const remoteItems = await target.getAll();
+  const byId = new Map(remoteItems.map((item) => [item.id, item]));
+  for (const item of localItems) {
+    const current = byId.get(item.id);
+    if (!current || item.updatedAt > current.updatedAt) byId.set(item.id, item);
+  }
+  const merged = [...byId.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+  if (target.setMany) await target.setMany(merged);
+  else for (const item of merged) await target.set(item);
+  return merged;
+}
+function isSyncOperation(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.operationId === "string" && (value.type === "upsert" || value.type === "remove") && typeof value.id === "string" && typeof value.createdAt === "number";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+  return Math.random().toString(36).slice(2);
+}
+function getBrowserStorage() {
+  if (typeof window === "undefined") return void 0;
+  try {
+    return window.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function getBrowserIndexedDB() {
+  if (typeof indexedDB === "undefined") return void 0;
+  return indexedDB;
+}
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function transactionToPromise(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () => reject(transaction.error);
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted."));
+  });
+}
+
+// src/storage/index.ts
+var DEFAULT_STORAGE_KEY = "keepkit:items";
+var DEFAULT_INDEXEDDB_DATABASE = "keepkit";
+var DEFAULT_INDEXEDDB_STORE = "items";
+function createStorageAdapter(options) {
+  const merge = options.merge;
+  const subscribe = options.subscribe;
+  const setMany = options.setMany;
+  const removeMany = options.removeMany;
+  return {
+    getAll: async () => options.getAll(),
+    set: async (item) => options.set(item),
+    ...setMany ? { setMany: async (items) => setMany(items) } : {},
+    remove: async (id) => options.remove(id),
+    ...removeMany ? { removeMany: async (ids) => removeMany(ids) } : {},
+    clear: async () => options.clear(),
+    ...merge ? { merge: async (items) => merge(items) } : {},
+    ...subscribe ? {
+      subscribe: (listener) => subscribe(listener) ?? (() => void 0)
+    } : {},
+    ...options.storageKey ? { storageKey: options.storageKey } : {}
+  };
+}
+var LocalStorageAdapter = class {
+  constructor(options = {}) {
+    this.storageKey = options.key ?? DEFAULT_STORAGE_KEY;
+    this.storage = options.storage ?? getBrowserStorage2();
+  }
+  async getAll() {
+    if (!this.storage) return [];
+    let raw;
+    try {
+      raw = this.storage.getItem(this.storageKey);
+    } catch (cause) {
+      throw new KeepStorageAccessError({
+        operation: "getAll",
+        storageKey: this.storageKey,
+        cause
+      });
+    }
+    if (!raw) return [];
+    try {
+      const value = JSON.parse(raw);
+      if (!isKeepItemArray(value)) {
+        throw new KeepStorageParseError({
+          operation: "getAll",
+          storageKey: this.storageKey
+        });
+      }
+      return value;
+    } catch (cause) {
+      if (cause instanceof KeepStorageParseError) throw cause;
+      throw new KeepStorageParseError({
+        operation: "getAll",
+        storageKey: this.storageKey,
+        cause
+      });
+    }
+  }
+  async set(item) {
+    await this.setMany([item]);
+  }
+  async setMany(items) {
+    const current = await this.getAll();
+    const byId = new Map(current.map((item) => [item.id, item]));
+    for (const item of items) byId.set(item.id, item);
+    this.write([...byId.values()], "set");
+  }
+  async remove(id) {
+    await this.removeMany([id]);
+  }
+  async removeMany(ids) {
+    const idSet = new Set(ids);
+    const items = await this.getAll();
+    this.write(
+      items.filter((item) => !idSet.has(item.id)),
+      "remove"
+    );
+  }
+  async clear() {
+    if (!this.storage) return;
+    try {
+      this.storage.removeItem(this.storageKey);
+    } catch (cause) {
+      throw new KeepStorageAccessError({
+        operation: "clear",
+        storageKey: this.storageKey,
+        cause
+      });
+    }
+  }
+  async merge(localItems) {
+    const remoteItems = await this.getAll();
+    const byId = new Map(remoteItems.map((item) => [item.id, item]));
+    for (const localItem of localItems) {
+      const remoteItem = byId.get(localItem.id);
+      if (!remoteItem || localItem.updatedAt > remoteItem.updatedAt) {
+        byId.set(localItem.id, localItem);
+      }
+    }
+    const merged = [...byId.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+    this.write(merged, "merge");
+    return merged;
+  }
+  subscribe(listener) {
+    if (typeof window === "undefined") return () => void 0;
+    const handleStorage = (event) => {
+      if (event.key !== null && event.key !== this.storageKey) return;
+      listener();
+    };
+    window.addEventListener("storage", handleStorage);
+    return () => window.removeEventListener("storage", handleStorage);
+  }
+  write(items, operation) {
+    if (!this.storage) return;
+    try {
+      this.storage.setItem(this.storageKey, JSON.stringify(items));
+    } catch (cause) {
+      if (isQuotaExceededError(cause)) {
+        throw new KeepStorageQuotaError({
+          operation,
+          storageKey: this.storageKey,
+          cause
+        });
+      }
+      throw new KeepStorageAccessError({
+        operation,
+        storageKey: this.storageKey,
+        cause
+      });
+    }
+  }
+};
+var IndexedDBAdapter = class {
+  constructor(options = {}) {
+    this.databaseName = options.databaseName ?? options.dbName ?? options.key ?? DEFAULT_INDEXEDDB_DATABASE;
+    this.storeName = options.storeName ?? DEFAULT_INDEXEDDB_STORE;
+    this.version = options.version ?? 1;
+    this.indexedDB = options.indexedDB ?? getBrowserIndexedDB2();
+    this.storageKey = `${this.databaseName}:${this.storeName}`;
+  }
+  async getAll() {
+    const database = await this.open("getAll");
+    if (!database) return [];
+    try {
+      const transaction = database.transaction(this.storeName, "readonly");
+      const value = await requestToPromise2(
+        transaction.objectStore(this.storeName).getAll()
+      );
+      if (!isKeepItemArray(value)) {
+        throw new KeepStorageParseError({ operation: "getAll", storageKey: this.storageKey });
+      }
+      return value;
+    } catch (cause) {
+      if (cause instanceof KeepStorageParseError) throw cause;
+      throw new KeepStorageAccessError({ operation: "getAll", storageKey: this.storageKey, cause });
+    }
+  }
+  async set(item) {
+    return this.setMany([item]);
+  }
+  async setMany(items) {
+    const database = await this.open("set");
+    if (!database) return;
+    try {
+      const transaction = database.transaction(this.storeName, "readwrite");
+      const objectStore = transaction.objectStore(this.storeName);
+      for (const item of items) objectStore.put(item);
+      await transactionToPromise2(transaction);
+      this.notifySubscribers();
+    } catch (cause) {
+      if (isQuotaExceededError(cause)) {
+        throw new KeepStorageQuotaError({ operation: "set", storageKey: this.storageKey, cause });
+      }
+      throw new KeepStorageAccessError({ operation: "set", storageKey: this.storageKey, cause });
+    }
+  }
+  async remove(id) {
+    return this.removeMany([id]);
+  }
+  async removeMany(ids) {
+    const database = await this.open("remove");
+    if (!database) return;
+    try {
+      const transaction = database.transaction(this.storeName, "readwrite");
+      const objectStore = transaction.objectStore(this.storeName);
+      for (const id of new Set(ids)) objectStore.delete(id);
+      await transactionToPromise2(transaction);
+      this.notifySubscribers();
+    } catch (cause) {
+      throw new KeepStorageAccessError({ operation: "remove", storageKey: this.storageKey, cause });
+    }
+  }
+  async clear() {
+    const database = await this.open("clear");
+    if (!database) return;
+    try {
+      const transaction = database.transaction(this.storeName, "readwrite");
+      transaction.objectStore(this.storeName).clear();
+      await transactionToPromise2(transaction);
+      this.notifySubscribers();
+    } catch (cause) {
+      throw new KeepStorageAccessError({ operation: "clear", storageKey: this.storageKey, cause });
+    }
+  }
+  async merge(localItems) {
+    try {
+      const remoteItems = await this.getAll();
+      const byId = new Map(remoteItems.map((item) => [item.id, item]));
+      for (const localItem of localItems) {
+        const remoteItem = byId.get(localItem.id);
+        if (!remoteItem || localItem.updatedAt > remoteItem.updatedAt)
+          byId.set(localItem.id, localItem);
+      }
+      const merged = [...byId.values()].sort((a, b) => b.updatedAt - a.updatedAt);
+      await this.setMany(merged);
+      return merged;
+    } catch (cause) {
+      if (cause instanceof KeepStorageError) throw cause;
+      throw new KeepStorageAccessError({ operation: "merge", storageKey: this.storageKey, cause });
+    }
+  }
+  subscribe(listener) {
+    if (!this.indexedDB || typeof BroadcastChannel === "undefined") return () => void 0;
+    const channel = new BroadcastChannel(`keepkit:${this.storageKey}`);
+    channel.onmessage = () => listener();
+    return () => channel.close();
+  }
+  notifySubscribers() {
+    if (!this.indexedDB || typeof BroadcastChannel === "undefined") return;
+    const channel = new BroadcastChannel(`keepkit:${this.storageKey}`);
+    channel.postMessage({ type: "keepkit:changed" });
+    channel.close();
+  }
+  open(operation) {
+    if (!this.indexedDB) return Promise.resolve(void 0);
+    if (!this.databasePromise) {
+      this.databasePromise = new Promise((resolve, reject) => {
+        let request;
+        try {
+          request = this.indexedDB?.open(this.databaseName, this.version);
+        } catch (cause) {
+          reject(new KeepStorageAccessError({ operation, storageKey: this.storageKey, cause }));
+          return;
+        }
+        request.onupgradeneeded = () => {
+          if (!request.result.objectStoreNames.contains(this.storeName)) {
+            request.result.createObjectStore(this.storeName, { keyPath: "id" });
+          }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+        request.onblocked = () => reject(request.error ?? new Error("IndexedDB open was blocked."));
+      });
+    }
+    return this.databasePromise.catch((cause) => {
+      this.databasePromise = void 0;
+      if (cause instanceof KeepStorageError) throw cause;
+      throw new KeepStorageAccessError({ operation, storageKey: this.storageKey, cause });
+    });
+  }
+};
+function isKeepItemArray(value) {
+  return Array.isArray(value) && value.every(
+    (item) => isRecord2(item) && typeof item.id === "string" && typeof item.savedAt === "number" && Number.isFinite(item.savedAt) && typeof item.updatedAt === "number" && Number.isFinite(item.updatedAt) && "meta" in item && (item.targetType === void 0 || typeof item.targetType === "string") && (item.note === void 0 || typeof item.note === "string") && (item.schemaVersion === void 0 || typeof item.schemaVersion === "number" && Number.isFinite(item.schemaVersion)) && (item.revision === void 0 || typeof item.revision === "string") && (item.tags === void 0 || Array.isArray(item.tags) && item.tags.every((tag) => typeof tag === "string"))
+  );
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function getBrowserStorage2() {
+  if (typeof window === "undefined") return void 0;
+  try {
+    return window.localStorage;
+  } catch {
+    return void 0;
+  }
+}
+function getBrowserIndexedDB2() {
+  if (typeof indexedDB === "undefined") return void 0;
+  return indexedDB;
+}
+function requestToPromise2(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function transactionToPromise2(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onerror = () => reject(transaction.error);
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted."));
+  });
+}
+function isQuotaExceededError(cause) {
+  if (!isRecord2(cause)) return false;
+  return cause.name === "QuotaExceededError" || cause.name === "NS_ERROR_DOM_QUOTA_REACHED" || cause.code === 22 || cause.code === 1014;
+}
+
+export {
+  KeepStorageError,
+  KeepStorageQuotaError,
+  KeepStorageAccessError,
+  KeepStorageParseError,
+  normalizeKeepTags,
+  DEFAULT_SYNC_QUEUE_KEY,
+  DEFAULT_SYNC_QUEUE_DATABASE,
+  DEFAULT_SYNC_QUEUE_STORE,
+  LocalStorageSyncQueueAdapter,
+  IndexedDBSyncQueueAdapter,
+  SyncStorageAdapter,
+  DEFAULT_STORAGE_KEY,
+  DEFAULT_INDEXEDDB_DATABASE,
+  DEFAULT_INDEXEDDB_STORE,
+  createStorageAdapter,
+  LocalStorageAdapter,
+  IndexedDBAdapter
+};
+//# sourceMappingURL=chunk-H4A322SZ.js.map