@salesforce/commerce-sdk-react 1.0.0-preview.0

package/hooks/ShopperSearch/query.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useSearchSuggestions = exports.useProductSearch = void 0;
+var _useCommerceApi = _interopRequireDefault(require("../useCommerceApi"));
+var _useQuery = require("../useQuery");
+var _utils = require("../utils");
+var queryKeyHelpers = _interopRequireWildcard(require("./queryKeyHelpers"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; } /*
+                                                                                                                                                                                                                                                                                                                                                                                                       * Copyright (c) 2023, Salesforce, Inc.
+                                                                                                                                                                                                                                                                                                                                                                                                       * All rights reserved.
+                                                                                                                                                                                                                                                                                                                                                                                                       * SPDX-License-Identifier: BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                                       * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+                                                                                                                                                                                                                                                                                                                                                                                                       */
+/**
+ * Provides keyword and refinement search functionality for products. Only returns the product ID, link, and name in
+the product search hit. The search result contains only products that are online and assigned to site catalog.
+ * @parameter apiOptions - Options to pass through to `commerce-sdk-isomorphic`, with `null` accepted for unset API parameters.
+ * @parameter queryOptions - TanStack Query query options, with `enabled` by default set to check that all required API parameters have been set.
+ * @returns A TanStack Query query hook with data from the Shopper Search `productSearch` endpoint.
+ * @see {@link https://developer.salesforce.com/docs/commerce/commerce-api/references/shopper-search?meta=productSearch| Salesforce Developer Center} for more information about the API endpoint.
+ * @see {@link https://salesforcecommercecloud.github.io/commerce-sdk-isomorphic/classes/shoppersearch.shoppersearch-1.html#productsearch | `commerce-sdk-isomorphic` documentation} for more information on the parameters and returned data type.
+ * @see {@link https://tanstack.com/query/latest/docs/react/reference/useQuery | TanStack Query `useQuery` reference} for more information about the return value.
+ */
+const useProductSearch = (apiOptions, queryOptions = {}) => {
+  const {
+    shopperSearch: client
+  } = (0, _useCommerceApi.default)();
+  const methodName = 'productSearch';
+  const requiredParameters = ['organizationId', 'siteId'];
+
+  // Parameters can be set in `apiOptions` or `client.clientConfig`;
+  // we must merge them in order to generate the correct query key.
+  const netOptions = (0, _utils.omitNullableParameters)((0, _utils.mergeOptions)(client, apiOptions));
+  const queryKey = queryKeyHelpers[methodName].queryKey(netOptions.parameters);
+  // We don't use `netOptions` here because we manipulate the options in `useQuery`.
+  const method = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (options) {
+      return yield client[methodName](options);
+    });
+    return function method(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  // For some reason, if we don't explicitly set these generic parameters, the inferred type for
+  // `Data` sometimes, but not always, includes `Response`, which is incorrect. I don't know why.
+  return (0, _useQuery.useQuery)(netOptions, queryOptions, {
+    method,
+    queryKey,
+    requiredParameters
+  });
+};
+/**
+ * Provides keyword search functionality for products, categories, and brands suggestions. Returns suggested products, suggested categories, and suggested brands for the given search phrase.
+ * @parameter apiOptions - Options to pass through to `commerce-sdk-isomorphic`, with `null` accepted for unset API parameters.
+ * @parameter queryOptions - TanStack Query query options, with `enabled` by default set to check that all required API parameters have been set.
+ * @returns A TanStack Query query hook with data from the Shopper Search `getSearchSuggestions` endpoint.
+ * @see {@link https://developer.salesforce.com/docs/commerce/commerce-api/references/shopper-search?meta=getSearchSuggestions| Salesforce Developer Center} for more information about the API endpoint.
+ * @see {@link https://salesforcecommercecloud.github.io/commerce-sdk-isomorphic/classes/shoppersearch.shoppersearch-1.html#getsearchsuggestions | `commerce-sdk-isomorphic` documentation} for more information on the parameters and returned data type.
+ * @see {@link https://tanstack.com/query/latest/docs/react/reference/useQuery | TanStack Query `useQuery` reference} for more information about the return value.
+ */
+exports.useProductSearch = useProductSearch;
+const useSearchSuggestions = (apiOptions, queryOptions = {}) => {
+  const {
+    shopperSearch: client
+  } = (0, _useCommerceApi.default)();
+  const methodName = 'getSearchSuggestions';
+  const requiredParameters = ['organizationId', 'siteId', 'q'];
+
+  // Parameters can be set in `apiOptions` or `client.clientConfig`;
+  // we must merge them in order to generate the correct query key.
+  const netOptions = (0, _utils.omitNullableParameters)((0, _utils.mergeOptions)(client, apiOptions));
+  const queryKey = queryKeyHelpers[methodName].queryKey(netOptions.parameters);
+  // We don't use `netOptions` here because we manipulate the options in `useQuery`.
+  const method = /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(function* (options) {
+      return yield client[methodName](options);
+    });
+    return function method(_x2) {
+      return _ref2.apply(this, arguments);
+    };
+  }();
+
+  // For some reason, if we don't explicitly set these generic parameters, the inferred type for
+  // `Data` sometimes, but not always, includes `Response`, which is incorrect. I don't know why.
+  return (0, _useQuery.useQuery)(netOptions, queryOptions, {
+    method,
+    queryKey,
+    requiredParameters
+  });
+};
+exports.useSearchSuggestions = useSearchSuggestions;

