@vue-storefront/next 7.0.0-next.2 → 7.0.0-next.4

package/dist/client.cjs

@@ -0,0 +1,223 @@
+"use client";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const require_env = require('./env-Be9N7zqo.cjs');
+let __alokai_instrumentation_next_component = require("@alokai/instrumentation-next-component");
+let next_script = require("next/script");
+next_script = __toESM(next_script);
+let react = require("react");
+react = __toESM(react);
+let zustand = require("zustand");
+
+//#region src/env/get-public-env.ts
+/**
+* Extracts all NEXT_PUBLIC_* environment variables from process.env
+* This is used server-side to prepare env vars for injection into the client
+*
+* @returns Object containing all NEXT_PUBLIC_* environment variables
+*/
+function getPublicEnv() {
+	const publicEnv = {};
+	for (const key in process.env) if (key.startsWith("NEXT_PUBLIC_")) publicEnv[key] = process.env[key];
+	return publicEnv;
+}
+
+//#endregion
+//#region src/state.tsx
+const createSfState = (initialData) => {
+	return (0, zustand.createStore)()((set) => require_env._objectSpread2(require_env._objectSpread2({
+		cart: null,
+		customer: null
+	}, initialData), {}, {
+		setCart: (cart) => set({ cart }),
+		setCurrencies: (currencies) => set({ currencies }),
+		setCurrency: (currency) => set({ currency }),
+		setCustomer: (customer) => set({ customer }),
+		setLocale: (locale) => set({ locale }),
+		setLocales: (locales) => set({ locales })
+	}));
+};
+function createSfStateProvider() {
+	const SfStateContext = (0, react.createContext)(null);
+	function SfStateProvider({ children, initialData }) {
+		const stateReference = (0, react.useRef)(null);
+		if (!stateReference.current) stateReference.current = createSfState(initialData);
+		return /* @__PURE__ */ react.default.createElement(SfStateContext.Provider, { value: stateReference.current }, children);
+	}
+	function getSfStateContext() {
+		const context = (0, react.useContext)(SfStateContext);
+		if (!context) throw new Error("Missing SfStateContext.Provider in the tree");
+		return context;
+	}
+	function useSfCurrencyState() {
+		const { currency, setCurrency } = (0, zustand.useStore)(getSfStateContext(), (state) => ({
+			currency: state.currency,
+			setCurrency: state.setCurrency
+		}));
+		return [currency, setCurrency];
+	}
+	function useSfCurrenciesState() {
+		const { currencies, setCurrencies } = (0, zustand.useStore)(getSfStateContext(), (state) => ({
+			currencies: state.currencies,
+			setCurrencies: state.setCurrencies
+		}));
+		return [currencies, setCurrencies];
+	}
+	function useSfLocaleState() {
+		const { locale, setLocale } = (0, zustand.useStore)(getSfStateContext(), (state) => ({
+			locale: state.locale,
+			setLocale: state.setLocale
+		}));
+		return [locale, setLocale];
+	}
+	function useSfLocalesState() {
+		const { locales, setLocales } = (0, zustand.useStore)(getSfStateContext(), (state) => ({
+			locales: state.locales,
+			setLocales: state.setLocales
+		}));
+		return [locales, setLocales];
+	}
+	function useSfCartState() {
+		const { cart, setCart } = (0, zustand.useStore)(getSfStateContext(), (state) => ({
+			cart: state.cart,
+			setCart: state.setCart
+		}));
+		return [cart, setCart];
+	}
+	function useSfCustomerState() {
+		const { customer, setCustomer } = (0, zustand.useStore)(getSfStateContext(), (state) => ({
+			customer: state.customer,
+			setCustomer: state.setCustomer
+		}));
+		return [customer, setCustomer];
+	}
+	return {
+		SfStateProvider,
+		useSfCartState,
+		useSfCurrenciesState,
+		useSfCurrencyState,
+		useSfCustomerState,
+		useSfLocalesState,
+		useSfLocaleState
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
+}
+
+//#endregion
+//#region src/alokai-provider.tsx
+const _excluded = ["SfStateProvider"];
+/**
+* Creates a new Alokai context which is a combination of SDK and state contexts.
+* This function is dedicated for the client-side usage.
+*
+* @example
+* Create a new Alokai context somewhere in your application. It may be the `hooks/sdk.ts` file.
+*
+* ```tsx
+* 'use client';
+*
+* import { createAlokaiContext } from "@vue-storefront/next/client";
+* import type { Sdk } from './sdk.server';
+* import type { SfContract } from 'storefront-middleware/types';
+*
+* export const {
+*  AlokaiProvider,
+*  useSdk,
+*  useSfCartState,
+*  useSfCurrenciesState,
+*  useSfCurrencyState,
+*  useSfCustomerState,
+* } = createAlokaiContext<Sdk, SfContract>();
+* ```
+* This is also a place where you can import hooks for handling the state management.
+* You can read more about the state management in the documentation https://docs.alokai.com/sdk/getting-started/state-management.
+* Then use the `AlokaiProvider` in the root component of your application.
+* For Pages Router it would be the `pages/_app.tsx` file,
+* and for the App Router it would be the `app/layout.tsx` file.
+* Finally, you can use the `useSdk` in any client component of your application.
+* @returns AlokaiProvider - The Alokai Context Provider.
+* @returns useSdk - The SDK provider and the `useSdk` hook.
+* @returns useSfCartState - Hook that return Cart state with `SfCart` type.
+* @returns useSfCurrenciesState - Hook that return Currencies state with `SfCurrency` type.
+* @returns useSfCurrencyState - Hook that return Currency state with `SfCurrency[]` type.
+* @returns useSfCustomerState - Hook that return Customer state with `SfCustomer` type.
+*/
+function createAlokaiContext() {
+	const SdkContext = (0, react.createContext)(null);
+	const _createSfStateProvide = createSfStateProvider(), { SfStateProvider } = _createSfStateProvide, rest = _objectWithoutProperties(_createSfStateProvide, _excluded);
+	function AlokaiProvider({ children, initialData, sdk }) {
+		const publicEnv = typeof window === "undefined" ? getPublicEnv() : void 0;
+		const envScript = publicEnv ? `window['${require_env.PUBLIC_ENV_KEY}'] = ${JSON.stringify(publicEnv)};` : "";
+		return /* @__PURE__ */ react.default.createElement(SdkContext.Provider, { value: sdk }, /* @__PURE__ */ react.default.createElement("meta", {
+			content: "Alokai Storefront",
+			name: "generator"
+		}), publicEnv && /* @__PURE__ */ react.default.createElement(next_script.default, {
+			id: "alokaiEnv",
+			strategy: "beforeInteractive"
+		}, envScript), /* @__PURE__ */ react.default.createElement(__alokai_instrumentation_next_component.AlokaiInstrumentation, null), /* @__PURE__ */ react.default.createElement(SfStateProvider, { initialData }, children));
+	}
+	const useSdk = () => {
+		const contextSdk = (0, react.useContext)(SdkContext);
+		if (!contextSdk) throw new Error("useSdk must be used within a AlokaiProvider");
+		return contextSdk;
+	};
+	return require_env._objectSpread2({
+		AlokaiProvider,
+		useSdk
+	}, rest);
+}
+
+//#endregion
+exports.__toESM = __toESM;
+exports.createAlokaiContext = createAlokaiContext;
+exports.createSfStateProvider = createSfStateProvider;
+exports.env = require_env.env;

package/dist/{client.d.ts → client.d.cts}

@@ -1,8 +1,7 @@
-import { SDKApi } from '@alokai/connect/sdk';
-import { S as SfContract, C as CreateSdkContextReturn } from './types-FGnrBhjy.js';
-export { M as Maybe, b as SfState, a as SfStateProps, c as createSfStateProvider, e as env } from './types-FGnrBhjy.js';
-import 'next/headers';
-import 'react';
+import { c as SfContract, d as createSfStateProvider, l as SfState, r as CreateSdkContextReturn, s as Maybe, t as env, u as SfStateProps } from "./index-D1weTw7N.cjs";
+import { SDKApi } from "@alokai/connect/sdk";
+
+//#region src/alokai-provider.d.ts
 
 /**
  * Creates a new Alokai context which is a combination of SDK and state contexts.
@@ -41,5 +40,5 @@ import 'react';
  * @returns useSfCustomerState - Hook that return Customer state with `SfCustomer` type.
  */
 declare function createAlokaiContext<TSdk extends SDKApi<any>, TSfContract extends SfContract>(): CreateSdkContextReturn<TSdk, TSfContract>;
-
-export { CreateSdkContextReturn, SfContract, createAlokaiContext };
+//#endregion
+export { type CreateSdkContextReturn, Maybe, SfContract, SfState, SfStateProps, createAlokaiContext, createSfStateProvider, env };

package/dist/client.d.mts

@@ -1,8 +1,7 @@
-import { SDKApi } from '@alokai/connect/sdk';
-import { S as SfContract, C as CreateSdkContextReturn } from './types-FGnrBhjy.mjs';
-export { M as Maybe, b as SfState, a as SfStateProps, c as createSfStateProvider, e as env } from './types-FGnrBhjy.mjs';
-import 'next/headers';
-import 'react';
+import { c as SfContract, d as createSfStateProvider, l as SfState, r as CreateSdkContextReturn, s as Maybe, t as env, u as SfStateProps } from "./index-BXYjHxeC.mjs";
+import { SDKApi } from "@alokai/connect/sdk";
+
+//#region src/alokai-provider.d.ts
 
 /**
  * Creates a new Alokai context which is a combination of SDK and state contexts.
@@ -41,5 +40,5 @@ import 'react';
  * @returns useSfCustomerState - Hook that return Customer state with `SfCustomer` type.
  */
 declare function createAlokaiContext<TSdk extends SDKApi<any>, TSfContract extends SfContract>(): CreateSdkContextReturn<TSdk, TSfContract>;
-
-export { CreateSdkContextReturn, SfContract, createAlokaiContext };
+//#endregion
+export { type CreateSdkContextReturn, Maybe, SfContract, SfState, SfStateProps, createAlokaiContext, createSfStateProvider, env };

package/dist/client.mjs

@@ -1,150 +1,191 @@
 "use client";
-import {
-  PUBLIC_ENV_KEY,
-  __objRest,
-  __spreadProps,
-  __spreadValues,
-  env,
-  getPublicEnv
-} from "./chunk-NSPLXZD5.mjs";
 
-// src/alokai-provider.tsx
+import { n as _objectSpread2, r as PUBLIC_ENV_KEY, t as env } from "./env-XPpRDRcE.mjs";
 import { AlokaiInstrumentation } from "@alokai/instrumentation-next-component";
 import Script from "next/script";
-import React2, { createContext as createContext2, useContext as useContext2 } from "react";
-
-// src/state.tsx
-import React, {
-  createContext,
-  useContext,
-  useRef
-} from "react";
+import React, { createContext, useContext, useRef } from "react";
 import { createStore, useStore } from "zustand";
-var createSfState = (initialData) => {
-  return createStore()((set) => __spreadProps(__spreadValues({
-    cart: null,
-    customer: null
-  }, initialData), {
-    setCart: (cart) => set({ cart }),
-    setCurrencies: (currencies) => set({ currencies }),
-    setCurrency: (currency) => set({ currency }),
-    setCustomer: (customer) => set({ customer }),
-    setLocale: (locale) => set({ locale }),
-    setLocales: (locales) => set({ locales })
-  }));
+
+//#region src/env/get-public-env.ts
+/**
+* Extracts all NEXT_PUBLIC_* environment variables from process.env
+* This is used server-side to prepare env vars for injection into the client
+*
+* @returns Object containing all NEXT_PUBLIC_* environment variables
+*/
+function getPublicEnv() {
+	const publicEnv = {};
+	for (const key in process.env) if (key.startsWith("NEXT_PUBLIC_")) publicEnv[key] = process.env[key];
+	return publicEnv;
+}
+
+//#endregion
+//#region src/state.tsx
+const createSfState = (initialData) => {
+	return createStore()((set) => _objectSpread2(_objectSpread2({
+		cart: null,
+		customer: null
+	}, initialData), {}, {
+		setCart: (cart) => set({ cart }),
+		setCurrencies: (currencies) => set({ currencies }),
+		setCurrency: (currency) => set({ currency }),
+		setCustomer: (customer) => set({ customer }),
+		setLocale: (locale) => set({ locale }),
+		setLocales: (locales) => set({ locales })
+	}));
 };
 function createSfStateProvider() {
-  const SfStateContext = createContext(null);
-  function SfStateProvider({
-    children,
-    initialData
-  }) {
-    const stateReference = useRef();
-    if (!stateReference.current) {
-      stateReference.current = createSfState(initialData);
-    }
-    return /* @__PURE__ */ React.createElement(SfStateContext.Provider, { value: stateReference.current }, children);
-  }
-  function getSfStateContext() {
-    const context = useContext(SfStateContext);
-    if (!context)
-      throw new Error("Missing SfStateContext.Provider in the tree");
-    return context;
-  }
-  function useSfCurrencyState() {
-    const { currency, setCurrency } = useStore(
-      getSfStateContext(),
-      (state) => ({
-        currency: state.currency,
-        setCurrency: state.setCurrency
-      })
-    );
-    return [currency, setCurrency];
-  }
-  function useSfCurrenciesState() {
-    const { currencies, setCurrencies } = useStore(
-      getSfStateContext(),
-      (state) => ({
-        currencies: state.currencies,
-        setCurrencies: state.setCurrencies
-      })
-    );
-    return [currencies, setCurrencies];
-  }
-  function useSfLocaleState() {
-    const { locale, setLocale } = useStore(getSfStateContext(), (state) => ({
-      locale: state.locale,
-      setLocale: state.setLocale
-    }));
-    return [locale, setLocale];
-  }
-  function useSfLocalesState() {
-    const { locales, setLocales } = useStore(getSfStateContext(), (state) => ({
-      locales: state.locales,
-      setLocales: state.setLocales
-    }));
-    return [locales, setLocales];
-  }
-  function useSfCartState() {
-    const { cart, setCart } = useStore(getSfStateContext(), (state) => ({
-      cart: state.cart,
-      setCart: state.setCart
-    }));
-    return [cart, setCart];
-  }
-  function useSfCustomerState() {
-    const { customer, setCustomer } = useStore(
-      getSfStateContext(),
-      (state) => ({
-        customer: state.customer,
-        setCustomer: state.setCustomer
-      })
-    );
-    return [customer, setCustomer];
-  }
-  return {
-    SfStateProvider,
-    useSfCartState,
-    useSfCurrenciesState,
-    useSfCurrencyState,
-    useSfCustomerState,
-    useSfLocalesState,
-    useSfLocaleState
-  };
+	const SfStateContext = createContext(null);
+	function SfStateProvider({ children, initialData }) {
+		const stateReference = useRef(null);
+		if (!stateReference.current) stateReference.current = createSfState(initialData);
+		return /* @__PURE__ */ React.createElement(SfStateContext.Provider, { value: stateReference.current }, children);
+	}
+	function getSfStateContext() {
+		const context = useContext(SfStateContext);
+		if (!context) throw new Error("Missing SfStateContext.Provider in the tree");
+		return context;
+	}
+	function useSfCurrencyState() {
+		const { currency, setCurrency } = useStore(getSfStateContext(), (state) => ({
+			currency: state.currency,
+			setCurrency: state.setCurrency
+		}));
+		return [currency, setCurrency];
+	}
+	function useSfCurrenciesState() {
+		const { currencies, setCurrencies } = useStore(getSfStateContext(), (state) => ({
+			currencies: state.currencies,
+			setCurrencies: state.setCurrencies
+		}));
+		return [currencies, setCurrencies];
+	}
+	function useSfLocaleState() {
+		const { locale, setLocale } = useStore(getSfStateContext(), (state) => ({
+			locale: state.locale,
+			setLocale: state.setLocale
+		}));
+		return [locale, setLocale];
+	}
+	function useSfLocalesState() {
+		const { locales, setLocales } = useStore(getSfStateContext(), (state) => ({
+			locales: state.locales,
+			setLocales: state.setLocales
+		}));
+		return [locales, setLocales];
+	}
+	function useSfCartState() {
+		const { cart, setCart } = useStore(getSfStateContext(), (state) => ({
+			cart: state.cart,
+			setCart: state.setCart
+		}));
+		return [cart, setCart];
+	}
+	function useSfCustomerState() {
+		const { customer, setCustomer } = useStore(getSfStateContext(), (state) => ({
+			customer: state.customer,
+			setCustomer: state.setCustomer
+		}));
+		return [customer, setCustomer];
+	}
+	return {
+		SfStateProvider,
+		useSfCartState,
+		useSfCurrenciesState,
+		useSfCurrencyState,
+		useSfCustomerState,
+		useSfLocalesState,
+		useSfLocaleState
+	};
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.101.0/helpers/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
 }
 
-// src/alokai-provider.tsx
+//#endregion
+//#region src/alokai-provider.tsx
+const _excluded = ["SfStateProvider"];
+/**
+* Creates a new Alokai context which is a combination of SDK and state contexts.
+* This function is dedicated for the client-side usage.
+*
+* @example
+* Create a new Alokai context somewhere in your application. It may be the `hooks/sdk.ts` file.
+*
+* ```tsx
+* 'use client';
+*
+* import { createAlokaiContext } from "@vue-storefront/next/client";
+* import type { Sdk } from './sdk.server';
+* import type { SfContract } from 'storefront-middleware/types';
+*
+* export const {
+*  AlokaiProvider,
+*  useSdk,
+*  useSfCartState,
+*  useSfCurrenciesState,
+*  useSfCurrencyState,
+*  useSfCustomerState,
+* } = createAlokaiContext<Sdk, SfContract>();
+* ```
+* This is also a place where you can import hooks for handling the state management.
+* You can read more about the state management in the documentation https://docs.alokai.com/sdk/getting-started/state-management.
+* Then use the `AlokaiProvider` in the root component of your application.
+* For Pages Router it would be the `pages/_app.tsx` file,
+* and for the App Router it would be the `app/layout.tsx` file.
+* Finally, you can use the `useSdk` in any client component of your application.
+* @returns AlokaiProvider - The Alokai Context Provider.
+* @returns useSdk - The SDK provider and the `useSdk` hook.
+* @returns useSfCartState - Hook that return Cart state with `SfCart` type.
+* @returns useSfCurrenciesState - Hook that return Currencies state with `SfCurrency` type.
+* @returns useSfCurrencyState - Hook that return Currency state with `SfCurrency[]` type.
+* @returns useSfCustomerState - Hook that return Customer state with `SfCustomer` type.
+*/
 function createAlokaiContext() {
-  const SdkContext = createContext2(null);
-  const _a = createSfStateProvider(), { SfStateProvider } = _a, rest = __objRest(_a, ["SfStateProvider"]);
-  function AlokaiProvider({
-    children,
-    initialData,
-    sdk
-  }) {
-    const metaTagScript = `
-      const vsfMetaTag = document.createElement("meta");
-      vsfMetaTag.setAttribute("name", "generator");
-      vsfMetaTag.setAttribute("content", "Alokai Storefront");
-      document.head.appendChild(vsfMetaTag);
-    `;
-    const publicEnv = typeof window === "undefined" ? getPublicEnv() : void 0;
-    const envScript = publicEnv ? `window['${PUBLIC_ENV_KEY}'] = ${JSON.stringify(publicEnv)};` : "";
-    return /* @__PURE__ */ React2.createElement(SdkContext.Provider, { value: sdk }, publicEnv && /* @__PURE__ */ React2.createElement(Script, { id: "alokaiEnv", strategy: "beforeInteractive" }, envScript), /* @__PURE__ */ React2.createElement(Script, { id: "vsfMetaTag", strategy: "beforeInteractive" }, `
-            ${metaTagScript}
-          `), /* @__PURE__ */ React2.createElement(AlokaiInstrumentation, null), /* @__PURE__ */ React2.createElement(SfStateProvider, { initialData }, children));
-  }
-  const useSdk = () => {
-    const contextSdk = useContext2(SdkContext);
-    if (!contextSdk) {
-      throw new Error("useSdk must be used within a AlokaiProvider");
-    }
-    return contextSdk;
-  };
-  return __spreadValues({ AlokaiProvider, useSdk }, rest);
+	const SdkContext = createContext(null);
+	const _createSfStateProvide = createSfStateProvider(), { SfStateProvider } = _createSfStateProvide, rest = _objectWithoutProperties(_createSfStateProvide, _excluded);
+	function AlokaiProvider({ children, initialData, sdk }) {
+		const publicEnv = typeof window === "undefined" ? getPublicEnv() : void 0;
+		const envScript = publicEnv ? `window['${PUBLIC_ENV_KEY}'] = ${JSON.stringify(publicEnv)};` : "";
+		return /* @__PURE__ */ React.createElement(SdkContext.Provider, { value: sdk }, /* @__PURE__ */ React.createElement("meta", {
+			content: "Alokai Storefront",
+			name: "generator"
+		}), publicEnv && /* @__PURE__ */ React.createElement(Script, {
+			id: "alokaiEnv",
+			strategy: "beforeInteractive"
+		}, envScript), /* @__PURE__ */ React.createElement(AlokaiInstrumentation, null), /* @__PURE__ */ React.createElement(SfStateProvider, { initialData }, children));
+	}
+	const useSdk = () => {
+		const contextSdk = useContext(SdkContext);
+		if (!contextSdk) throw new Error("useSdk must be used within a AlokaiProvider");
+		return contextSdk;
+	};
+	return _objectSpread2({
+		AlokaiProvider,
+		useSdk
+	}, rest);
 }
-export {
-  createAlokaiContext,
-  createSfStateProvider,
-  env
-};
+
+//#endregion
+export { createAlokaiContext, createSfStateProvider, env };