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

package/hooks/useAuthHelper.js

@@ -0,0 +1,66 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AuthHelpers = void 0;
+exports.useAuthHelper = useAuthHelper;
+var _reactQuery = require("@tanstack/react-query");
+var _useAuthContext = _interopRequireDefault(require("./useAuthContext"));
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * 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
+ */
+
+const AuthHelpers = {
+  LoginGuestUser: 'loginGuestUser',
+  LoginRegisteredUserB2C: 'loginRegisteredUserB2C',
+  Logout: 'logout',
+  Register: 'register'
+};
+exports.AuthHelpers = AuthHelpers;
+const noop = () => ({});
+/**
+ * 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
+ */
+function useAuthHelper(mutation) {
+  const auth = (0, _useAuthContext.default)();
+  if (!auth[mutation]) throw new Error(`Unknown login helper mutation: ${mutation}`);
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  // I'm not sure if there's a way to avoid this type assertion, but, I'm fairly confident that
+  // it is safe to do, as it seems to be simply re-asserting what we already know.
+  const method = auth[mutation].bind(auth);
+  return (0, _reactQuery.useMutation)(auth.whenReady(method), {
+    onSuccess(data, options) {
+      const getCacheUpdates = cacheUpdateMatrix[mutation];
+      if (getCacheUpdates) {
+        const cacheUpdates = getCacheUpdates(options, data);
+        (0, _utils.updateCache)(queryClient, cacheUpdates, data);
+      }
+    }
+  });
+}
+const cacheUpdateMatrix = {
+  loginRegisteredUserB2C: noop,
+  loginGuestUser: noop,
+  logout() {
+    return {
+      remove: [{
+        queryKey: ['/commerce-sdk-react']
+      }]
+    };
+  },
+  register: noop
+};

package/hooks/useAuthorizationHeader.d.ts

@@ -0,0 +1,9 @@
+import { ApiOptions, ApiMethod } from './types';
+/**
+ * Creates a method that waits for authentication to complete and automatically includes an
+ * Authorization header when making requests.
+ * @param method Bound API method
+ * @internal
+ */
+export declare const useAuthorizationHeader: <Options extends ApiOptions<Record<string, unknown>, unknown[] | Record<string, unknown> | undefined, Record<string, string>>, Data>(method: ApiMethod<Options, Data>) => ApiMethod<Options, Data>;
+//# sourceMappingURL=useAuthorizationHeader.d.ts.map