package/hooks/ShopperSearch/queryKeyHelpers.d.ts

@@ -0,0 +1,37 @@
+import type { ShopperSearch } from 'commerce-sdk-isomorphic';
+import { Argument, ExcludeTail } from '../types';
+declare type Client = ShopperSearch<{
+    shortCode: string;
+}>;
+declare type Params<T extends keyof QueryKeys> = Partial<Argument<Client[T]>['parameters']>;
+export declare type QueryKeys = {
+    productSearch: [
+        '/commerce-sdk-react',
+        '/organizations/',
+        string | undefined,
+        '/product-search',
+        Params<'productSearch'>
+    ];
+    getSearchSuggestions: [
+        '/commerce-sdk-react',
+        '/organizations/',
+        string | undefined,
+        '/search-suggestions',
+        Params<'getSearchSuggestions'>
+    ];
+};
+declare type QueryKeyHelper<T extends keyof QueryKeys> = {
+    /**
+     * Reduces the given parameters (which may have additional, unknown properties) to an object
+     * containing *only* the properties required for an endpoint.
+     */
+    parameters: (params: Params<T>) => Params<T>;
+    /** Generates the path component of the query key for an endpoint. */
+    path: (params: Params<T>) => ExcludeTail<QueryKeys[T]>;
+    /** Generates the full query key for an endpoint. */
+    queryKey: (params: Params<T>) => QueryKeys[T];
+};
+export declare const productSearch: QueryKeyHelper<'productSearch'>;
+export declare const getSearchSuggestions: QueryKeyHelper<'getSearchSuggestions'>;
+export {};
+//# sourceMappingURL=queryKeyHelpers.d.ts.map

