@medusajs/loyalty-plugin 0.0.1

package/.medusa/server/src/admin/hooks/api/gift-cards.js

@@ -0,0 +1,107 @@
+import { useQuery, useQueryClient, useMutation } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const giftCardQueryKey = queryKeysFactory("gift-card");
+const useGiftCards = (query, options) => {
+  const fetchGiftCards = (query2, headers) => sdk.client.fetch(`/admin/gift-cards`, {
+    query: query2,
+    headers
+  });
+  const { data, ...rest } = useQuery({
+    ...options,
+    queryFn: () => fetchGiftCards(query),
+    queryKey: giftCardQueryKey.list(query)
+  });
+  return { ...data, ...rest };
+};
+const useGiftCard = (id, query, options) => {
+  const fetchGiftCard = (id2, query2, headers) => sdk.client.fetch(`/admin/gift-cards/${id2}`, {
+    query: query2,
+    headers
+  });
+  const { data, ...rest } = useQuery({
+    queryFn: () => fetchGiftCard(id, query),
+    queryKey: giftCardQueryKey.detail(id),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+const useRedeemGiftCard = (id, options) => {
+  const queryClient = useQueryClient();
+  const redeemGiftCard = async (id2, body) => sdk.client.fetch(`/admin/gift-cards/${id2}/redeem`, {
+    body,
+    method: "POST"
+  });
+  return useMutation({
+    mutationFn: (body) => redeemGiftCard(id, body),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: giftCardQueryKey.lists() });
+      queryClient.invalidateQueries({ queryKey: giftCardQueryKey.detail(id) });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    }
+  });
+};
+const useTransferGiftCard = (id, options) => {
+  const queryClient = useQueryClient();
+  const transferGiftCard = async (id2, body) => sdk.client.fetch(
+    `/admin/gift-cards/${id2}/transfer`,
+    {
+      body,
+      method: "POST"
+    }
+  );
+  return useMutation({
+    mutationFn: (body) => transferGiftCard(id, body),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: giftCardQueryKey.lists() });
+      queryClient.invalidateQueries({ queryKey: giftCardQueryKey.detail(id) });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    }
+  });
+};
+const useUpdateGiftCard = (id, options) => {
+  const queryClient = useQueryClient();
+  const updateGiftCard = async (id2, body) => sdk.client.fetch(`/admin/gift-cards/${id2}`, {
+    body,
+    method: "POST"
+  });
+  return useMutation({
+    mutationFn: async (payload) => updateGiftCard(id, payload),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({
+        queryKey: giftCardQueryKey.detail(id)
+      });
+      queryClient.invalidateQueries({
+        queryKey: giftCardQueryKey.lists()
+      });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    },
+    ...options
+  });
+};
+const useDeleteGiftCard = (id, options) => {
+  const queryClient = useQueryClient();
+  const deleteGiftCard = async (id2) => sdk.client.fetch(`/admin/gift-cards/${id2}`, {
+    method: "DELETE"
+  });
+  return useMutation({
+    mutationFn: () => deleteGiftCard(id),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: giftCardQueryKey.lists() });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    }
+  });
+};
+export {
+  giftCardQueryKey,
+  useDeleteGiftCard,
+  useGiftCard,
+  useGiftCards,
+  useRedeemGiftCard,
+  useTransferGiftCard,
+  useUpdateGiftCard
+};

package/.medusa/server/src/admin/hooks/api/order.js

