@keepkit/core 0.10.0 → 0.12.0

package/dist/react.js

@@ -6,15 +6,14 @@ import {
   isKeepItemMetadataStale,
   queryKeepItems,
   revalidateKeepItems
-} from "./chunk-XF5VI6O5.js";
+} from "./chunk-MDTL5L64.js";
 import {
   parseKeepMeta
 } from "./chunk-THZ3ACR2.js";
-import "./chunk-5QSZP6MT.js";
 import {
   createBrowserStorageAdapter,
   normalizeKeepTags
-} from "./chunk-EXE4E3GA.js";
+} from "./chunk-VJDO3GFH.js";
 
 // src/hooks/useKeepItem.ts
 import { useCallback as useCallback3 } from "react";
@@ -69,6 +68,7 @@ function KeepProvider({
   onNoteUpdate,
   onTagsUpdate,
   onChange,
+  onUndo,
   onError,
   plugins = [],
   schemaVersion,
@@ -81,6 +81,8 @@ function KeepProvider({
   boundaryResetKey,
   validateItem,
   resolveItem,
+  autoRevalidation,
+  undoTimeoutMs,
   children
 }) {
   const content = /* @__PURE__ */ jsx(
@@ -93,6 +95,7 @@ function KeepProvider({
       onNoteUpdate,
       onTagsUpdate,
       onChange,
+      onUndo,
       onError,
       plugins,
       schemaVersion,
@@ -102,6 +105,8 @@ function KeepProvider({
       migrateMeta,
       validateItem,
       resolveItem,
+      autoRevalidation,
+      undoTimeoutMs,
       children
     }
   );
@@ -116,6 +121,7 @@ function KeepProviderContent({
   onNoteUpdate,
   onTagsUpdate,
   onChange,
+  onUndo,
   onError,
   plugins = [],
   schemaVersion,
@@ -125,6 +131,8 @@ function KeepProviderContent({
   migrateMeta,
   validateItem,
   resolveItem,
+  autoRevalidation,
+  undoTimeoutMs = 5e3,
   children
 }) {
   const storeRef = useRef(null);
@@ -135,17 +143,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,
@@ -157,6 +167,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(
@@ -257,6 +271,16 @@ function KeepProviderContent({
     if (!storage.subscribe) return;
     return storage.subscribe(() => void refresh());
   }, [refresh, storage]);
+  useEffect(() => {
+    if (!isScopeAwareStorage(storage)) return;
+    return storage.subscribeScope(() => {
+      undoRef.current?.timer && clearTimeout(undoRef.current.timer);
+      undoRef.current = void 0;
+      itemsRef.current = [];
+      store.setState({ items: [], isHydrated: false, isLoading: true, error: null, undo: EMPTY_UNDO_STATE });
+      void refresh();
+    });
+  }, [refresh, storage, store]);
   const runMutation = useCallback(
     (action, id, createPlan) => {
       pendingMutationsRef.current += 1;
@@ -474,6 +498,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: [],
@@ -544,6 +631,27 @@ function KeepProviderContent({
       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)) {
@@ -557,6 +665,15 @@ function KeepProviderContent({
     [revalidateItems]
   );
   const flushSync = useCallback(() => syncStorage ? syncStorage.flushSync() : Promise.resolve(), [syncStorage]);
+  const resolveSyncConflict = useCallback(
+    (id, resolution, item) => {
+      if (!syncStorage?.resolveSyncConflict) {
+        return Promise.reject(new Error("The configured storage does not support sync conflict resolution."));
+      }
+      return syncStorage.resolveSyncConflict(id, resolution, item);
+    },
+    [syncStorage]
+  );
   const exportBackup = useCallback(() => exportItems(storage), [storage]);
   const importBackup = useCallback(
     async (data, options = {}) => {
@@ -594,6 +711,7 @@ function KeepProviderContent({
       error,
       lastChange,
       syncState,
+      undo,
       saveItem,
       updateNote,
       updateTags,
@@ -602,9 +720,13 @@ function KeepProviderContent({
       removeTagsBatch,
       removeItem,
       removeItems,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval,
       clear,
       refresh,
       flushSync,
+      resolveSyncConflict,
       refreshItemMetadata,
       revalidateItems,
       exportBackup,
@@ -615,14 +737,19 @@ function KeepProviderContent({
       error,
       lastChange,
       flushSync,
+      resolveSyncConflict,
       isHydrated,
       isLoading,
       isMutating,
       items,
       syncState,
+      undo,
       refresh,
       removeItem,
       saveItem,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval,
       updateNote,
       updateTags,
       updateTagsBatch,
@@ -645,6 +772,9 @@ function KeepProviderContent({
       removeTagsBatch,
       removeItem,
       removeItems,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval,
       clear,
       refresh,
       refreshItemMetadata,
@@ -662,7 +792,10 @@ function KeepProviderContent({
       updateTags,
       updateTagsBatch,
       refreshItemMetadata,
-      revalidateItems
+      revalidateItems,
+      removeItemWithUndo,
+      removeItemsWithUndo,
+      undoLastRemoval
     ]
   );
   const storeAccess = useMemo(() => ({ store, actions }), [actions, store]);
@@ -671,11 +804,16 @@ function KeepProviderContent({
 var IDLE_SYNC_STATE = Object.freeze({
   status: "idle",
   pendingCount: 0,
-  conflictIds: []
+  conflictIds: [],
+  conflicts: []
 });
+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";
 }
+function isScopeAwareStorage(storage) {
+  return "subscribeScope" in storage && typeof storage.subscribeScope === "function";
+}
 async function parseKeepMetaItem(item, schema) {
   return { ...item, meta: await parseKeepMeta(schema, item.meta) };
 }
@@ -745,6 +883,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]);
@@ -760,6 +899,8 @@ function useKeepItem(input) {
     error,
     save,
     remove,
+    removeWithUndo,
+    undo: actions.undoLastRemoval,
     toggle,
     updateNote,
     updateTags,
@@ -814,6 +955,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]
@@ -841,6 +984,8 @@ function useKeepList(query = {}) {
     error,
     remove,
     removeBatch,
+    removeWithUndo,
+    removeBatchWithUndo,
     updateTagsBatch,
     addTagsBatch,
     removeTagsBatch,