@keepkit/core 0.1.0 → 0.3.0

package/dist/{index.js → react.js}

@@ -1,190 +1,18 @@
+"use client";
 import {
-  DEFAULT_INDEXEDDB_DATABASE,
-  DEFAULT_INDEXEDDB_STORE,
-  DEFAULT_STORAGE_KEY,
-  DEFAULT_SYNC_QUEUE_DATABASE,
-  DEFAULT_SYNC_QUEUE_KEY,
-  DEFAULT_SYNC_QUEUE_STORE,
-  IndexedDBAdapter,
-  IndexedDBSyncQueueAdapter,
-  KeepStorageAccessError,
-  KeepStorageError,
-  KeepStorageParseError,
-  KeepStorageQuotaError,
-  LocalStorageAdapter,
-  LocalStorageSyncQueueAdapter,
-  SyncStorageAdapter,
-  createStorageAdapter,
+  KeepStore,
+  isKeepItemMetadataStale,
+  queryKeepItems,
+  revalidateKeepItems
+} from "./chunk-J7NKIOXV.js";
+import {
+  parseKeepMeta
+} from "./chunk-THZ3ACR2.js";
+import "./chunk-5QSZP6MT.js";
+import {
+  createBrowserStorageAdapter,
   normalizeKeepTags
-} from "./chunk-H4A322SZ.js";
-
-// src/migration.ts
-async function mergeKeepItems(localItems, target) {
-  if (target.merge) return target.merge(localItems);
-  const remoteItems = await target.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 Promise.all(merged.map((item) => target.set(item)));
-  return merged;
-}
-async function migrateKeepItems(source, target) {
-  const localItems = await source.getAll();
-  const merged = await mergeKeepItems(localItems, target);
-  await source.clear();
-  return merged;
-}
-
-// src/schema.ts
-var KeepSchemaValidationError = class extends Error {
-  constructor(message, options = {}) {
-    super(message);
-    this.name = "KeepSchemaValidationError";
-    this.cause = options.cause;
-    this.itemId = options.itemId;
-  }
-};
-async function parseKeepMeta(schema, value) {
-  try {
-    if ("parse" in schema) return await schema.parse(value);
-    if ("safeParse" in schema) {
-      const result2 = await schema.safeParse(value);
-      if (result2.success) return result2.data;
-      throw new KeepSchemaValidationError("KeepKit metadata did not match the configured schema.", {
-        cause: result2.error
-      });
-    }
-    const result = await schema["~standard"].validate(value);
-    if (!result.issues && "value" in result) return result.value;
-    throw new KeepSchemaValidationError("KeepKit metadata did not match the configured schema.", {
-      cause: result.issues
-    });
-  } catch (cause) {
-    if (cause instanceof KeepSchemaValidationError) throw cause;
-    throw new KeepSchemaValidationError("KeepKit metadata did not match the configured schema.", {
-      cause
-    });
-  }
-}
-async function validateKeepItem(item, schema) {
-  return { ...item, meta: await parseKeepMeta(schema, item.meta) };
-}
-
-// src/backup.ts
-var KEEP_BACKUP_FORMAT = "keepkit";
-var KEEP_BACKUP_VERSION = 1;
-var KeepBackupParseError = class extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "KeepBackupParseError";
-    if (options?.cause !== void 0) this.cause = options.cause;
-  }
-};
-var KeepBackupImportError = class extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "KeepBackupImportError";
-    this.mode = options.mode;
-    this.imported = options.imported;
-    this.failed = options.failed;
-    if (options.cause !== void 0) this.cause = options.cause;
-  }
-};
-async function exportItems(adapter) {
-  const backup = {
-    format: KEEP_BACKUP_FORMAT,
-    version: KEEP_BACKUP_VERSION,
-    exportedAt: Date.now(),
-    items: await adapter.getAll()
-  };
-  return JSON.stringify(backup, null, 2);
-}
-async function importItems(adapter, data, options = {}) {
-  const backup = parseBackup(data);
-  const mode = options.mode ?? "merge";
-  const validItems = [];
-  let failed = 0;
-  for (const item of backup.items) {
-    if (!options.schema) {
-      validItems.push(item);
-      continue;
-    }
-    try {
-      validItems.push(await validateKeepItem(item, options.schema));
-    } catch (cause) {
-      options.onInvalidItem?.(cause, item);
-      if ((options.invalidItemPolicy ?? "error") === "drop") {
-        failed += 1;
-        continue;
-      }
-      throw cause;
-    }
-  }
-  let items;
-  if (mode === "merge") {
-    try {
-      items = await mergeKeepItems(validItems, adapter);
-    } catch (cause) {
-      throw new KeepBackupImportError("KeepKit could not merge the backup.", {
-        mode,
-        imported: 0,
-        failed: validItems.length + failed,
-        cause
-      });
-    }
-  } else {
-    let imported = 0;
-    try {
-      await adapter.clear();
-      for (const item of validItems) {
-        await adapter.set(item);
-        imported += 1;
-      }
-      items = await adapter.getAll();
-    } catch (cause) {
-      throw new KeepBackupImportError("KeepKit could not replace the stored items.", {
-        mode,
-        imported,
-        failed: validItems.length + failed - imported,
-        cause
-      });
-    }
-  }
-  return { mode, imported: validItems.length, failed, total: items.length, items };
-}
-function parseBackup(data) {
-  let value = data;
-  if (typeof data === "string") {
-    try {
-      value = JSON.parse(data);
-    } catch (cause) {
-      throw new KeepBackupParseError("KeepKit backup is not valid JSON.", { cause });
-    }
-  }
-  if (!isRecord(value)) throw new KeepBackupParseError("KeepKit backup must be an object.");
-  if (value.format !== KEEP_BACKUP_FORMAT || value.version !== KEEP_BACKUP_VERSION) {
-    throw new KeepBackupParseError("KeepKit backup format or version is unsupported.");
-  }
-  if (typeof value.exportedAt !== "number" || !Number.isFinite(value.exportedAt)) {
-    throw new KeepBackupParseError("KeepKit backup has an invalid export timestamp.");
-  }
-  if (!Array.isArray(value.items) || !value.items.every(isKeepItem)) {
-    throw new KeepBackupParseError("KeepKit backup contains invalid items.");
-  }
-  return value;
-}
-function isKeepItem(value) {
-  if (!isRecord(value)) return false;
-  return typeof value.id === "string" && typeof value.savedAt === "number" && Number.isFinite(value.savedAt) && typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) && "meta" in value && (value.targetType === void 0 || typeof value.targetType === "string") && (value.note === void 0 || typeof value.note === "string") && (value.schemaVersion === void 0 || typeof value.schemaVersion === "number" && Number.isFinite(value.schemaVersion)) && (value.revision === void 0 || typeof value.revision === "string") && (value.tags === void 0 || Array.isArray(value.tags) && value.tags.every((tag) => typeof tag === "string"));
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
+} from "./chunk-X4UVKTBK.js";
 
 // src/hooks/useKeepItem.ts
 import { useCallback as useCallback3 } from "react";