package/hooks/useAuthorizationHeader.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useAuthorizationHeader = void 0;
+var _useAuthContext = _interopRequireDefault(require("./useAuthContext"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+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
+                                                                                                                                                                                                                                                                                                                                                                                                       */
+/**
+ * Creates a method that waits for authentication to complete and automatically includes an
+ * Authorization header when making requests.
+ * @param method Bound API method
+ * @internal
+ */
+const useAuthorizationHeader = method => {
+  const auth = (0, _useAuthContext.default)();
+  return /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (options) {
+      const {
+        access_token
+      } = yield auth.ready();
+      return yield method(_objectSpread(_objectSpread({}, options), {}, {
+        headers: _objectSpread({
+          Authorization: `Bearer ${access_token}`
+        }, options.headers)
+      }));
+    });
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+};
+exports.useAuthorizationHeader = useAuthorizationHeader;

package/hooks/useCommerceApi.d.ts

@@ -0,0 +1,9 @@
+import { ApiClients } from './types';
+/**
+ * Access a set of initialized Commerce API clients, which are initialized using the configurations passed to the CommerceApiProvider.
+ *
+ * @returns Commerce API clients
+ */
+declare const useCommerceApi: () => ApiClients;
+export default useCommerceApi;
+//# sourceMappingURL=useCommerceApi.d.ts.map

package/hooks/useCommerceApi.js

@@ -0,0 +1,26 @@
+"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
+ */
+
+/**
+ * Access a set of initialized Commerce API clients, which are initialized using the configurations passed to the CommerceApiProvider.
+ *
+ * @returns Commerce API clients
+ */
+const useCommerceApi = () => {
+  return _react.default.useContext(_provider.CommerceApiContext);
+};
+var _default = useCommerceApi;
+exports.default = _default;

package/hooks/useConfig.d.ts

@@ -0,0 +1,7 @@
+import { CommerceApiProviderProps } from '../provider';
+/**
+ * @Internal
+ */
+declare const useConfig: () => Omit<CommerceApiProviderProps, 'children'>;
+export default useConfig;
+//# sourceMappingURL=useConfig.d.ts.map

package/hooks/useConfig.js

@@ -0,0 +1,24 @@
+"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
+ */
+
+/**
+ * @Internal
+ */
+const useConfig = () => {
+  return _react.default.useContext(_provider.ConfigContext);
+};
+var _default = useConfig;
+exports.default = _default;

package/hooks/useCustomerId.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook that returns the customer ID.
+ *
+ */
+declare const useCustomerId: () => string | null;
+export default useCustomerId;
+//# sourceMappingURL=useCustomerId.d.ts.map

package/hooks/useCustomerId.js

@@ -0,0 +1,38 @@
+"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 customer ID.
+ *
+ */
+const useCustomerId = () => {
+  if (onClient) {
+    // `onClient` is a constant, so the hooks will always have the same execution order,
+    // despite technically being inside a conditional.
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    const config = (0, _useConfig.default)();
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return (0, _useLocalStorage.default)(`customer_id_${config.siteId}`);
+  }
+  // eslint-disable-next-line react-hooks/rules-of-hooks
+  const auth = (0, _useAuthContext.default)();
+  return auth.get('customer_id');
+};
+var _default = useCustomerId;
+exports.default = _default;

package/hooks/useCustomerType.d.ts

@@ -0,0 +1,21 @@
+export declare type CustomerType = null | 'guest' | 'registered';
+declare type useCustomerType = {
+    customerType: CustomerType;
+    isGuest: boolean;
+    isRegistered: boolean;
+};
+/**
+ * A hook to return customer auth type.
+ *
+ * Customer type can have 3 values:
+ * - null
+ * - guest
+ * - registered
+ *
+ * During initialization, type is null. And it is possible that
+ * isGuest and isRegistered to both be false.
+ *
+ */
+declare const useCustomerType: () => useCustomerType;
+export default useCustomerType;
+//# sourceMappingURL=useCustomerType.d.ts.map

package/hooks/useCustomerType.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _useAuthContext = _interopRequireDefault(require("./useAuthContext"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * Copyright (c) 2023, 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
+ */
+
+/**
+ * A hook to return customer auth type.
+ *
+ * Customer type can have 3 values:
+ * - null
+ * - guest
+ * - registered
+ *
+ * During initialization, type is null. And it is possible that
+ * isGuest and isRegistered to both be false.
+ *
+ */
+const useCustomerType = () => {
+  const auth = (0, _useAuthContext.default)();
+  let customerType = auth.get('customer_type');
+  const isGuest = customerType === 'guest';
+  const isRegistered = customerType === 'registered';
+  if (customerType !== null && customerType !== 'guest' && customerType !== 'registered') {
+    customerType = null;
+  }
+  return {
+    customerType,
+    isGuest,
+    isRegistered
+  };
+};
+var _default = useCustomerType;
+exports.default = _default;

package/hooks/useEncUserId.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hook that returns the ecom user ID.
+ *
+ * This is sometimes used as the user ID for Einstein.
+ *
+ */
+declare const useEncUserId: () => string | null;
+export default useEncUserId;
+//# sourceMappingURL=useEncUserId.d.ts.map

package/hooks/useEncUserId.js

@@ -0,0 +1,36 @@
+"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 ecom user ID.
+ *
+ * This is sometimes used as the user ID for Einstein.
+ *
+ */
+const useEncUserId = () => {
+  const config = (0, _useConfig.default)();
+  const auth = (0, _useAuthContext.default)();
+  return 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)(`$enc_user_id_${config.siteId}`) : auth.get('enc_user_id');
+};
+var _default = useEncUserId;
+exports.default = _default;

package/hooks/useLocalStorage.d.ts

@@ -0,0 +1,8 @@
+declare type Value = string | null;
+/**
+ * @internal
+ *
+ */
+declare function useLocalStorage(key: string): Value;
+export default useLocalStorage;
+//# sourceMappingURL=useLocalStorage.d.ts.map

package/hooks/useLocalStorage.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _react = require("react");
+/*
+ * Copyright (c) 2022, 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
+ */
+
+/**
+ * @internal
+ *
+ */
+function useLocalStorage(key) {
+  const readValue = () => {
+    if (typeof window === 'undefined') {
+      return null;
+    }
+    return window.localStorage.getItem(key);
+  };
+  const [storedValue, setStoredValue] = (0, _react.useState)(readValue);
+  const handleStorageChange = event => {
+    if (event.key !== key) {
+      return;
+    }
+    setStoredValue(readValue());
+  };
+  (0, _react.useEffect)(() => {
+    window.addEventListener('storage', handleStorageChange);
+    return () => window.removeEventListener('storage', handleStorageChange);
+  }, []);
+  return storedValue;
+}
+var _default = useLocalStorage;
+exports.default = _default;

package/hooks/useMutation.d.ts

@@ -0,0 +1,12 @@
+import { CacheUpdateGetter, ApiOptions, ApiMethod, ApiClient, MergedOptions } from './types';
+/**
+ * Helper for mutation hooks, contains most of the logic in order to keep individual hooks small.
+ * @param hookConfig - Config values that vary per API endpoint
+ * @internal
+ */
+export declare const useMutation: <Client extends ApiClient, Options extends ApiOptions<Record<string, unknown>, unknown[] | Record<string, unknown> | undefined, Record<string, string>>, Data>(hookConfig: {
+    client: Client;
+    method: ApiMethod<Options, Data>;
+    getCacheUpdates: CacheUpdateGetter<Required<ApiOptions<NonNullable<Client["clientConfig"]["parameters"] & Options["parameters"]>, unknown extends Options["body"] ? never : Options["body"], NonNullable<Client["clientConfig"]["headers"] & Options["headers"]>>>, Data>;
+}) => import("@tanstack/react-query").UseMutationResult<Data, unknown, Options, unknown>;
+//# sourceMappingURL=useMutation.d.ts.map

package/hooks/useMutation.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useMutation = void 0;
+var _reactQuery = require("@tanstack/react-query");
+var _useAuthorizationHeader = require("./useAuthorizationHeader");
+var _useCustomerId = _interopRequireDefault(require("./useCustomerId"));
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
+ * 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
+ */
+
+/**
+ * Helper for mutation hooks, contains most of the logic in order to keep individual hooks small.
+ * @param hookConfig - Config values that vary per API endpoint
+ * @internal
+ */
+const useMutation = hookConfig => {
+  const queryClient = (0, _reactQuery.useQueryClient)();
+  const customerId = (0, _useCustomerId.default)();
+  const authenticatedMethod = (0, _useAuthorizationHeader.useAuthorizationHeader)(hookConfig.method);
+  return (0, _reactQuery.useMutation)(authenticatedMethod, {
+    onSuccess(data, options) {
+      // commerce-sdk-isomorphic merges `clientConfig` and `options` under the hood,
+      // so we also need to do that to get the "net" options that are actually sent to SCAPI.
+      const netOptions = (0, _utils.mergeOptions)(hookConfig.client, options);
+      const cacheUpdates = hookConfig.getCacheUpdates(customerId, netOptions, data);
+      (0, _utils.updateCache)(queryClient, cacheUpdates, data);
+    }
+  });
+};
+exports.useMutation = useMutation;

package/hooks/useQuery.d.ts

@@ -0,0 +1,15 @@
+import { ApiClient, ApiMethod, ApiOptions, ApiQueryKey, ApiQueryOptions, MergedOptions, NullableParameters, OmitNullableParameters } from './types';
+/**
+ * Helper for query hooks, contains most of the logic in order to keep individual hooks small.
+ * @param apiOptions - Options passed through to commerce-sdk-isomorphic
+ * @param queryOptions - Options passed through to @tanstack/react-query
+ * @param hookConfig - Config values that vary per API endpoint
+ * @internal
+ */
+export declare const useQuery: <Client extends ApiClient, Options extends ApiOptions<Record<string, unknown>, unknown[] | Record<string, unknown> | undefined, Record<string, string>>, Data>(apiOptions: OmitNullableParameters<NullableParameters<Required<ApiOptions<NonNullable<Client["clientConfig"]["parameters"] & Options["parameters"]>, unknown extends Options["body"] ? never : Options["body"], NonNullable<Client["clientConfig"]["headers"] & Options["headers"]>>>>>, queryOptions: ApiQueryOptions<ApiMethod<Options, Data>>, hookConfig: {
+    method: ApiMethod<Options, Data>;
+    queryKey: ApiQueryKey<Partial<Options["parameters"]>>;
+    requiredParameters: readonly (keyof NonNullable<Options["parameters"]>)[];
+    enabled?: boolean | undefined;
+}) => import("@tanstack/react-query").UseQueryResult<Data, unknown>;
+//# sourceMappingURL=useQuery.d.ts.map

package/hooks/useQuery.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useQuery = void 0;
+var _reactQuery = require("@tanstack/react-query");
+var _useAuthorizationHeader = require("./useAuthorizationHeader");
+var _utils = require("./utils");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+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
+                                                                                                                                                                                                                                                                                                                                                                                                       */
+/**
+ * Helper for query hooks, contains most of the logic in order to keep individual hooks small.
+ * @param apiOptions - Options passed through to commerce-sdk-isomorphic
+ * @param queryOptions - Options passed through to @tanstack/react-query
+ * @param hookConfig - Config values that vary per API endpoint
+ * @internal
+ */
+const useQuery = (apiOptions, queryOptions, hookConfig) => {
+  const authenticatedMethod = (0, _useAuthorizationHeader.useAuthorizationHeader)(hookConfig.method);
+  // This type assertion is NOT safe in all cases. However, we know that `requiredParameters` is
+  // the list of parameters required by `Options`, and we know that in the default case (when
+  // `queryOptions.enabled` is not set), we only execute the hook when `apiOptions` has all
+  // required parameters. Therefore, we know that `apiOptions` satisfies `Options` in the default
+  // case, so the type assertion is safe in the default case. We explicitly do NOT guarantee type
+  // safety when `queryOptions.enabled` is set; when it is `true`, the callback may be called with
+  // missing parameters. This will result in a runtime error. I think that this is an acceptable
+  // trade-off, as the behavior is opt-in by the end user, and it feels like adding type safety
+  // for this case would add significantly more complexity.
+  const wrappedMethod = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* () {
+      return yield authenticatedMethod(apiOptions);
+    });
+    return function wrappedMethod() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return (0, _reactQuery.useQuery)(hookConfig.queryKey, wrappedMethod, _objectSpread({
+    enabled:
+    // Individual hooks can provide `enabled` checks that are done in ADDITION to
+    // the required parameter check
+    hookConfig.enabled !== false &&
+    // The default `enabled` is "has all required parameters"
+    (0, _utils.hasAllKeys)(apiOptions.parameters, hookConfig.requiredParameters)
+  }, queryOptions));
+};
+exports.useQuery = useQuery;

package/hooks/useUsid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook that returns the usid associated with the current access token.
+ *
+ */
+declare const useUsid: () => string | null;
+export default useUsid;
+//# sourceMappingURL=useUsid.d.ts.map

package/hooks/useUsid.js

@@ -0,0 +1,34 @@
+"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 usid associated with the current access token.
+ *
+ */
+const useUsid = () => {
+  const config = (0, _useConfig.default)();
+  const auth = (0, _useAuthContext.default)();
+  return 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)(`usid_${config.siteId}`) : auth.get('usid');
+};
+var _default = useUsid;
+exports.default = _default;

