@keepkit/core 0.9.0 → 0.11.0

package/dist/react.js

@@ -1,10 +1,12 @@
 "use client";
 import {
   KeepStore,
+  exportItems,
+  importItems,
   isKeepItemMetadataStale,
   queryKeepItems,
   revalidateKeepItems
-} from "./chunk-AWQWKK4V.js";
+} from "./chunk-MDTL5L64.js";
 import {
   parseKeepMeta
 } from "./chunk-THZ3ACR2.js";
@@ -12,7 +14,7 @@ import "./chunk-5QSZP6MT.js";
 import {
   createBrowserStorageAdapter,
   normalizeKeepTags
-} from "./chunk-DBRHZ6XU.js";
+} from "./chunk-36YIELZE.js";
 
 // src/hooks/useKeepItem.ts
 import { useCallback as useCallback3 } from "react";
@@ -67,6 +69,7 @@ function KeepProvider({
   onNoteUpdate,
   onTagsUpdate,
   onChange,
+  onUndo,
   onError,
   plugins = [],
   schemaVersion,
@@ -77,6 +80,10 @@ function KeepProvider({
   fallback,
   onBoundaryError,
   boundaryResetKey,
+  validateItem,
+  resolveItem,
+  autoRevalidation,
+  undoTimeoutMs,
   children
 }) {
   const content = /* @__PURE__ */ jsx(
@@ -89,6 +96,7 @@ function KeepProvider({
       onNoteUpdate,
       onTagsUpdate,
       onChange,
+      onUndo,
       onError,
       plugins,
       schemaVersion,
@@ -96,6 +104,10 @@ function KeepProvider({
       invalidItemPolicy,
       onInvalidItem,
       migrateMeta,
+      validateItem,
+      resolveItem,
+      autoRevalidation,
+      undoTimeoutMs,
       children
     }
   );
@@ -110,6 +122,7 @@ function KeepProviderContent({
   onNoteUpdate,
   onTagsUpdate,
   onChange,
+  onUndo,
   onError,
   plugins = [],
   schemaVersion,
@@ -117,6 +130,10 @@ function KeepProviderContent({
   invalidItemPolicy = "error",
   onInvalidItem,
   migrateMeta,
+  validateItem,
+  resolveItem,
+  autoRevalidation,
+  undoTimeoutMs = 5e3,
   children
 }) {
   const storeRef = useRef(null);
@@ -127,17 +144,19 @@ function KeepProviderContent({
       isHydrated: false,
       isMutating: false,
       error: null,
-      lastChange: void 0
+      lastChange: void 0,
+      undo: { canUndo: false, ids: [] }
     });
   }
   const store = storeRef.current;
   const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
-  const { items, isLoading, isHydrated, isMutating, error, lastChange } = state;
+  const { items, isLoading, isHydrated, isMutating, error, lastChange, undo: storedUndo } = state;
+  const undo = storedUndo ?? EMPTY_UNDO_STATE;
   const itemsRef = useRef(items);
   const pluginsRef = useRef(plugins);
   pluginsRef.current = plugins;
-  const handlersRef = useRef({ onSave, onRemove, onNoteUpdate, onTagsUpdate, onChange, onError });
-  handlersRef.current = { onSave, onRemove, onNoteUpdate, onTagsUpdate, onChange, onError };
+  const handlersRef = useRef({ onSave, onRemove, onNoteUpdate, onTagsUpdate, onChange, onUndo, onError });
+  handlersRef.current = { onSave, onRemove, onNoteUpdate, onTagsUpdate, onChange, onUndo, onError };
   const migrationRef = useRef({
     schemaVersion,
     migrateMeta,
@@ -149,6 +168,10 @@ function KeepProviderContent({
   const operationTailRef = useRef(Promise.resolve());
   const pendingRefreshesRef = useRef(0);
   const pendingMutationsRef = useRef(0);
+  const undoRef = useRef(void 0);
+  const autoRevalidationRef = useRef(autoRevalidation);
+  autoRevalidationRef.current = autoRevalidation;
+  const didMountRevalidateRef = useRef(false);
   const syncStorage = isSyncCapableStorage(storage) ? storage : void 0;
   const getSyncState = useCallback(() => syncStorage?.getSyncState() ?? IDLE_SYNC_STATE, [syncStorage]);
   const subscribeSync = useCallback(
@@ -466,6 +489,69 @@ function KeepProviderContent({
     },
     [runMutation, storage]
   );
+  const rememberUndo = useCallback(
+    (removedItems) => {
+      undoRef.current?.timer && clearTimeout(undoRef.current.timer);
+      const expiresAt = Date.now() + Math.max(0, undoTimeoutMs);
+      const timer = setTimeout(
+        () => {
+          undoRef.current = void 0;
+          store.setState({ undo: { canUndo: false, ids: [] } });
+        },
+        Math.max(0, undoTimeoutMs)
+      );
+      undoRef.current = { items: removedItems, expiresAt, timer };
+      store.setState({ undo: { canUndo: true, ids: removedItems.map((item) => item.id), expiresAt } });
+    },
+    [store, undoTimeoutMs]
+  );
+  const removeItemWithUndo = useCallback(
+    async (id) => {
+      const item = itemsRef.current.find((current) => current.id === id);
+      await removeItem(id);
+      if (item) rememberUndo([item]);
+    },
+    [rememberUndo, removeItem]
+  );
+  const removeItemsWithUndo = useCallback(
+    async (ids) => {
+      const idSet = new Set(ids);
+      const removedItems = itemsRef.current.filter((item) => idSet.has(item.id));
+      await removeItems(ids);
+      if (removedItems.length > 0) rememberUndo(removedItems);
+    },
+    [rememberUndo, removeItems]
+  );
+  const undoLastRemoval = useCallback(async () => {
+    const pending = undoRef.current;
+    if (!pending || pending.expiresAt < Date.now()) {
+      undoRef.current = void 0;
+      store.setState({ undo: { canUndo: false, ids: [] } });
+      return;
+    }
+    if (pending.timer) clearTimeout(pending.timer);
+    undoRef.current = void 0;
+    store.setState({ undo: { canUndo: false, ids: [] } });
+    await runMutation("undo", void 0, (previous) => {
+      const restored = new Map(pending.items.map((item) => [item.id, item]));
+      const next = [...previous.filter((item) => !restored.has(item.id)), ...pending.items].sort(
+        (a, b) => b.updatedAt - a.updatedAt
+      );
+      return {
+        next,
+        persist: async () => {
+          if (storage.setMany) await storage.setMany(pending.items);
+          else for (const item of pending.items) await storage.set(item);
+        },
+        onSuccess: () => handlersRef.current.onUndo?.(pending.items),
+        pluginContext: { action: "undo", items: pending.items }
+      };
+    });
+  }, [runMutation, storage, store]);
+  useEffect(() => {
+    if (syncState.status !== "error" || !undoRef.current) return;
+    void undoLastRemoval();
+  }, [syncState.status, undoLastRemoval]);
   const clear = useCallback(
     () => runMutation("clear", void 0, (_previous) => ({
       next: [],
@@ -482,7 +568,13 @@ function KeepProviderContent({
         const previous = itemsRef.current;
         let persistenceStarted = false;
         try {
-          const summary = await revalidateKeepItems(previous, revalidator, options);
+          const activeRevalidator = revalidator ?? validateItem;
+          if (!activeRevalidator)
+            throw new Error("KeepProvider.revalidateItems requires a revalidator or validateItem.");
+          const summary = await revalidateKeepItems(previous, activeRevalidator, {
+            ...options,
+            resolveItem: options.resolveItem ?? resolveItem
+          });
           const pluginContext = { action: "revalidate", items: summary.updatedItems };
           await runBeforePlugins(pluginContext);
           if (summary.updatedItems.length > 0) {
@@ -518,8 +610,39 @@ function KeepProviderContent({
         if (pendingMutationsRef.current === 0) store.setState({ isMutating: false });
       });
     },
-    [enqueueOperation, reportError, runAfterPlugins, runBeforePlugins, setItems, storage, store]
+    [
+      enqueueOperation,
+      reportError,
+      resolveItem,
+      runAfterPlugins,
+      runBeforePlugins,
+      setItems,
+      storage,
+      store,
+      validateItem
+    ]
   );
+  useEffect(() => {
+    const settings = autoRevalidationRef.current;
+    const activeRevalidator = settings?.revalidator ?? validateItem;
+    if (!settings || !activeRevalidator) return;
+    const run = () => void revalidateItems(activeRevalidator, { removeStatuses: settings.removeStatuses }).catch(() => void 0);
+    if (isHydrated && settings.onMount !== false && !didMountRevalidateRef.current) {
+      didMountRevalidateRef.current = true;
+      run();
+    }
+    const interval = settings.intervalMs && settings.intervalMs > 0 ? setInterval(run, settings.intervalMs) : void 0;
+    const onOnline = () => {
+      if (settings.onReconnect !== false) run();
+    };
+    if (typeof window !== "undefined" && settings.onReconnect !== false) {
+      window.addEventListener("online", onOnline);
+    }
+    return () => {
+      if (interval) clearInterval(interval);
+      if (typeof window !== "undefined") window.removeEventListener("online", onOnline);
+    };
+  }, [isHydrated, revalidateItems, validateItem]);
   const refreshItemMetadata = useCallback(
     async (id, refresh2) => {
       if (!itemsRef.current.some((item) => item.id === id)) {
@@ -533,6 +656,34 @@ function KeepProviderContent({
     [revalidateItems]
   );
   const flushSync = useCallback(() => syncStorage ? syncStorage.flushSync() : Promise.resolve(), [syncStorage]);
+  const exportBackup = useCallback(() => exportItems(storage), [storage]);
+  const importBackup = useCallback(
+    async (data, options = {}) => {
+      pendingMutationsRef.current += 1;
+      store.setState({ isMutating: true });
+      const run = enqueueOperation(async () => {
+        try {
+          const result = await importItems(storage, data, {
+            ...options,
+            schema: migrationRef.current.schema,
+            invalidItemPolicy: options.invalidItemPolicy ?? migrationRef.current.invalidItemPolicy,
+            onInvalidItem: options.onInvalidItem ?? migrationRef.current.onInvalidItem
+          });
+          setItems(result.items);
+          store.setState({ error: null });
+          return result;
+        } catch (cause) {
+          reportError(cause, { action: "import" });
+          throw cause;
+        }
+      });
+      return run.finally(() => {
+        pendingMutationsRef.current -= 1;
+        if (pendingMutationsRef.current === 0) store.setState({ isMutating: false });
+      });
+    },
+    [enqueueOperation, reportError, setItems, storage, store]
+  );
   const value = useMemo(
     () => ({
       items,
@@ -542,6 +693,7 @@ function KeepProviderContent({
       error,
       lastChange,
       syncState,
+      undo,
       saveItem,
       updateNote,
       updateTags,
@@ -550,11 +702,16 @@ function KeepProviderContent({
       removeTagsBatch,
       removeItem,
       removeItems,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval,
       clear,
       refresh,
       flushSync,
       refreshItemMetadata,
-      revalidateItems
+      revalidateItems,
+      exportBackup,
+      importBackup
     }),
     [
       clear,
@@ -566,9 +723,13 @@ function KeepProviderContent({
       isMutating,
       items,
       syncState,
+      undo,
       refresh,
       removeItem,
       saveItem,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval,
       updateNote,
       updateTags,
       updateTagsBatch,
@@ -576,7 +737,9 @@ function KeepProviderContent({
       removeTagsBatch,
       removeItems,
       refreshItemMetadata,
-      revalidateItems
+      revalidateItems,
+      exportBackup,
+      importBackup
     ]
   );
   const actions = useMemo(
@@ -589,6 +752,9 @@ function KeepProviderContent({
       removeTagsBatch,
       removeItem,
       removeItems,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval,
       clear,
       refresh,
       refreshItemMetadata,
@@ -606,7 +772,10 @@ function KeepProviderContent({
       updateTags,
       updateTagsBatch,
       refreshItemMetadata,
-      revalidateItems
+      revalidateItems,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval
     ]
   );
   const storeAccess = useMemo(() => ({ store, actions }), [actions, store]);
@@ -617,6 +786,7 @@ var IDLE_SYNC_STATE = Object.freeze({
   pendingCount: 0,
   conflictIds: []
 });
+var EMPTY_UNDO_STATE = Object.freeze({ canUndo: false, ids: [] });
 function isSyncCapableStorage(storage) {
   return "getSyncState" in storage && typeof storage.getSyncState === "function" && "subscribeSync" in storage && typeof storage.subscribeSync === "function" && "flushSync" in storage && typeof storage.flushSync === "function";
 }
@@ -689,6 +859,7 @@ function useKeepItem(input) {
     });
   }, [actions, input, item?.savedAt]);
   const remove = useCallback3(() => actions.removeItem(id), [actions, id]);
+  const removeWithUndo = useCallback3(() => actions.removeItemWithUndo(id), [actions, id]);
   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]);
@@ -704,6 +875,8 @@ function useKeepItem(input) {
     error,
     save,
     remove,
+    removeWithUndo,
+    undo: actions.undoLastRemoval,
     toggle,
     updateNote,
     updateTags,
@@ -758,6 +931,8 @@ function useKeepList(query = {}) {
   const allTags = useKeepStoreSelector(store, tagsSelector);
   const remove = useCallback4((id) => actions.removeItem(id), [actions]);
   const removeBatch = useCallback4((ids) => actions.removeItems(ids), [actions]);
+  const removeWithUndo = useCallback4((id) => actions.removeItemWithUndo(id), [actions]);
+  const removeBatchWithUndo = useCallback4((ids) => actions.removeItemsWithUndo(ids), [actions]);
   const updateTagsBatch = useCallback4(
     (ids, nextTags) => actions.updateTagsBatch(ids, nextTags),
     [actions]
@@ -785,6 +960,8 @@ function useKeepList(query = {}) {
     error,
     remove,
     removeBatch,
+    removeWithUndo,
+    removeBatchWithUndo,
     updateTagsBatch,
     addTagsBatch,
     removeTagsBatch,