@buoy-gg/react-query 1.7.2

package/lib/commonjs/react-query/utils/actions/deleteItem.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = deleteItem;
+var _deleteNestedDataByPath = require("../deleteNestedDataByPath");
+function deleteItem({
+  activeQuery,
+  dataPath,
+  queryClient
+}) {
+  if (!dataPath) {
+    // Early return if path is missing
+    return;
+  }
+  const oldData = activeQuery.state.data;
+  const newData = (0, _deleteNestedDataByPath.deleteNestedDataByPath)(oldData, dataPath);
+
+  // Force a new object reference to ensure React detects the change
+  const forceNewReference = JSON.parse(JSON.stringify(newData));
+  queryClient.setQueryData(activeQuery.queryKey, forceNewReference);
+}

package/lib/commonjs/react-query/utils/actions/invalidate.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = invalidate;
+function invalidate({
+  query,
+  queryClient
+}) {
+  // This matches the ACTION-INVALIDATE case from the external sync system
+  queryClient.invalidateQueries(query);
+}

package/lib/commonjs/react-query/utils/actions/refetch.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = refetch;
+function refetch({
+  query
+}) {
+  // This matches the ACTION-REFETCH case from the external sync system
+  const promise = query.fetch();
+  promise.catch(() => {
+    // Silently handle fetch errors
+  });
+}

package/lib/commonjs/react-query/utils/actions/remove.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = remove;
+function remove({
+  query,
+  queryClient
+}) {
+  queryClient.removeQueries(query);
+}

package/lib/commonjs/react-query/utils/actions/reset.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = reset;
+function reset({
+  query,
+  queryClient
+}) {
+  queryClient.resetQueries({
+    queryKey: query.queryKey,
+    exact: true
+  });
+}

package/lib/commonjs/react-query/utils/actions/triggerError.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = triggerError;
+function triggerError({
+  query,
+  queryClient
+}) {
+  if (query.state.status !== "error") {
+    // --ACTION-TRIGGER-ERROR logic--
+    // This matches the ACTION-TRIGGER-ERROR case from the external sync system
+    const error = new Error("Unknown error from devtools");
+    const __previousQueryOptions = query.options;
+    query.setState({
+      status: "error",
+      error,
+      fetchMeta: {
+        ...query.state.fetchMeta,
+        // @ts-expect-error This does exist
+        __previousQueryOptions
+      }
+    });
+  } else {
+    // --ACTION-RESTORE-ERROR logic--
+    // This matches the ACTION-RESTORE-ERROR case from the external sync system
+    queryClient.resetQueries(query);
+  }
+}

package/lib/commonjs/react-query/utils/actions/triggerLoading.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = triggerLoading;
+function triggerLoading({
+  query
+}) {
+  if (query.state.data === undefined) {
+    // --ACTION-RESTORE-LOADING logic--
+    // This matches the ACTION-RESTORE-LOADING case from the external sync system
+    const previousState = query.state;
+    const previousOptions = query.state.fetchMeta ? query.state.fetchMeta.__previousQueryOptions : null;
+    query.cancel({
+      silent: true
+    });
+    query.setState({
+      ...previousState,
+      fetchStatus: "idle",
+      fetchMeta: null
+    });
+    if (previousOptions) {
+      query.fetch(previousOptions);
+    }
+  } else {
+    // --ACTION-TRIGGER-LOADING logic--
+    // This matches the ACTION-TRIGGER-LOADING case from the external sync system
+    const __previousQueryOptions = query.options;
+
+    // Trigger a fetch in order to trigger suspense as well.
+    query.fetch({
+      ...__previousQueryOptions,
+      queryFn: () => {
+        return new Promise(() => {
+          // Never resolve - simulates perpetual loading
+        });
+      },
+      gcTime: -1
+    });
+    query.setState({
+      data: undefined,
+      status: "pending",
+      fetchMeta: {
+        ...query.state.fetchMeta,
+        // @ts-expect-error This does exist
+        __previousQueryOptions
+      }
+    });
+  }
+}