@@ -199,39 +27,13 @@ import {
   useRef,
   useSyncExternalStore
 } from "react";
-
-// src/store.ts
-var KeepStore = class {
-  constructor(initialState) {
-    this.listeners = /* @__PURE__ */ new Set();
-    this.getSnapshot = () => this.state;
-    this.subscribe = (listener) => {
-      this.listeners.add(listener);
-      return () => this.listeners.delete(listener);
-    };
-    this.state = initialState;
-  }
-  setState(next) {
-    let changed = false;
-    for (const key of Object.keys(next)) {
-      if (!Object.is(this.state[key], next[key])) {
-        changed = true;
-        break;
-      }
-    }
-    if (!changed) return;
-    this.state = { ...this.state, ...next };
-    for (const listener of this.listeners) listener();
-  }
-};
-
-// src/KeepProvider.tsx
 import { jsx } from "react/jsx-runtime";
-var defaultStorage = new LocalStorageAdapter();
+var defaultStorage = createBrowserStorageAdapter();
 var KeepContext = createContext(null);
 var KeepStoreContext = createContext(null);
 function KeepProvider({
   storage = defaultStorage,
+  initialItems,
   onSave,
   onRemove,
   onNoteUpdate,
@@ -249,7 +51,7 @@ function KeepProvider({
   const storeRef = useRef(null);
   if (!storeRef.current) {
     storeRef.current = new KeepStore({
-      items: [],
+      items: initialItems ? [...initialItems] : [],
       isLoading: true,
       isHydrated: false,
       isMutating: false,
@@ -276,10 +78,7 @@ function KeepProvider({
   const pendingRefreshesRef = useRef(0);
   const pendingMutationsRef = useRef(0);
   const syncStorage = isSyncCapableStorage(storage) ? storage : void 0;
-  const getSyncState = useCallback(
-    () => syncStorage?.getSyncState() ?? IDLE_SYNC_STATE,
-    [syncStorage]
-  );
+  const getSyncState = useCallback(() => syncStorage?.getSyncState() ?? IDLE_SYNC_STATE, [syncStorage]);
   const subscribeSync = useCallback(
     (listener) => syncStorage?.subscribeSync(listener) ?? (() => void 0),
     [syncStorage]
@@ -300,19 +99,13 @@ function KeepProvider({
     },
     [store]
   );
-  const runBeforePlugins = useCallback(
-    async (context) => {
-      for (const plugin of pluginsRef.current) await plugin.before?.(context);
-      return context;
-    },
-    []
-  );
-  const runAfterPlugins = useCallback(
-    async (context) => {
-      for (const plugin of pluginsRef.current) await plugin.after?.(context);
-    },
-    []
-  );
+  const runBeforePlugins = useCallback(async (context) => {
+    for (const plugin of pluginsRef.current) await plugin.before?.(context);
+    return context;
+  }, []);
+  const runAfterPlugins = useCallback(async (context) => {
+    for (const plugin of pluginsRef.current) await plugin.after?.(context);
+  }, []);
   const enqueueOperation = useCallback((operation) => {
     const run = operationTailRef.current.then(operation, operation);
     operationTailRef.current = run.then(
@@ -434,10 +227,9 @@ function KeepProvider({
         throw cause;
       }
       await runMutation("save", normalizedItem.id, (previous) => ({
-        next: [
-          ...previous.filter((current) => current.id !== normalizedItem.id),
-          normalizedItem
-        ].sort((a, b) => b.updatedAt - a.updatedAt),
+        next: [...previous.filter((current) => current.id !== normalizedItem.id), normalizedItem].sort(
+          (a, b) => b.updatedAt - a.updatedAt
+        ),
         persist: () => storage.set(normalizedItem),
         onSuccess: () => handlersRef.current.onSave?.(normalizedItem),
         pluginContext: { action: "save", id: normalizedItem.id, item: normalizedItem }
@@ -533,9 +325,7 @@ function KeepProvider({
       const idSet = new Set(ids);
       const currentItems = itemsRef.current.filter((item) => idSet.has(item.id));
       await Promise.all(
-        currentItems.map(
-          (item) => updateTags(item.id, normalizeKeepTags([...item.tags ?? [], ...additions]))
-        )
+        currentItems.map((item) => updateTags(item.id, normalizeKeepTags([...item.tags ?? [], ...additions])))
       );
     },
     [updateTags]
@@ -547,10 +337,7 @@ function KeepProvider({
       const currentItems = itemsRef.current.filter((item) => idSet.has(item.id));
       await Promise.all(
         currentItems.map(
-          (item) => updateTags(
-            item.id,
-            normalizeKeepTags((item.tags ?? []).filter((tag) => !removals.has(tag)))
-          )
+          (item) => updateTags(item.id, normalizeKeepTags((item.tags ?? []).filter((tag) => !removals.has(tag))))
         )
       );
     },
@@ -614,10 +401,65 @@ function KeepProvider({
     })),
     [runMutation, storage]
   );
-  const flushSync = useCallback(
-    () => syncStorage ? syncStorage.flushSync() : Promise.resolve(),
-    [syncStorage]
+  const revalidateItems = useCallback(
+    async (revalidator, options = {}) => {
+      pendingMutationsRef.current += 1;
+      store.setState({ isMutating: true });
+      const run = enqueueOperation(async () => {
+        const previous = itemsRef.current;
+        let persistenceStarted = false;
+        try {
+          const summary = await revalidateKeepItems(previous, revalidator, options);
+          const pluginContext = { action: "revalidate", items: summary.updatedItems };
+          await runBeforePlugins(pluginContext);
+          if (summary.updatedItems.length > 0) {
+            persistenceStarted = true;
+            if (storage.setMany) await storage.setMany(summary.updatedItems);
+            else for (const item of summary.updatedItems) await storage.set(item);
+          }
+          if (summary.removedIds.length > 0) {
+            persistenceStarted = true;
+            if (storage.removeMany) await storage.removeMany(summary.removedIds);
+            else for (const id of summary.removedIds) await storage.remove(id);
+          }
+          setItems(summary.items);
+          store.setState({ error: null });
+          const removedIdSet = new Set(summary.removedIds);
+          for (const result of summary.results) {
+            if (removedIdSet.has(result.item.id)) handlersRef.current.onRemove?.(result.item);
+          }
+          await runAfterPlugins(pluginContext);
+          void Promise.resolve(handlersRef.current.onChange?.({ ...pluginContext, phase: "local" })).catch(
+            (cause) => reportError(cause, { action: "revalidate" })
+          );
+          return summary;
+        } catch (cause) {
+          if (persistenceStarted) await restoreItems(storage, previous);
+          setItems(previous);
+          reportError(cause, { action: "revalidate" });
+          throw cause;
+        }
+      });
+      return run.finally(() => {
+        pendingMutationsRef.current -= 1;
+        if (pendingMutationsRef.current === 0) store.setState({ isMutating: false });
+      });
+    },
+    [enqueueOperation, reportError, runAfterPlugins, runBeforePlugins, setItems, storage, store]
+  );
+  const refreshItemMetadata = useCallback(
+    async (id, refresh2) => {
+      if (!itemsRef.current.some((item) => item.id === id)) {
+        throw new Error(`Cannot refresh metadata for missing item "${id}".`);
+      }
+      await revalidateItems(async (item) => {
+        if (item.id !== id) return "available";
+        return { status: "available", meta: await refresh2(item) };
+      });
+    },
+    [revalidateItems]
   );
+  const flushSync = useCallback(() => syncStorage ? syncStorage.flushSync() : Promise.resolve(), [syncStorage]);
   const value = useMemo(
     () => ({
       items,
@@ -636,7 +478,9 @@ function KeepProvider({
       removeItems,
       clear,
       refresh,
-      flushSync
+      flushSync,
+      refreshItemMetadata,
+      revalidateItems
     }),
     [
       clear,
@@ -655,7 +499,9 @@ function KeepProvider({
       updateTagsBatch,
       addTagsBatch,
       removeTagsBatch,
-      removeItems
+      removeItems,
+      refreshItemMetadata,
+      revalidateItems
     ]
   );
   const actions = useMemo(
@@ -669,7 +515,9 @@ function KeepProvider({
       removeItem,
       removeItems,
       clear,
-      refresh
+      refresh,
+      refreshItemMetadata,
+      revalidateItems
     }),
     [
       addTagsBatch,
@@ -681,7 +529,9 @@ function KeepProvider({
       saveItem,
       updateNote,
       updateTags,
-      updateTagsBatch
+      updateTagsBatch,
+      refreshItemMetadata,
+      revalidateItems
     ]
   );
   const storeAccess = useMemo(() => ({ store, actions }), [actions, store]);
@@ -698,6 +548,16 @@ function isSyncCapableStorage(storage) {
 async function parseKeepMetaItem(item, schema) {
   return { ...item, meta: await parseKeepMeta(schema, item.meta) };
 }
+async function restoreItems(storage, items) {
+  try {
+    if (storage.setMany) {
+      await storage.setMany(items);
+      return;
+    }
+    for (const item of items) await storage.set(item);
+  } catch {
+  }
+}
 function useKeepContext() {
   const context = useContext(KeepContext);
   if (!context) throw new Error("Keep hooks must be used inside a KeepProvider");
@@ -759,6 +619,10 @@ function useKeepItem(id, itemPayload) {
   const toggle = useCallback3(() => item ? remove() : save(), [item, remove, save]);
   const updateNote = useCallback3((note) => actions.updateNote(id, note), [actions, id]);
   const updateTags = useCallback3((tags) => actions.updateTags(id, tags), [actions, id]);
+  const refreshMetadata = useCallback3(
+    (refresh) => actions.refreshItemMetadata(id, refresh),
+    [actions, id]
+  );
   return {
     item,
     isSaved: Boolean(item),
@@ -769,7 +633,8 @@ function useKeepItem(id, itemPayload) {
     remove,
     toggle,
     updateNote,
-    updateTags
+    updateTags,
+    refreshMetadata
   };
 }
 
@@ -873,14 +738,8 @@ function useKeepList(options = {}) {
     (ids, tags2) => actions.updateTagsBatch(ids, tags2),
     [actions]
   );
-  const addTagsBatch = useCallback4(
-    (ids, tags2) => actions.addTagsBatch(ids, tags2),
-    [actions]
-  );
-  const removeTagsBatch = useCallback4(
-    (ids, tags2) => actions.removeTagsBatch(ids, tags2),
-    [actions]
-  );
+  const addTagsBatch = useCallback4((ids, tags2) => actions.addTagsBatch(ids, tags2), [actions]);
+  const removeTagsBatch = useCallback4((ids, tags2) => actions.removeTagsBatch(ids, tags2), [actions]);
   return {
     items,
     totalCount,
@@ -896,55 +755,10 @@ function useKeepList(options = {}) {
     addTagsBatch,
     removeTagsBatch,
     clear: actions.clear,
-    refresh: actions.refresh
+    refresh: actions.refresh,
+    revalidate: actions.revalidateItems
   };
 }
-function queryKeepItems(source, options = {}) {
-  const filtered = source.filter((item) => {
-    const [from, to] = options.savedBetween ?? [];
-    const savedAt = item.savedAt;
-    const lowerBound = from === void 0 ? void 0 : toTimestamp(from);
-    const upperBound = to === void 0 ? void 0 : toTimestamp(to);
-    return (options.targetType === void 0 || item.targetType === options.targetType) && (options.tag === void 0 || item.tags?.includes(options.tag) === true) && (options.tags === void 0 || options.tags.every((tag) => item.tags?.includes(tag))) && (lowerBound === void 0 || savedAt >= lowerBound) && (upperBound === void 0 || savedAt <= upperBound) && matchesSearch(item, options.searchQuery, options.search) && (options.filter?.(item) ?? true) && (options.filterFn?.(item) ?? true);
-  });
-  const tagCounts = getTagCounts(filtered);
-  const sortBy = options.sortBy ?? options.sort?.by;
-  const direction = (options.order ?? options.sort?.direction) === "asc" ? 1 : -1;
-  const sorted = sortBy ? [...filtered].sort((a, b) => (a[sortBy] - b[sortBy]) * direction) : filtered;
-  const offset = Math.max(0, options.offset ?? 0);
-  const items = options.limit === void 0 ? sorted.slice(offset) : sorted.slice(offset, offset + Math.max(0, options.limit));
-  return { items, totalCount: sorted.length, tagCounts };
-}
-function getTagCounts(items) {
-  const counts = {};
-  for (const item of items) {
-    for (const tag of item.tags ?? []) counts[tag] = (counts[tag] ?? 0) + 1;
-  }
-  return Object.fromEntries(Object.entries(counts).sort(([a], [b]) => a.localeCompare(b)));
-}
-function matchesSearch(item, searchQuery, search) {
-  const query = search?.query ?? searchQuery;
-  if (!query?.trim()) return true;
-  const fields = search?.fields ?? ["note", "meta", "tags"];
-  const values = fields.map((field) => {
-    if (field === "note") return item.note ?? "";
-    if (field === "tags") return (item.tags ?? []).join(" ");
-    try {
-      return JSON.stringify(item.meta) ?? "";
-    } catch {
-      return String(item.meta);
-    }
-  });
-  const text = values.join(" ").toLocaleLowerCase();
-  if (!search) return text.includes(query.trim().toLocaleLowerCase());
-  const normalized = query.trim().toLocaleLowerCase();
-  const needles = search.tokenize === false ? [normalized] : normalized.split(/\s+/).filter(Boolean);
-  const matches = needles.map((needle) => text.includes(needle));
-  return search.mode === "or" ? matches.some(Boolean) : matches.every(Boolean);
-}
-function toTimestamp(value) {
-  return value instanceof Date ? value.getTime() : value;
-}
 function sameItems(left, right) {
   return left.length === right.length && left.every((item, index) => item === right[index]);
 }
@@ -957,6 +771,62 @@ function sameCounts(left, right) {
   });
 }
 
+// src/hooks/useKeepShortcut.ts
+import { useEffect as useEffect2 } from "react";
+function useKeepShortcut(options) {
+  const item = useKeepItem(options.id ?? "", options.itemPayload);
+  const {
+    action = "toggle",
+    allowInEditable = false,
+    enabled = true,
+    key,
+    modifier,
+    onError,
+    onTrigger,
+    preventDefault = true
+  } = options;
+  useEffect2(() => {
+    if (!enabled) return;
+    const handleKeyDown = (event) => {
+      if (!allowInEditable && isEditableTarget(event.target)) return;
+      if (!matchesShortcut(event, key, modifier)) return;
+      if (preventDefault) event.preventDefault();
+      const run = onTrigger ? onTrigger(event) : options.id ? action === "save" ? item.save() : action === "remove" ? item.remove() : item.toggle() : void 0;
+      if (run) void Promise.resolve(run).catch((error) => onError?.(error));
+    };
+    window.addEventListener("keydown", handleKeyDown);
+    return () => window.removeEventListener("keydown", handleKeyDown);
+  }, [
+    action,
+    allowInEditable,
+    enabled,
+    item.remove,
+    item.save,
+    item.toggle,
+    key,
+    modifier,
+    onError,
+    onTrigger,
+    options.id,
+    preventDefault
+  ]);
+}
+function matchesShortcut(event, key, modifier) {
+  if (event.key.toLocaleLowerCase() !== key.toLocaleLowerCase()) return false;
+  const modifiers = {
+    meta: event.metaKey,
+    ctrl: event.ctrlKey,
+    alt: event.altKey,
+    shift: event.shiftKey
+  };
+  if (modifier ? !modifiers[modifier] : Object.values(modifiers).some(Boolean)) return false;
+  return Object.entries(modifiers).every(([name, pressed]) => name === modifier || !pressed);
+}
+function isEditableTarget(target) {
+  if (!(target instanceof HTMLElement)) return false;
+  return target.isContentEditable || target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.tagName === "SELECT";
+}
+
 // src/KeepButton.tsx
 import {
   Children,
@@ -969,6 +839,9 @@ function KeepButton({
   children,
   savedLabel = "Saved",
   unsavedLabel = "Save",
+  savedAriaLabel,
+  unsavedAriaLabel,
+  getAriaLabel,
   asChild = false,
   onToggleError,
   onClick,
@@ -984,6 +857,7 @@ function KeepButton({
   const { isSaved, toggle } = state;
   const isDisabled = disabled ?? state.isMutating;
   async function handleClick(event) {
+    if (isDisabled) return;
     if (asChild) {
       onClick?.(event);
     } else {
@@ -1000,33 +874,53 @@ function KeepButton({
   }
   const content = typeof children === "function" ? children(state) : children ?? (isSaved ? savedLabel : unsavedLabel);
   function handleElementClick(event) {
+    if (isDisabled) return;
     if (asChild && isValidElement(content)) {
       content.props.onClick?.(event);
     }
     if (!event.defaultPrevented) void handleClick(event);
   }
+  function handleKeyDown(event) {
+    if (asChild && isValidElement(content)) {
+      content.props.onKeyDown?.(event);
+    }
+    buttonProps.onKeyDown?.(event);
+    if (!event.defaultPrevented && !isDisabled && asChild && (event.key === "Enter" || event.key === " ")) {
+      void handleClick(event);
+      event.preventDefault();
+    }
+  }
+  const child = asChild ? Children.only(content) : void 0;
+  if (asChild && !isValidElement(child)) {
+    throw new Error("KeepButton with asChild requires a single React element child.");
+  }
   const commonProps = {
     ...buttonProps,
     "aria-pressed": isSaved,
-    "aria-label": ("aria-label" in buttonProps ? buttonProps["aria-label"] : void 0) ?? (isSaved ? "Remove saved item" : "Save item"),
-    disabled: isDisabled,
-    onClick: handleElementClick
+    "aria-label": ("aria-label" in buttonProps ? buttonProps["aria-label"] : void 0) ?? getAriaLabel?.(state) ?? (isSaved ? savedAriaLabel : unsavedAriaLabel) ?? getAccessibleLabel(isSaved, item, asChild),
+    ...asChild ? {
+      "aria-disabled": isDisabled,
+      role: buttonProps.role ?? "button",
+      tabIndex: isDisabled ? -1 : buttonProps.tabIndex ?? 0
+    } : { disabled: isDisabled },
+    onClick: handleElementClick,
+    onKeyDown: handleKeyDown
   };
   if (asChild) {
-    const child = Children.only(content);
-    if (!isValidElement(child)) {
-      throw new Error("KeepButton with asChild requires a single React element child.");
-    }
     return cloneElement(child, commonProps);
   }
-  return /* @__PURE__ */ jsx2(
-    "button",
-    {
-      ...commonProps,
-      type: "type" in buttonProps ? buttonProps.type ?? "button" : "button",
-      children: content
-    }
-  );
+  return /* @__PURE__ */ jsx2("button", { ...commonProps, type: "type" in buttonProps ? buttonProps.type ?? "button" : "button", children: content });
+}
+function getAccessibleLabel(isSaved, item, asChild) {
+  if (!asChild) return isSaved ? "Remove saved item" : "Save item";
+  const title = getMetaTitle(item.meta);
+  const subject = title ? `${item.targetType ?? "item"}: ${title}` : item.targetType ?? "item";
+  return `${isSaved ? "Remove" : "Save"} ${subject}`;
+}
+function getMetaTitle(meta) {
+  if (typeof meta !== "object" || meta === null || !("title" in meta)) return void 0;
+  const title = meta.title;
+  return typeof title === "string" && title.trim() ? title.trim() : void 0;
 }
 
 // src/createKeepKit.tsx
@@ -1037,57 +931,19 @@ function createKeepKit(options = {}) {
     KeepButton: (props) => /* @__PURE__ */ jsx3(KeepButton, { ...props }),
     useKeepContext: () => useKeepContext(),
     useKeepItem: (id, itemPayload) => useKeepItem(id, itemPayload),
-    useKeepList: (options2) => useKeepList(options2)
-  };
-}
-
-// src/integrations.ts
-function createKeepInvalidationPlugin(options) {
-  return {
-    name: options.name ?? "keepkit-cache-invalidation",
-    after: async (context) => {
-      const keys = typeof options.queryKeys === "function" ? options.queryKeys(context) : [options.queryKeys];
-      await Promise.all(keys.map((queryKey) => options.invalidate(queryKey, context)));
-    }
+    useKeepList: (options2) => useKeepList(options2),
+    useKeepShortcut: (shortcutOptions) => useKeepShortcut(shortcutOptions)
   };
 }
 export {
-  DEFAULT_INDEXEDDB_DATABASE,
-  DEFAULT_INDEXEDDB_STORE,
-  DEFAULT_STORAGE_KEY,
-  DEFAULT_SYNC_QUEUE_DATABASE,
-  DEFAULT_SYNC_QUEUE_KEY,
-  DEFAULT_SYNC_QUEUE_STORE,
-  IndexedDBAdapter,
-  IndexedDBSyncQueueAdapter,
-  KEEP_BACKUP_FORMAT,
-  KEEP_BACKUP_VERSION,
-  KeepBackupImportError,
-  KeepBackupParseError,
   KeepButton,
   KeepProvider,
-  KeepSchemaValidationError,
-  KeepStorageAccessError,
-  KeepStorageError,
-  KeepStorageParseError,
-  KeepStorageQuotaError,
-  LocalStorageAdapter,
-  LocalStorageSyncQueueAdapter,
-  SyncStorageAdapter,
-  createKeepInvalidationPlugin,
   createKeepKit,
-  createStorageAdapter,
-  exportItems,
-  getTagCounts,
-  importItems,
-  mergeKeepItems,
-  migrateKeepItems,
-  normalizeKeepTags,
-  parseKeepMeta,
-  queryKeepItems,
+  isKeepItemMetadataStale,
   useKeepContext,
   useKeepItem,
   useKeepList,
-  validateKeepItem
+  useKeepShortcut,
+  useKeepStore
 };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=react.js.map