package/hooks/utils.d.ts

@@ -0,0 +1,32 @@
+import { Query, QueryClient } from '@tanstack/react-query';
+import { ApiClient, ApiOptions, CacheUpdate, MergedOptions, NullToOptional, OmitNullableParameters } from './types';
+/** Applies the set of cache updates to the query client. */
+export declare const updateCache: (queryClient: QueryClient, cacheUpdates: CacheUpdate, data: unknown) => void;
+/** Error thrown when a method is not implemented. */
+export declare class NotImplementedError extends Error {
+    constructor(method?: string);
+}
+/** Determines whether a value is an object. */
+export declare const isObject: (obj: unknown) => obj is Record<string, unknown>;
+/** Determines whether a value has all of the given keys. */
+export declare const hasAllKeys: <T>(object: T, keys: readonly (keyof T)[]) => boolean;
+/** Creates a query predicate that determines whether a query key starts with the given path segments. */
+export declare const pathStartsWith: (search: readonly (string | undefined)[]) => ({ queryKey }: Query) => boolean;
+/** Creates a query predicate that returns true if all of the given predicates return true. */
+export declare const and: <Args extends unknown[]>(...funcs: ((...args: Args) => boolean)[]) => (...args: Args) => boolean;
+/**
+ * Merges headers and parameters from client config into the options, mimicking the behavior
+ * of commerce-sdk-isomorphic.
+ */
+export declare const mergeOptions: <Client extends ApiClient, Options extends ApiOptions<Record<string, unknown>, unknown[] | Record<string, unknown> | undefined, Record<string, string>>>(client: Client, options: Options) => Required<ApiOptions<NonNullable<Client["clientConfig"]["parameters"] & Options["parameters"]>, unknown extends Options["body"] ? never : Options["body"], NonNullable<Client["clientConfig"]["headers"] & Options["headers"]>>>;
+/** Constructs a subset of the given object containing only the given keys. */
+export declare const pick: <T extends object, K extends keyof T>(obj: T, keys: readonly K[]) => Pick<T, K>;
+/** Removes keys with `null` or `undefined` values from the given object. */
+export declare const omitNullable: <T extends object>(obj: T) => NullToOptional<T>;
+/** Removes keys with `null` or `undefined` values from the `parameters` of the given object. */
+export declare const omitNullableParameters: <T extends {
+    parameters: object;
+}>(obj: T) => OmitNullableParameters<T>;
+/** Simple deep clone utility */
+export declare const clone: <T>(val: T) => T;
+//# sourceMappingURL=utils.d.ts.map