@@ -0,0 +1,16 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const ORDERS_QUERY_KEY = "orders";
+const orderQueryKeys = queryKeysFactory(ORDERS_QUERY_KEY);
+const useOrder = (id, query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: async () => sdk.admin.order.retrieve(id, query),
+    queryKey: orderQueryKeys.detail(id, query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  useOrder
+};

package/.medusa/server/src/admin/hooks/api/price-preferences.js

@@ -0,0 +1,19 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const PRICE_PREFERENCES_QUERY_KEY = "price-preferences";
+const pricePreferencesQueryKeys = queryKeysFactory(
+  PRICE_PREFERENCES_QUERY_KEY
+);
+const usePricePreferences = (query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.pricePreference.list(query),
+    queryKey: pricePreferencesQueryKeys.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  pricePreferencesQueryKeys,
+  usePricePreferences
+};

package/.medusa/server/src/admin/hooks/api/products.js

@@ -0,0 +1,127 @@
+import { useQuery, useQueryClient, useMutation } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const PRODUCTS_QUERY_KEY = "products";
+const productsQueryKeys = queryKeysFactory(PRODUCTS_QUERY_KEY);
+const VARIANTS_QUERY_KEY = "product_variants";
+const variantsQueryKeys = queryKeysFactory(VARIANTS_QUERY_KEY);
+const useProducts = (query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.product.list(query),
+    queryKey: productsQueryKeys.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+const useProduct = (id, query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.product.retrieve(id, query),
+    queryKey: productsQueryKeys.detail(id, query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+const useCreateProduct = (options) => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.create(payload),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    },
+    ...options
+  });
+};
+const useDeleteProduct = (id, options) => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () => sdk.admin.product.delete(id),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: productsQueryKeys.detail(id) });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    },
+    ...options
+  });
+};
+const useProductVariants = (productId, query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.product.listVariants(productId, query),
+    queryKey: variantsQueryKeys.list({ productId, ...query }),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+const useDeleteVariantLazy = (productId, options) => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ variantId }) => sdk.admin.product.deleteVariant(productId, variantId),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() });
+      queryClient.invalidateQueries({
+        queryKey: variantsQueryKeys.detail(variables.variantId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId)
+      });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    },
+    ...options
+  });
+};
+const useUpdateProduct = (id, options) => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.update(id, payload),
+    onSuccess: async (data, variables, context) => {
+      var _a;
+      await queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.lists()
+      });
+      await queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.details()
+      });
+      await queryClient.invalidateQueries({
+        queryKey: variantsQueryKeys.lists()
+      });
+      await queryClient.invalidateQueries({
+        queryKey: variantsQueryKeys.details()
+      });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    },
+    ...options
+  });
+};
+const useUpdateProductVariantsBatch = (productId, options) => {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (payload) => sdk.admin.product.batchVariants(productId, {
+      update: payload
+    }),
+    onSuccess: (data, variables, context) => {
+      var _a;
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.lists() });
+      queryClient.invalidateQueries({ queryKey: variantsQueryKeys.details() });
+      queryClient.invalidateQueries({
+        queryKey: productsQueryKeys.detail(productId)
+      });
+      (_a = options == null ? void 0 : options.onSuccess) == null ? void 0 : _a.call(options, data, variables, context);
+    },
+    ...options
+  });
+};
+export {
+  productsQueryKeys,
+  useCreateProduct,
+  useDeleteProduct,
+  useDeleteVariantLazy,
+  useProduct,
+  useProductVariants,
+  useProducts,
+  useUpdateProduct,
+  useUpdateProductVariantsBatch,
+  variantsQueryKeys
+};

package/.medusa/server/src/admin/hooks/api/regions.js

@@ -0,0 +1,17 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const REGIONS_QUERY_KEY = "regions";
+const regionsQueryKeys = queryKeysFactory(REGIONS_QUERY_KEY);
+const useRegions = (query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.region.list(query),
+    queryKey: regionsQueryKeys.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  regionsQueryKeys,
+  useRegions
+};

package/.medusa/server/src/admin/hooks/api/sales-channels.js