package/lib/commonjs/react-query/utils/deleteNestedDataByPath.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deleteNestedDataByPath = void 0;
+/**
+ * Deletes nested data by path
+ *
+ * @param {unknown} oldData Data to be updated
+ * @param {Array<string>} deletePath Path to the data to be deleted
+ * @returns newData without the deleted items by path
+ */
+const deleteNestedDataByPath = (oldData, deletePath) => {
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (deletePath.length === 1) {
+      newData.delete(deletePath[0]);
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
+    return new Set(setAsArray);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (deletePath.length === 1) {
+      return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
+    }
+    const [head, ...tail] = deletePath;
+
+    // @ts-expect-error NAS
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = {
+      ...oldData
+    };
+    if (deletePath.length === 1) {
+      // @ts-expect-error NAS
+      delete newData[deletePath[0]];
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    // @ts-expect-error NAS
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  return oldData;
+};
+exports.deleteNestedDataByPath = deleteNestedDataByPath;

package/lib/commonjs/react-query/utils/formatRelativeTime.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatRelativeTime = formatRelativeTime;
+/**
+ * Formats a timestamp as a relative time string (e.g., "10s ago", "5m ago", "2h ago")
+ * @param timestamp - Unix timestamp in milliseconds
+ * @returns Formatted relative time string
+ */
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const seconds = Math.floor(diff / 1000);
+  if (seconds < 60) {
+    return `${seconds}s ago`;
+  }
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m ago`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h ago`;
+  }
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}

package/lib/commonjs/react-query/utils/getQueryStatusColor.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getQueryStatusColor = getQueryStatusColor;
+/**
+ * Maps a query’s runtime state to one of the predefined status color tokens used in the UI.
+ */
+function getQueryStatusColor({
+  queryState,
+  observerCount,
+  isStale
+}) {
+  return queryState.fetchStatus === "fetching" ? "blue" : !observerCount ? "gray" : queryState.fetchStatus === "paused" ? "purple" : isStale ? "yellow" : "green";
+}

package/lib/commonjs/react-query/utils/getQueryStatusLabel.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getQueryStatusLabel = getQueryStatusLabel;
+/**
+ * Converts a query object into a human-friendly status string for badge rendering.
+ * Priority order: disabled > fetching > inactive > paused > stale > fresh
+ */
+function getQueryStatusLabel(query) {
+  // Check disabled first - disabled queries won't automatically fetch
+  if (query.isDisabled()) {
+    return "disabled";
+  }
+  return query.state.fetchStatus === "fetching" ? "fetching" : !query.getObserversCount() ? "inactive" : query.state.fetchStatus === "paused" ? "paused" : query.isStale() ? "stale" : "fresh";
+}

package/lib/commonjs/react-query/utils/getStorageQueryCounts.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStorageQueryCounts = getStorageQueryCounts;
+var _storageQueryUtils = require("./storageQueryUtils");
+var _sharedUi = require("@buoy-gg/shared-ui");
+/**
+ * Calculate counts for each storage type from storage queries
+ * Following performance principles: no unnecessary memoization [[memory:4875074]]
+ */
+function getStorageQueryCounts(queries) {
+  const counts = {
+    mmkv: 0,
+    async: 0,
+    secure: 0,
+    total: 0
+  };
+
+  // Filter to storage queries only, then count by type
+  const storageQueries = queries.filter(query => (0, _storageQueryUtils.isStorageQuery)(query.queryKey));
+  storageQueries.forEach(query => {
+    const storageType = (0, _storageQueryUtils.getStorageType)(query.queryKey);
+    if (storageType) {
+      // Filter out dev tool keys from the counts
+      const cleanKey = (0, _storageQueryUtils.getCleanStorageKey)(query.queryKey);
+      if (!(0, _sharedUi.isDevToolsStorageKey)(cleanKey)) {
+        counts[storageType]++;
+        counts.total++;
+      }
+    }
+  });
+  return counts;
+}

package/lib/commonjs/react-query/utils/index.js