package/hooks/ShopperSearch/queryKeyHelpers.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.productSearch = exports.getSearchSuggestions = void 0;
+var _utils = require("../utils");
+/*
+ * Copyright (c) 2023, Salesforce, Inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+// We must use a client with no parameters in order to have required/optional match the API spec
+
+// This is defined here, rather than `types.ts`, because it relies on `Client` and `QueryKeys`,
+// and making those generic would add too much complexity.
+
+const productSearch = {
+  parameters: params => (0, _utils.pick)(params, ['organizationId', 'siteId', 'q', 'refine', 'sort', 'currency', 'locale', 'expand', 'offset', 'limit']),
+  path: params => ['/commerce-sdk-react', '/organizations/', params.organizationId, '/product-search'],
+  queryKey: params => [...productSearch.path(params), productSearch.parameters(params)]
+};
+exports.productSearch = productSearch;
+const getSearchSuggestions = {
+  parameters: params => (0, _utils.pick)(params, ['organizationId', 'siteId', 'q', 'limit', 'currency', 'locale']),
+  path: params => ['/commerce-sdk-react', '/organizations/', params.organizationId, '/search-suggestions'],
+  queryKey: params => [...getSearchSuggestions.path(params), getSearchSuggestions.parameters(params)]
+};
+exports.getSearchSuggestions = getSearchSuggestions;

package/hooks/index.d.ts

@@ -0,0 +1,18 @@
+export * from './ShopperBaskets';
+export * from './ShopperContexts';
+export * from './ShopperCustomers';
+export * from './ShopperExperience';
+export * from './ShopperGiftCertificates';
+export * from './ShopperLogin';
+export * from './ShopperOrders';
+export * from './ShopperProducts';
+export * from './ShopperPromotions';
+export * from './ShopperSearch';
+export * from './useAuthHelper';
+export { default as useAccessToken } from './useAccessToken';
+export { default as useCommerceApi } from './useCommerceApi';
+export { default as useEncUserId } from './useEncUserId';
+export { default as useUsid } from './useUsid';
+export { default as useCustomerId } from './useCustomerId';
+export { default as useCustomerType } from './useCustomerType';
+//# sourceMappingURL=index.d.ts.map

package/hooks/index.js

@@ -0,0 +1,188 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useAccessToken: true,
+  useCommerceApi: true,
+  useEncUserId: true,
+  useUsid: true,
+  useCustomerId: true,
+  useCustomerType: true
+};
+Object.defineProperty(exports, "useAccessToken", {
+  enumerable: true,
+  get: function () {
+    return _useAccessToken.default;
+  }
+});
+Object.defineProperty(exports, "useCommerceApi", {
+  enumerable: true,
+  get: function () {
+    return _useCommerceApi.default;
+  }
+});
+Object.defineProperty(exports, "useCustomerId", {
+  enumerable: true,
+  get: function () {
+    return _useCustomerId.default;
+  }
+});
+Object.defineProperty(exports, "useCustomerType", {
+  enumerable: true,
+  get: function () {
+    return _useCustomerType.default;
+  }
+});
+Object.defineProperty(exports, "useEncUserId", {
+  enumerable: true,
+  get: function () {
+    return _useEncUserId.default;
+  }
+});
+Object.defineProperty(exports, "useUsid", {
+  enumerable: true,
+  get: function () {
+    return _useUsid.default;
+  }
+});
+var _ShopperBaskets = require("./ShopperBaskets");
+Object.keys(_ShopperBaskets).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperBaskets[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperBaskets[key];
+    }
+  });
+});
+var _ShopperContexts = require("./ShopperContexts");
+Object.keys(_ShopperContexts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperContexts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperContexts[key];
+    }
+  });
+});
+var _ShopperCustomers = require("./ShopperCustomers");
+Object.keys(_ShopperCustomers).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperCustomers[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperCustomers[key];
+    }
+  });
+});
+var _ShopperExperience = require("./ShopperExperience");
+Object.keys(_ShopperExperience).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperExperience[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperExperience[key];
+    }
+  });
+});
+var _ShopperGiftCertificates = require("./ShopperGiftCertificates");
+Object.keys(_ShopperGiftCertificates).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperGiftCertificates[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperGiftCertificates[key];
+    }
+  });
+});
+var _ShopperLogin = require("./ShopperLogin");
+Object.keys(_ShopperLogin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperLogin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperLogin[key];
+    }
+  });
+});
+var _ShopperOrders = require("./ShopperOrders");
+Object.keys(_ShopperOrders).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperOrders[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperOrders[key];
+    }
+  });
+});
+var _ShopperProducts = require("./ShopperProducts");
+Object.keys(_ShopperProducts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperProducts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperProducts[key];
+    }
+  });
+});
+var _ShopperPromotions = require("./ShopperPromotions");
+Object.keys(_ShopperPromotions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperPromotions[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperPromotions[key];
+    }
+  });
+});
+var _ShopperSearch = require("./ShopperSearch");
+Object.keys(_ShopperSearch).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ShopperSearch[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ShopperSearch[key];
+    }
+  });
+});
+var _useAuthHelper = require("./useAuthHelper");
+Object.keys(_useAuthHelper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useAuthHelper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useAuthHelper[key];
+    }
+  });
+});
+var _useAccessToken = _interopRequireDefault(require("./useAccessToken"));
+var _useCommerceApi = _interopRequireDefault(require("./useCommerceApi"));
+var _useEncUserId = _interopRequireDefault(require("./useEncUserId"));
+var _useUsid = _interopRequireDefault(require("./useUsid"));
+var _useCustomerId = _interopRequireDefault(require("./useCustomerId"));
+var _useCustomerType = _interopRequireDefault(require("./useCustomerType"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/hooks/types.d.ts

@@ -0,0 +1,128 @@
+import { InvalidateQueryFilters, QueryFilters, Updater, UseQueryOptions } from '@tanstack/react-query';
+import { ShopperBaskets, ShopperContexts, ShopperCustomers, ShopperExperience, ShopperGiftCertificates, ShopperLogin, ShopperOrders, ShopperProducts, ShopperPromotions, ShopperSearch } from 'commerce-sdk-isomorphic';
+/** Makes a type easier to read. */
+export declare type Prettify<T extends object> = NonNullable<Pick<T, keyof T>>;
+/**
+ * Marks the given keys as required.
+ * WARNING: Does not work if T has an index signature.
+ */
+export declare type RequireKeys<T, K extends keyof T> = Prettify<T & Required<Pick<T, K>>>;
+/** Removes keys whose value is `never`. */
+declare type RemoveNeverValues<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+/** Change string index type to `never`. */
+declare type StringIndexToNever<T> = {
+    [K in keyof T]: string extends K ? never : T[K];
+};
+/** Removes a string index type. */
+export declare type RemoveStringIndex<T> = RemoveNeverValues<StringIndexToNever<T>>;
+/** Gets the last element of an array. */
+export declare type Tail<T extends readonly unknown[]> = T extends [...head: unknown[], tail: infer Tail] ? Tail : T;
+/** Remove the last entry from a tuple type. */
+export declare type ExcludeTail<T extends readonly unknown[]> = T extends readonly [...infer Head, unknown] ? T extends unknown[] ? Head : Readonly<Head> : T;
+/** Adds `null` as an allowed value to all properties. */
+declare type AllowNull<T> = {
+    [K in keyof T]: T[K] | null;
+};
+/** Gets the keys of `T` which allow `null` as a possible value. */
+declare type NullKeys<T> = {
+    [K in keyof T]-?: null extends T[K] ? K : never;
+}[keyof T];
+/** Removes `null` values and marks those properties as optional. */
+export declare type NullToOptional<T> = Omit<T, NullKeys<T>> & {
+    [K in keyof T]?: NonNullable<T[K]>;
+};
+export declare type ApiClientConfigParams = {
+    clientId: string;
+    organizationId: string;
+    siteId: string;
+    shortCode: string;
+    locale?: string;
+    currency?: string;
+};
+export interface ApiClients {
+    shopperBaskets: ShopperBaskets<ApiClientConfigParams>;
+    shopperContexts: ShopperContexts<ApiClientConfigParams>;
+    shopperCustomers: ShopperCustomers<ApiClientConfigParams>;
+    shopperExperience: ShopperExperience<ApiClientConfigParams>;
+    shopperGiftCertificates: ShopperGiftCertificates<ApiClientConfigParams>;
+    shopperLogin: ShopperLogin<ApiClientConfigParams>;
+    shopperOrders: ShopperOrders<ApiClientConfigParams>;
+    shopperProducts: ShopperProducts<ApiClientConfigParams>;
+    shopperPromotions: ShopperPromotions<ApiClientConfigParams>;
+    shopperSearch: ShopperSearch<ApiClientConfigParams>;
+}
+export declare type ApiClient = ApiClients[keyof ApiClients];
+/**
+ * Generic signature of the options objects used by commerce-sdk-isomorphic
+ */
+export declare type ApiOptions<Parameters extends object = Record<string, unknown>, Body extends object | unknown[] | undefined = Record<string, unknown> | unknown[] | undefined, Headers extends Record<string, string> = Record<string, string>> = {
+    parameters?: Parameters;
+    headers?: Headers;
+    body?: Body;
+};
+/**
+ * Generic signature of API methods exported by commerce-sdk-isomorphic
+ */
+export declare type ApiMethod<Options extends ApiOptions, Data> = {
+    (options: Options): Promise<Data>;
+};
+/**
+ * The first argument of a function.
+ */
+export declare type Argument<T extends (arg: any) => unknown> = NonNullable<Parameters<T>[0]>;
+/**
+ * The data type returned by a commerce-sdk-isomorphic method when the raw response
+ * flag is not set.
+ */
+export declare type DataType<T> = T extends ApiMethod<any, Response | infer R> ? R : never;
+/**
+ * Merged headers and parameters from client config and options, mimicking the behavior
+ * of commerce-sdk-isomorphic.
+ */
+export declare type MergedOptions<Client extends ApiClient, Options extends ApiOptions> = Required<ApiOptions<NonNullable<Client['clientConfig']['parameters'] & Options['parameters']>, unknown extends Options['body'] ? never : Options['body'], NonNullable<Client['clientConfig']['headers'] & Options['headers']>>>;
+/** Query key interface used by API query hooks. */
+export declare type ApiQueryKey<Params extends Record<string, unknown> = Record<string, unknown>> = readonly [...path: (string | undefined)[], parameters: Params];
+/** Query options for endpoint hooks. */
+export declare type ApiQueryOptions<Method extends ApiMethod<any, unknown>> = Prettify<Omit<UseQueryOptions<DataType<Method>, unknown, DataType<Method>, ApiQueryKey>, 'queryFn' | 'queryKey'>>;
+/** Adds `null` as an allowed value to all parameters. */
+export declare type NullableParameters<T extends {
+    parameters?: object;
+}> = {
+    [K in keyof T]: K extends 'parameters' ? AllowNull<T[K]> : T[K];
+};
+/** Remove `null` and `undefined` values from all parameters. */
+export declare type OmitNullableParameters<T extends {
+    parameters: object;
+}> = Omit<T, 'parameters'> & {
+    parameters: NullToOptional<T['parameters']>;
+};
+/**
+ * Interface to update a cached API response.
+ * @property queryKey - The query key to update
+ * @property updater - Either the new data or a function that accepts old data and returns new data
+ */
+export declare type CacheUpdateUpdate<T> = {
+    queryKey: ApiQueryKey;
+    updater?: Updater<T | undefined, T | undefined>;
+};
+/** Query predicate for queries to invalidate */
+export declare type CacheUpdateInvalidate = InvalidateQueryFilters;
+/** Query predicate for queries to remove */
+export declare type CacheUpdateRemove = QueryFilters;
+/** Collection of updates to make to the cache when a request completes. */
+export declare type CacheUpdate = {
+    update?: CacheUpdateUpdate<unknown>[];
+    invalidate?: CacheUpdateInvalidate[];
+    remove?: CacheUpdateRemove[];
+    clear?: boolean;
+};
+/** Generates a collection of cache updates to make for a given request. */
+export declare type CacheUpdateGetter<Options, Data> = (customerId: string | null, options: Options, response: Data) => CacheUpdate;
+/** Collection of cache update getters for each method of an API client. */
+export declare type CacheUpdateMatrix<Client extends ApiClient> = {
+    [Method in keyof Client]?: Client[Method] extends ApiMethod<any, Response | infer Data> ? CacheUpdateGetter<MergedOptions<Client, Argument<Client[Method]>>, Data> : never;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/hooks/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/hooks/useAccessToken.d.ts

@@ -0,0 +1,11 @@
+interface AccessToken {
+    token: string | null;
+    getTokenWhenReady: () => Promise<string>;
+}
+/**
+ * Hook that returns the access token.
+ *
+ */
+declare const useAccessToken: () => AccessToken;
+export default useAccessToken;
+//# sourceMappingURL=useAccessToken.d.ts.map

package/hooks/useAccessToken.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _useAuthContext = _interopRequireDefault(require("./useAuthContext"));
+var _useLocalStorage = _interopRequireDefault(require("./useLocalStorage"));
+var _useConfig = _interopRequireDefault(require("./useConfig"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+const onClient = typeof window !== 'undefined';
+/**
+ * Hook that returns the access token.
+ *
+ */
+const useAccessToken = () => {
+  const config = (0, _useConfig.default)();
+  const auth = (0, _useAuthContext.default)();
+  const token = onClient ?
+  // This conditional is a constant value based on the environment, so the same path will
+  // always be followed., and the "rule of hooks" is not violated.
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  (0, _useLocalStorage.default)(`access_token_${config.siteId}`) : auth.get('access_token');
+
+  // NOTE: auth.ready() is to be called later. If you call it immediately in this hook,
+  // it'll cause infinite re-renders during testing.
+  const getTokenWhenReady = () => auth.ready().then(({
+    access_token
+  }) => access_token);
+  return {
+    token,
+    getTokenWhenReady
+  };
+};
+var _default = useAccessToken;
+exports.default = _default;

package/hooks/useAuthContext.d.ts

@@ -0,0 +1,9 @@
+import Auth from '../auth';
+/**
+ * TBD
+ *
+ * @internal
+ */
+declare const useAuthContext: () => Auth;
+export default useAuthContext;
+//# sourceMappingURL=useAuthContext.d.ts.map

package/hooks/useAuthContext.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = _interopRequireDefault(require("react"));
+var _provider = require("../provider");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright (c) 2022, salesforce.com, inc.
+ * All rights reserved.
+ * SPDX-License-Identifier: BSD-3-Clause
+ * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+/**
+ * TBD
+ *
+ * @internal
+ */
+const useAuthContext = () => {
+  const context = _react.default.useContext(_provider.AuthContext);
+  if (!context) {
+    throw new Error('Missing CommerceApiProvider. You probably forget to render the provider.');
+  }
+  return context;
+};
+var _default = useAuthContext;
+exports.default = _default;

package/hooks/useAuthHelper.d.ts

@@ -0,0 +1,23 @@
+import { UseMutationResult } from '@tanstack/react-query';
+import Auth from '../auth';
+export declare const AuthHelpers: {
+    readonly LoginGuestUser: "loginGuestUser";
+    readonly LoginRegisteredUserB2C: "loginRegisteredUserB2C";
+    readonly Logout: "logout";
+    readonly Register: "register";
+};
+export declare type AuthHelper = (typeof AuthHelpers)[keyof typeof AuthHelpers];
+/**
+ * A hook for Public Client OAuth helpers.
+ * The hook calls the SLAS helpers imported from commerce-sdk-isomorphic.
+ * For more, see https://github.com/SalesforceCommerceCloud/commerce-sdk-isomorphic/#public-client-shopper-login-helpers
+ *
+ * Avaliable helpers:
+ * - loginRegisteredUserB2C
+ * - loginGuestUser
+ * - logout
+ * - register
+ */
+export declare function useAuthHelper<Mutation extends AuthHelper>(mutation: Mutation): UseMutationResult<ReturnType<Auth[Mutation]> extends Promise<infer Data> ? Data : never, unknown, [
+] extends Parameters<Auth[Mutation]> ? void : Parameters<Auth[Mutation]>[0], unknown>;
+//# sourceMappingURL=useAuthHelper.d.ts.map