@@ -0,0 +1,28 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const SALES_CHANNELS_QUERY_KEY = "sales-channels";
+const salesChannelsQueryKeys = queryKeysFactory(
+  SALES_CHANNELS_QUERY_KEY
+);
+const useSalesChannel = (id, options) => {
+  const { data, ...rest } = useQuery({
+    queryKey: salesChannelsQueryKeys.detail(id),
+    queryFn: async () => sdk.admin.salesChannel.retrieve(id),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+const useSalesChannels = (query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => sdk.admin.salesChannel.list(query),
+    queryKey: salesChannelsQueryKeys.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  salesChannelsQueryKeys,
+  useSalesChannel,
+  useSalesChannels
+};

package/.medusa/server/src/admin/hooks/api/store-credit-accounts.js

@@ -0,0 +1,41 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const storeCreditAccountQueryKey = queryKeysFactory(
+  "store-credit-account"
+);
+const useStoreCreditAccounts = (query, options) => {
+  const fetchStoreCreditAccounts = (query2, headers) => sdk.client.fetch(
+    `/admin/store-credit-accounts`,
+    {
+      query: query2,
+      headers
+    }
+  );
+  const { data, ...rest } = useQuery({
+    queryFn: () => fetchStoreCreditAccounts(query),
+    queryKey: storeCreditAccountQueryKey.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+const useStoreCreditAccount = (id, query, options) => {
+  const fetchStoreCreditAccount = (query2, headers) => sdk.client.fetch(
+    `/admin/store-credit-accounts/${id}`,
+    {
+      query: query2,
+      headers
+    }
+  );
+  const { data, ...rest } = useQuery({
+    queryFn: () => fetchStoreCreditAccount(query),
+    queryKey: storeCreditAccountQueryKey.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  storeCreditAccountQueryKey,
+  useStoreCreditAccount,
+  useStoreCreditAccounts
+};

package/.medusa/server/src/admin/hooks/api/store.js

@@ -0,0 +1,31 @@
+import { FetchError } from "@medusajs/js-sdk";
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const STORE_QUERY_KEY = "store";
+const storeQueryKeys = queryKeysFactory(STORE_QUERY_KEY);
+async function retrieveActiveStore(query) {
+  var _a;
+  const response = await sdk.admin.store.list(query);
+  const activeStore = (_a = response.stores) == null ? void 0 : _a[0];
+  if (!activeStore) {
+    throw new FetchError("No active store found", "Not Found", 404);
+  }
+  return { store: activeStore };
+}
+const useStore = (query, options) => {
+  const { data, ...rest } = useQuery({
+    queryFn: () => retrieveActiveStore(query),
+    queryKey: storeQueryKeys.details(),
+    ...options
+  });
+  return {
+    ...data,
+    ...rest
+  };
+};
+export {
+  retrieveActiveStore,
+  storeQueryKeys,
+  useStore
+};

package/.medusa/server/src/admin/hooks/api/transaction-groups.js

@@ -0,0 +1,23 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const transactionGroupQueryKey = queryKeysFactory("transaction-group");
+const useTransactionGroups = (query, options) => {
+  const fetchTransactionGroups = (query2, headers) => sdk.client.fetch(
+    `/admin/transaction-groups`,
+    {
+      query: query2,
+      headers
+    }
+  );
+  const { data, ...rest } = useQuery({
+    queryFn: () => fetchTransactionGroups(query),
+    queryKey: transactionGroupQueryKey.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  transactionGroupQueryKey,
+  useTransactionGroups
+};

package/.medusa/server/src/admin/hooks/api/transactions.js

@@ -0,0 +1,23 @@
+import { useQuery } from "@tanstack/react-query";
+import { queryKeysFactory } from "../../lib/query-key.js";
+import { sdk } from "../../lib/sdk.js";
+const transactionQueryKey = queryKeysFactory("transaction");
+const useStoreCreditAccountTransactions = (id, query, options) => {
+  const fetchStoreCreditAccountTransactions = (query2, headers) => sdk.client.fetch(
+    `/admin/store-credit-accounts/${id}/transactions`,
+    {
+      query: query2,
+      headers
+    }
+  );
+  const { data, ...rest } = useQuery({
+    queryFn: () => fetchStoreCreditAccountTransactions(query),
+    queryKey: transactionQueryKey.list(query),
+    ...options
+  });
+  return { ...data, ...rest };
+};
+export {
+  transactionQueryKey,
+  useStoreCreditAccountTransactions
+};

package/.medusa/server/src/admin/hooks/commands/use-command-history.js

@@ -0,0 +1,45 @@
+import { useState, useCallback } from "react";
+const useCommandHistory = (maxHistory = 20) => {
+  const [past, setPast] = useState([]);
+  const [future, setFuture] = useState([]);
+  const canUndo = past.length > 0;
+  const canRedo = future.length > 0;
+  const undo = useCallback(() => {
+    if (!canUndo) {
+      return;
+    }
+    const previous = past[past.length - 1];
+    const newPast = past.slice(0, past.length - 1);
+    previous.undo();
+    setPast(newPast);
+    setFuture([previous, ...future.slice(0, maxHistory - 1)]);
+  }, [canUndo, future, past, maxHistory]);
+  const redo = useCallback(() => {
+    if (!canRedo) {
+      return;
+    }
+    const next = future[0];
+    const newFuture = future.slice(1);
+    next.redo();
+    setPast([...past, next].slice(0, maxHistory - 1));
+    setFuture(newFuture);
+  }, [canRedo, future, past, maxHistory]);
+  const execute = useCallback(
+    (command) => {
+      command.execute();
+      setPast((past2) => [...past2, command].slice(0, maxHistory - 1));
+      setFuture([]);
+    },
+    [maxHistory]
+  );
+  return {
+    undo,
+    redo,
+    execute,
+    canUndo,
+    canRedo
+  };
+};
+export {
+  useCommandHistory
+};

package/.medusa/server/src/admin/hooks/common/use-combobox-data.js

@@ -0,0 +1,59 @@
+import { useQuery, useInfiniteQuery, keepPreviousData } from "@tanstack/react-query";
+import { useDebouncedSearch } from "./use-debounced-search.js";
+const useComboboxData = ({
+  queryKey,
+  queryFn,
+  getOptions,
+  defaultValue,
+  defaultValueKey,
+  pageSize = 10
+}) => {
+  const { searchValue, onSearchValueChange, query } = useDebouncedSearch();
+  const queryInitialDataBy = defaultValueKey || "id";
+  const { data: initialData } = useQuery({
+    queryKey,
+    queryFn: async () => {
+      return queryFn({
+        [queryInitialDataBy]: defaultValue,
+        limit: Array.isArray(defaultValue) ? defaultValue.length : 1
+      });
+    },
+    enabled: !!defaultValue
+  });
+  const { data, ...rest } = useInfiniteQuery({
+    queryKey: [...queryKey, query],
+    queryFn: async ({ pageParam = 0 }) => {
+      return await queryFn({
+        q: query,
+        limit: pageSize,
+        offset: pageParam
+      });
+    },
+    initialPageParam: 0,
+    getNextPageParam: (lastPage) => {
+      const moreItemsExist = lastPage.count > lastPage.offset + lastPage.limit;
+      return moreItemsExist ? lastPage.offset + lastPage.limit : void 0;
+    },
+    placeholderData: keepPreviousData
+  });
+  const options = (data == null ? void 0 : data.pages.flatMap((page) => getOptions(page))) ?? [];
+  const defaultOptions = initialData ? getOptions(initialData) : [];
+  const disabled = !rest.isPending && !options.length && !searchValue;
+  if (defaultValue && defaultOptions.length && !searchValue) {
+    defaultOptions.forEach((option) => {
+      if (!options.find((o) => o.value === option.value)) {
+        options.unshift(option);
+      }
+    });
+  }
+  return {
+    options,
+    searchValue,
+    onSearchValueChange,
+    disabled,
+    ...rest
+  };
+};
+export {
+  useComboboxData
+};

package/.medusa/server/src/admin/hooks/common/use-data-table-date-filters.js

@@ -0,0 +1,89 @@
+import { createDataTableFilterHelper } from "@medusajs/ui";
+import { subDays, subMonths } from "date-fns";
+import { useMemo } from "react";
+import { getFullDate } from "../../utils/date-utils.js";
+const filterHelper = createDataTableFilterHelper();
+const useDateFilterOptions = () => {
+  const today = useMemo(() => {
+    const date = /* @__PURE__ */ new Date();
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }, []);
+  return useMemo(() => {
+    return [
+      {
+        label: "Today",
+        value: {
+          $gte: today.toISOString()
+        }
+      },
+      {
+        label: "Last 7 days",
+        value: {
+          $gte: subDays(today, 7).toISOString()
+          // 7 days ago
+        }
+      },
+      {
+        label: "Last 30 days",
+        value: {
+          $gte: subDays(today, 30).toISOString()
+          // 30 days ago
+        }
+      },
+      {
+        label: "Last 90 days",
+        value: {
+          $gte: subDays(today, 90).toISOString()
+          // 90 days ago
+        }
+      },
+      {
+        label: "Last 12 months",
+        value: {
+          $gte: subMonths(today, 12).toISOString()
+          // 12 months ago
+        }
+      }
+    ];
+  }, [today]);
+};
+const useDataTableDateFilters = (disableRangeOption) => {
+  const dateFilterOptions = useDateFilterOptions();
+  const rangeOptions = useMemo(() => {
+    if (disableRangeOption) {
+      return {
+        disableRangeOption: true
+      };
+    }
+    return {
+      rangeOptionStartLabel: "Starting",
+      rangeOptionEndLabel: "Ending",
+      rangeOptionLabel: "Custom",
+      options: dateFilterOptions
+    };
+  }, [disableRangeOption, dateFilterOptions]);
+  return useMemo(() => {
+    return [
+      filterHelper.accessor("created_at", {
+        type: "date",
+        label: "Created at",
+        format: "date",
+        formatDateValue: (date) => getFullDate({ date }),
+        options: dateFilterOptions,
+        ...rangeOptions
+      }),
+      filterHelper.accessor("updated_at", {
+        type: "date",
+        label: "Updated at",
+        format: "date",
+        formatDateValue: (date) => getFullDate({ date }),
+        options: dateFilterOptions,
+        ...rangeOptions
+      })
+    ];
+  }, [dateFilterOptions, getFullDate, rangeOptions]);
+};
+export {
+  useDataTableDateFilters
+};

package/.medusa/server/src/admin/hooks/common/use-date.js

@@ -0,0 +1,32 @@
+import { formatDistance, sub, format } from "date-fns";
+import { enUS } from "/Users/oliverjuhl/Desktop/medusa/loyalty-plugin/node_modules/date-fns/locale.mjs";
+const useDate = () => {
+  const locale = enUS;
+  const getFullDate = ({
+    date,
+    includeTime = false
+  }) => {
+    const ensuredDate = new Date(date);
+    if (isNaN(ensuredDate.getTime())) {
+      return "";
+    }
+    const timeFormat = includeTime ? "p" : "";
+    return format(ensuredDate, `PP ${timeFormat}`, {
+      locale
+    });
+  };
+  function getRelativeDate(date) {
+    const now = /* @__PURE__ */ new Date();
+    return formatDistance(sub(new Date(date), { minutes: 0 }), now, {
+      addSuffix: true,
+      locale
+    });
+  }
+  return {
+    getFullDate,
+    getRelativeDate
+  };
+};
+export {
+  useDate
+};

package/.medusa/server/src/admin/hooks/common/use-debounced-search.js

@@ -0,0 +1,22 @@
+import debounce from "/Users/oliverjuhl/Desktop/medusa/loyalty-plugin/node_modules/lodash/debounce.js";
+import { useState, useCallback, useEffect } from "react";
+const useDebouncedSearch = () => {
+  const [searchValue, onSearchValueChange] = useState("");
+  const [debouncedQuery, setDebouncedQuery] = useState("");
+  const debouncedUpdate = useCallback(
+    debounce((query) => setDebouncedQuery(query), 300),
+    []
+  );
+  useEffect(() => {
+    debouncedUpdate(searchValue);
+    return () => debouncedUpdate.cancel();
+  }, [searchValue, debouncedUpdate]);
+  return {
+    searchValue,
+    onSearchValueChange,
+    query: debouncedQuery || void 0
+  };
+};
+export {
+  useDebouncedSearch
+};