@@ -0,0 +1,170 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  invalidate: true,
+  refetch: true,
+  reset: true,
+  remove: true,
+  deleteItem: true,
+  triggerError: true,
+  triggerLoading: true,
+  safeStringify: true,
+  displayValue: true,
+  parseDisplayValue: true
+};
+Object.defineProperty(exports, "deleteItem", {
+  enumerable: true,
+  get: function () {
+    return _deleteItem.default;
+  }
+});
+Object.defineProperty(exports, "displayValue", {
+  enumerable: true,
+  get: function () {
+    return _sharedUi.displayValue;
+  }
+});
+Object.defineProperty(exports, "invalidate", {
+  enumerable: true,
+  get: function () {
+    return _invalidate.default;
+  }
+});
+Object.defineProperty(exports, "parseDisplayValue", {
+  enumerable: true,
+  get: function () {
+    return _sharedUi.parseDisplayValue;
+  }
+});
+Object.defineProperty(exports, "refetch", {
+  enumerable: true,
+  get: function () {
+    return _refetch.default;
+  }
+});
+Object.defineProperty(exports, "remove", {
+  enumerable: true,
+  get: function () {
+    return _remove.default;
+  }
+});
+Object.defineProperty(exports, "reset", {
+  enumerable: true,
+  get: function () {
+    return _reset.default;
+  }
+});
+Object.defineProperty(exports, "safeStringify", {
+  enumerable: true,
+  get: function () {
+    return _sharedUi.safeStringify;
+  }
+});
+Object.defineProperty(exports, "triggerError", {
+  enumerable: true,
+  get: function () {
+    return _triggerError.default;
+  }
+});
+Object.defineProperty(exports, "triggerLoading", {
+  enumerable: true,
+  get: function () {
+    return _triggerLoading.default;
+  }
+});
+var _invalidate = _interopRequireDefault(require("./actions/invalidate"));
+var _refetch = _interopRequireDefault(require("./actions/refetch"));
+var _reset = _interopRequireDefault(require("./actions/reset"));
+var _remove = _interopRequireDefault(require("./actions/remove"));
+var _deleteItem = _interopRequireDefault(require("./actions/deleteItem"));
+var _triggerError = _interopRequireDefault(require("./actions/triggerError"));
+var _triggerLoading = _interopRequireDefault(require("./actions/triggerLoading"));
+var _getQueryStatusLabel = require("./getQueryStatusLabel");
+Object.keys(_getQueryStatusLabel).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getQueryStatusLabel[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getQueryStatusLabel[key];
+    }
+  });
+});
+var _getQueryStatusColor = require("./getQueryStatusColor");
+Object.keys(_getQueryStatusColor).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getQueryStatusColor[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getQueryStatusColor[key];
+    }
+  });
+});
+var _getStorageQueryCounts = require("./getStorageQueryCounts");
+Object.keys(_getStorageQueryCounts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getStorageQueryCounts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getStorageQueryCounts[key];
+    }
+  });
+});
+var _storageQueryUtils = require("./storageQueryUtils");
+Object.keys(_storageQueryUtils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _storageQueryUtils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _storageQueryUtils[key];
+    }
+  });
+});
+var _modalStorageOperations = require("./modalStorageOperations");
+Object.keys(_modalStorageOperations).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _modalStorageOperations[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _modalStorageOperations[key];
+    }
+  });
+});
+var _updateNestedDataByPath = require("./updateNestedDataByPath");
+Object.keys(_updateNestedDataByPath).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _updateNestedDataByPath[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _updateNestedDataByPath[key];
+    }
+  });
+});
+var _deleteNestedDataByPath = require("./deleteNestedDataByPath");
+Object.keys(_deleteNestedDataByPath).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _deleteNestedDataByPath[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _deleteNestedDataByPath[key];
+    }
+  });
+});
+var _sharedUi = require("@buoy-gg/shared-ui");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/lib/commonjs/react-query/utils/modalStorageOperations.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.savePanelHeight = exports.savePanelDimensions = exports.saveModalVisibilityState = exports.saveFloatingMode = exports.loadPanelState = exports.loadModalVisibilityState = exports.clearModalVisibilityState = void 0;
+var _sharedUi = require("@buoy-gg/shared-ui");
+// Helper functions for persisting panel state using shared storage wrapper
+const setItem = async (key, value) => {
+  await (0, _sharedUi.safeSetItem)(key, value);
+};
+const getItem = async key => {
+  return (0, _sharedUi.safeGetItem)(key);
+};
+// Storage operations
+/**
+ * Persist the draggable panel dimensions so future sessions can restore the last window size.
+ */
+const savePanelDimensions = async (storagePrefix, dimensions) => {
+  try {
+    await setItem(`${storagePrefix}_panel_dimensions`, JSON.stringify(dimensions));
+  } catch {
+    // Silently fail - persistence is optional
+  }
+};
+
+/** Remember the last snap height of the panel for bottom-sheet style layouts. */
+exports.savePanelDimensions = savePanelDimensions;
+const savePanelHeight = async (storagePrefix, height) => {
+  try {
+    await setItem(`${storagePrefix}_panel_height`, height.toString());
+  } catch {
+    // Silently fail - persistence is optional
+  }
+};
+
+/**
+ * Persist whether the panel was in floating mode so we can reopen at the same presentation style.
+ */
+exports.savePanelHeight = savePanelHeight;
+const saveFloatingMode = async (storagePrefix, isFloating) => {
+  try {
+    await setItem(`${storagePrefix}_is_floating_mode`, isFloating.toString());
+  } catch {
+    // Silently fail - persistence is optional
+  }
+};
+
+/**
+ * Retrieve persisted panel geometry and presentation mode. Returns null values when nothing was
+ * previously stored so callers can fall back to defaults.
+ */
+exports.saveFloatingMode = saveFloatingMode;
+const loadPanelState = async storagePrefix => {
+  try {
+    const [dimensionsStr, heightStr, floatingModeStr] = await Promise.all([getItem(`${storagePrefix}_panel_dimensions`), getItem(`${storagePrefix}_panel_height`), getItem(`${storagePrefix}_is_floating_mode`)]);
+    const dimensions = dimensionsStr ? JSON.parse(dimensionsStr) : null;
+    const height = heightStr ? parseInt(heightStr, 10) : null;
+    const isFloating = floatingModeStr ? floatingModeStr === "true" : null;
+    return {
+      dimensions,
+      height,
+      isFloating
+    };
+  } catch {
+    // Return defaults on error
+    return {
+      dimensions: null,
+      height: null,
+      isFloating: null
+    };
+  }
+};
+
+// Modal visibility state operations
+/**
+ * Persist the comprehensive modal visibility state (open flags, selected query, etc.). Stored as a
+ * single JSON blob keyed by the provided prefix.
+ */
+exports.loadPanelState = loadPanelState;
+const saveModalVisibilityState = async (storagePrefix, state) => {
+  try {
+    const stateJson = JSON.stringify(state);
+    // storagePrefix already contains the full key, don't append _modal_state
+    const key = storagePrefix;
+    await setItem(key, stateJson);
+  } catch {
+    // Silently fail - persistence is a nice-to-have feature
+  }
+};
+
+/**
+ * Read previously persisted modal visibility state. Returns null when no entry is stored or the
+ * payload cannot be parsed.
+ */
+exports.saveModalVisibilityState = saveModalVisibilityState;
+const loadModalVisibilityState = async storagePrefix => {
+  try {
+    // storagePrefix already contains the full key, don't append _modal_state
+    const key = storagePrefix;
+    const stateStr = await getItem(key);
+    if (stateStr && stateStr !== "") {
+      const parsed = JSON.parse(stateStr);
+      return parsed;
+    }
+    return null;
+  } catch {
+    // Silently fail - persistence is a nice-to-have feature
+    return null;
+  }
+};
+
+/**
+ * Clear the cached modal visibility state. Useful when all modals close so we avoid reopening
+ * unintentionally on the next session.
+ */
+exports.loadModalVisibilityState = loadModalVisibilityState;
+const clearModalVisibilityState = async storagePrefix => {
+  try {
+    // storagePrefix already contains the full key, don't append _modal_state
+    const key = storagePrefix;
+    await setItem(key, "");
+  } catch {
+    // Silently fail - persistence is a nice-to-have feature
+  }
+};
+exports.clearModalVisibilityState = clearModalVisibilityState;