@wix/headless-stores 0.0.0

package/dist/services/pay-now-service.js

@@ -0,0 +1,156 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+/**
+ * Service definition for the Pay Now service.
+ * This defines the reactive API contract for managing custom payment checkout functionality.
+ *
+ * @constant
+ */
+export const PayNowServiceDefinition = defineService('PayNow');
+/**
+ * Implementation of the Pay Now service that manages custom payment checkout functionality.
+ * This service provides signals for loading state and error handling, along with a method
+ * to redirect to checkout using a custom checkout action.
+ *
+ * @example
+ * ```tsx
+ * import { PayNowServiceImplementation, PayNowServiceDefinition } from '@wix/stores/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function PayNowComponent({ payNowConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [PayNowServiceDefinition, PayNowServiceImplementation.withConfig(payNowConfig)]
+ *     ])}>
+ *       <PayNowButton />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function PayNowButton() {
+ *   const payNowService = useService(PayNowServiceDefinition);
+ *   const isLoading = payNowService.loadingSignal.get();
+ *   const error = payNowService.errorSignal.get();
+ *
+ *   const handlePayNow = async () => {
+ *     await payNowService.redirectToCheckout();
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       {error && <div className="error">{error}</div>}
+ *       <button
+ *         onClick={handlePayNow}
+ *         disabled={isLoading}
+ *         className="pay-now-btn"
+ *       >
+ *         {isLoading ? 'Processing...' : 'Pay Now'}
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export const PayNowServiceImplementation = implementService.withConfig()(PayNowServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const loadingSignal = signalsService.signal(false);
+    const errorSignal = signalsService.signal(null);
+    return {
+        redirectToCheckout: async () => {
+            loadingSignal.set(true);
+            try {
+                if (config.customCheckoutAction) {
+                    const result = await config.customCheckoutAction();
+                    if (result && result.data) {
+                        window.location.href = result.data;
+                    }
+                    else {
+                        throw new Error('Failed to create checkout' + result?.error);
+                    }
+                }
+            }
+            catch (error) {
+                errorSignal.set(error.toString());
+                loadingSignal.set(false);
+            }
+        },
+        loadingSignal,
+        errorSignal,
+    };
+});
+/**
+ * Loads pay now service initial data for SSR initialization.
+ * This function returns an empty configuration as the Pay Now service
+ * is typically configured with custom checkout actions at runtime.
+ *
+ * @returns {Promise} Promise that resolves to an empty pay now service configuration
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example
+ * import { loadPayNowServiceInitialData } from '@wix/stores/services';
+ * import { PayNow } from '@wix/stores/components';
+ *
+ * // Load initial data (empty for PayNow)
+ * const payNowData = await loadPayNowServiceInitialData();
+ * ---
+ *
+ * <PayNow.PayNow payNowConfig={payNowData.PayNow}>
+ *   {({ redirectToCheckout, isLoading, error }) => (
+ *     <button onClick={redirectToCheckout} disabled={isLoading}>
+ *       {isLoading ? 'Processing...' : 'Pay Now'}
+ *     </button>
+ *   )}
+ * </PayNow.PayNow>
+ * ```
+ */
+export const loadPayNowServiceInitialData = async () => {
+    return {
+        [PayNowServiceDefinition]: {},
+    };
+};
+/**
+ * Helper function to create a pay now service binding with configuration.
+ * This function simplifies the process of binding the pay now service with its configuration
+ * and allows for additional configuration overrides, particularly for custom checkout actions.
+ *
+ * @template T - Type of the services configurations object
+ * @param {T} servicesConfigs - Object containing service configurations
+ * @param {Partial<PayNowServiceConfig>} [additionalConfig={}] - Additional configuration to override defaults
+ * @returns Tuple containing service definition, implementation, and merged configuration
+ *
+ * @example
+ * ```tsx
+ * import { payNowServiceBinding, loadPayNowServiceInitialData } from '@wix/stores/services';
+ * import { actions } from 'astro:actions';
+ *
+ * // Load initial data
+ * const initialData = await loadPayNowServiceInitialData();
+ *
+ * // Create service binding with custom checkout action
+ * const payNowBinding = payNowServiceBinding(initialData, {
+ *   customCheckoutAction: async () => {
+ *     try {
+ *       const result = await actions.customCheckout();
+ *       return { data: result, error: null };
+ *     } catch (error) {
+ *       return { data: undefined, error };
+ *     }
+ *   }
+ * });
+ *
+ * // Use in service provider
+ * const services = createServicesMap([payNowBinding]);
+ * ```
+ */
+export const payNowServiceBinding = (servicesConfigs, additionalConfig = {}) => {
+    return [
+        PayNowServiceDefinition,
+        PayNowServiceImplementation,
+        {
+            ...servicesConfigs[PayNowServiceDefinition],
+            ...additionalConfig,
+        },
+    ];
+};

package/dist/services/product-modifiers-service.d.ts

@@ -0,0 +1,34 @@
+import { type ServiceFactoryConfig } from '@wix/services-definitions';
+import { type Signal, type ReadOnlySignal } from '@wix/services-definitions/core-services/signals';
+import * as productsV3 from '@wix/auto_sdk_stores_products-v-3';
+export interface ModifierValue {
+    modifierName: string;
+    choiceValue?: string;
+    freeTextValue?: string;
+}
+export interface ProductModifiersServiceAPI {
+    modifiers: ReadOnlySignal<productsV3.ConnectedModifier[]>;
+    selectedModifiers: Signal<Record<string, ModifierValue>>;
+    hasModifiers: ReadOnlySignal<boolean>;
+    isLoading: Signal<boolean>;
+    error: Signal<string | null>;
+    setModifierChoice: (modifierName: string, choiceValue: string) => void;
+    setModifierFreeText: (modifierName: string, freeTextValue: string) => void;
+    clearModifier: (modifierName: string) => void;
+    clearAllModifiers: () => void;
+    getModifierValue: (modifierName: string) => ModifierValue | null;
+    isModifierRequired: (modifierName: string) => boolean;
+    hasRequiredModifiers: () => boolean;
+    areAllRequiredModifiersFilled: () => boolean;
+}
+export declare const ProductModifiersServiceDefinition: string & {
+    __api: ProductModifiersServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductModifiersServiceAPI;
+export declare const ProductModifiersService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ProductModifiersServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductModifiersServiceAPI, unknown>;
+export declare function createProductModifiersServiceConfig(product: productsV3.V3Product): ServiceFactoryConfig<typeof ProductModifiersService>;

package/dist/services/product-modifiers-service.js

@@ -0,0 +1,107 @@
+import { defineService, implementService, } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import * as productsV3 from '@wix/auto_sdk_stores_products-v-3';
+import { ProductServiceDefinition } from './product-service.js';
+export const ProductModifiersServiceDefinition = defineService('productModifiers');
+export const ProductModifiersService = implementService.withConfig()(ProductModifiersServiceDefinition, ({ getService }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const productService = getService(ProductServiceDefinition);
+    const selectedModifiers = signalsService.signal({});
+    const isLoading = signalsService.signal(false);
+    const error = signalsService.signal(null);
+    // Extract modifiers from product
+    const modifiers = signalsService.computed(() => {
+        const configProduct = productService.product.get();
+        return (configProduct?.modifiers || []);
+    });
+    const hasModifiers = signalsService.computed(() => {
+        const mods = modifiers.get();
+        return mods.length > 0;
+    });
+    const setModifierChoice = (modifierName, choiceValue) => {
+        const current = selectedModifiers.get();
+        selectedModifiers.set({
+            ...current,
+            [modifierName]: {
+                modifierName,
+                choiceValue,
+            },
+        });
+    };
+    const setModifierFreeText = (modifierName, freeTextValue) => {
+        const current = selectedModifiers.get();
+        selectedModifiers.set({
+            ...current,
+            [modifierName]: {
+                modifierName,
+                freeTextValue,
+            },
+        });
+    };
+    const clearModifier = (modifierName) => {
+        const current = selectedModifiers.get();
+        const updated = { ...current };
+        delete updated[modifierName];
+        selectedModifiers.set(updated);
+    };
+    const clearAllModifiers = () => {
+        selectedModifiers.set({});
+    };
+    const getModifierValue = (modifierName) => {
+        const current = selectedModifiers.get();
+        return current[modifierName] || null;
+    };
+    const isModifierRequired = (modifierName) => {
+        const mods = modifiers.get();
+        const modifier = mods.find((m) => m.name === modifierName);
+        return modifier?.mandatory || false;
+    };
+    const hasRequiredModifiers = () => {
+        const mods = modifiers.get();
+        return mods.some((m) => m.mandatory);
+    };
+    const areAllRequiredModifiersFilled = () => {
+        const mods = modifiers.get();
+        const current = selectedModifiers.get();
+        return mods.every((modifier) => {
+            if (!modifier.mandatory)
+                return true;
+            const selectedValue = current[modifier.name || ''];
+            if (!selectedValue)
+                return false;
+            // Check based on modifier type
+            const renderType = modifier.modifierRenderType;
+            if (!renderType)
+                return false;
+            if (renderType === productsV3.ModifierRenderType.SWATCH_CHOICES ||
+                renderType === productsV3.ModifierRenderType.TEXT_CHOICES) {
+                return !!selectedValue.choiceValue;
+            }
+            else if (renderType === productsV3.ModifierRenderType.FREE_TEXT) {
+                return (!!selectedValue.freeTextValue &&
+                    selectedValue.freeTextValue.trim() !== '');
+            }
+            return false;
+        });
+    };
+    return {
+        modifiers,
+        selectedModifiers,
+        hasModifiers,
+        isLoading,
+        error,
+        setModifierChoice,
+        setModifierFreeText,
+        clearModifier,
+        clearAllModifiers,
+        getModifierValue,
+        isModifierRequired,
+        hasRequiredModifiers,
+        areAllRequiredModifiersFilled,
+    };
+});
+export function createProductModifiersServiceConfig(product) {
+    return {
+        product,
+    };
+}

package/dist/services/product-service.d.ts

@@ -0,0 +1,177 @@
+import { type Signal } from '@wix/services-definitions/core-services/signals';
+import * as productsV3 from '@wix/auto_sdk_stores_products-v-3';
+/**
+ * API interface for the Product service, providing reactive product data management.
+ * This service handles loading and managing a single product's data, loading state, and errors.
+ *
+ * @interface ProductServiceAPI
+ */
+export interface ProductServiceAPI {
+    /** Reactive signal containing the current product data */
+    product: Signal<productsV3.V3Product>;
+    /** Reactive signal indicating if a product is currently being loaded */
+    isLoading: Signal<boolean>;
+    /** Reactive signal containing any error message, or null if no error */
+    error: Signal<string | null>;
+    /** Function to load a product by its slug */
+    loadProduct: (slug: string) => Promise<void>;
+}
+/**
+ * Service definition for the Product service.
+ * This defines the contract that the ProductService must implement.
+ *
+ * @constant
+ */
+export declare const ProductServiceDefinition: string & {
+    __api: ProductServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductServiceAPI;
+/**
+ * Configuration interface required to initialize the ProductService.
+ * Contains the initial product data that will be loaded into the service.
+ *
+ * @interface ProductServiceConfig
+ */
+export interface ProductServiceConfig {
+    /** The initial product data to configure the service with */
+    product?: productsV3.V3Product;
+    productSlug?: string;
+}
+/**
+ * Implementation of the Product service that manages reactive product data.
+ * This service provides signals for product data, loading state, and error handling,
+ * along with methods to dynamically load products.
+ *
+ * @example
+ * ```tsx
+ * import { ProductService, ProductServiceDefinition } from '@wix/stores/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function ProductComponent({ productConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [ProductServiceDefinition, ProductService.withConfig(productConfig)]
+ *     ])}>
+ *       <ProductDisplay />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function ProductDisplay() {
+ *   const productService = useService(ProductServiceDefinition);
+ *   const product = productService.product.get();
+ *   const isLoading = productService.isLoading.get();
+ *   const error = productService.error.get();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return <h1>{product.name}</h1>;
+ * }
+ * ```
+ */
+export declare const ProductService: import("@wix/services-definitions").ServiceFactory<string & {
+    __api: ProductServiceAPI;
+    __config: {};
+    isServiceDefinition?: boolean;
+} & ProductServiceAPI, ProductServiceConfig>;
+/**
+ * Success result interface for product service configuration loading.
+ * Returned when a product is successfully found and loaded.
+ *
+ * @interface SuccessProductServiceConfigResult
+ */
+export interface SuccessProductServiceConfigResult {
+    /** Type "success" means that the product was found and the config is valid */
+    type: 'success';
+    /** The product config containing the loaded product data */
+    config: ProductServiceConfig;
+}
+/**
+ * Not found result interface for product service configuration loading.
+ * Returned when a product with the given slug cannot be found.
+ *
+ * @interface NotFoundProductServiceConfigResult
+ */
+export interface NotFoundProductServiceConfigResult {
+    /** Type "notFound" means that the product was not found */
+    type: 'notFound';
+}
+/**
+ * Loads product service configuration from the Wix Products API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific product by slug that will be used to configure the ProductService.
+ *
+ * @param productSlug The product slug to load
+ * @returns Promise that resolves to ProductServiceConfigResult (success with config or notFound)
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example - pages/product/[slug].astro
+ * import { loadProductServiceConfig } from '@wix/stores/services';
+ * import { Product } from '@wix/stores/components';
+ *
+ * // Get product slug from URL params
+ * const { slug } = Astro.params;
+ *
+ * // Load product data during SSR
+ * const productResult = await loadProductServiceConfig(slug);
+ *
+ * // Handle not found case
+ * if (productResult.type === 'notFound') {
+ *   return Astro.redirect('/404');
+ * }
+ * ---
+ *
+ * <Product.Root productConfig={productResult.config}>
+ *   <Product.Name>
+ *     {({ name }) => <h1>{name}</h1>}
+ *   </Product.Name>
+ * </Product.Root>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Next.js page example - pages/product/[slug].tsx
+ * import { GetServerSideProps } from 'next';
+ * import { loadProductServiceConfig } from '@wix/stores/services';
+ * import { Product } from '@wix/stores/components';
+ *
+ * interface ProductPageProps {
+ *   productConfig: Extract<Awaited<ReturnType<typeof loadProductServiceConfig>>, { type: 'success' }>['config'];
+ * }
+ *
+ * export const getServerSideProps: GetServerSideProps<ProductPageProps> = async ({ params }) => {
+ *   const slug = params?.slug as string;
+ *
+ *   // Load product data during SSR
+ *   const productResult = await loadProductServiceConfig(slug);
+ *
+ *   // Handle not found case
+ *   if (productResult.type === 'notFound') {
+ *     return {
+ *       notFound: true,
+ *     };
+ *   }
+ *
+ *   return {
+ *     props: {
+ *       productConfig: productResult.config,
+ *     },
+ *   };
+ * };
+ *
+ * export default function ProductPage({ productConfig }: ProductPageProps) {
+ *   return (
+ *     <Product.Root productConfig={productConfig}>
+ *       <Product.Name>
+ *         {({ name }) => <h1>{name}</h1>}
+ *       </Product.Name>
+ *     </Product.Root>
+ *   );
+ * }
+ * ```
+ */
+export declare function loadProductServiceConfig(productSlug: string): Promise<SuccessProductServiceConfigResult | NotFoundProductServiceConfigResult>;

package/dist/services/product-service.js

@@ -0,0 +1,190 @@
+import { defineService, implementService } from '@wix/services-definitions';
+import { SignalsServiceDefinition, } from '@wix/services-definitions/core-services/signals';
+import * as productsV3 from '@wix/auto_sdk_stores_products-v-3';
+/**
+ * Service definition for the Product service.
+ * This defines the contract that the ProductService must implement.
+ *
+ * @constant
+ */
+export const ProductServiceDefinition = defineService('product');
+/**
+ * Implementation of the Product service that manages reactive product data.
+ * This service provides signals for product data, loading state, and error handling,
+ * along with methods to dynamically load products.
+ *
+ * @example
+ * ```tsx
+ * import { ProductService, ProductServiceDefinition } from '@wix/stores/services';
+ * import { useService } from '@wix/services-manager-react';
+ *
+ * function ProductComponent({ productConfig }) {
+ *   return (
+ *     <ServiceProvider services={createServicesMap([
+ *       [ProductServiceDefinition, ProductService.withConfig(productConfig)]
+ *     ])}>
+ *       <ProductDisplay />
+ *     </ServiceProvider>
+ *   );
+ * }
+ *
+ * function ProductDisplay() {
+ *   const productService = useService(ProductServiceDefinition);
+ *   const product = productService.product.get();
+ *   const isLoading = productService.isLoading.get();
+ *   const error = productService.error.get();
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error}</div>;
+ *
+ *   return <h1>{product.name}</h1>;
+ * }
+ * ```
+ */
+export const ProductService = implementService.withConfig()(ProductServiceDefinition, ({ getService, config }) => {
+    const signalsService = getService(SignalsServiceDefinition);
+    const product = signalsService.signal(config.product);
+    const isLoading = signalsService.signal(!!config.productSlug);
+    const error = signalsService.signal(null);
+    const loadProduct = async (slug) => {
+        isLoading.set(true);
+        const productResponse = await loadProductBySlug(slug);
+        if (!productResponse.product) {
+            error.set('Product not found');
+        }
+        else {
+            product.set(productResponse.product);
+            error.set(null);
+        }
+        isLoading.set(false);
+    };
+    if (config.productSlug) {
+        loadProduct(config.productSlug);
+    }
+    return {
+        product,
+        isLoading,
+        error,
+        loadProduct,
+    };
+});
+/**
+ * Internal helper function to load a product by its slug from the Wix Products API.
+ * Fetches comprehensive product data including description, categories, media, etc.
+ *
+ * @private
+ * @param {string} slug - The product slug to load
+ * @returns {Promise} Product response from the API
+ */
+const loadProductBySlug = async (slug) => {
+    const productResponse = await productsV3.getProductBySlug(slug, {
+        fields: [
+            'DESCRIPTION',
+            'DIRECT_CATEGORIES_INFO',
+            'BREADCRUMBS_INFO',
+            'INFO_SECTION',
+            'MEDIA_ITEMS_INFO',
+            'PLAIN_DESCRIPTION',
+            'THUMBNAIL',
+            'URL',
+            'VARIANT_OPTION_CHOICE_NAMES',
+            'WEIGHT_MEASUREMENT_UNIT_INFO',
+        ],
+    });
+    return productResponse;
+};
+/**
+ * Loads product service configuration from the Wix Products API for SSR initialization.
+ * This function is designed to be used during Server-Side Rendering (SSR) to preload
+ * a specific product by slug that will be used to configure the ProductService.
+ *
+ * @param productSlug The product slug to load
+ * @returns Promise that resolves to ProductServiceConfigResult (success with config or notFound)
+ *
+ * @example
+ * ```astro
+ * ---
+ * // Astro page example - pages/product/[slug].astro
+ * import { loadProductServiceConfig } from '@wix/stores/services';
+ * import { Product } from '@wix/stores/components';
+ *
+ * // Get product slug from URL params
+ * const { slug } = Astro.params;
+ *
+ * // Load product data during SSR
+ * const productResult = await loadProductServiceConfig(slug);
+ *
+ * // Handle not found case
+ * if (productResult.type === 'notFound') {
+ *   return Astro.redirect('/404');
+ * }
+ * ---
+ *
+ * <Product.Root productConfig={productResult.config}>
+ *   <Product.Name>
+ *     {({ name }) => <h1>{name}</h1>}
+ *   </Product.Name>
+ * </Product.Root>
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Next.js page example - pages/product/[slug].tsx
+ * import { GetServerSideProps } from 'next';
+ * import { loadProductServiceConfig } from '@wix/stores/services';
+ * import { Product } from '@wix/stores/components';
+ *
+ * interface ProductPageProps {
+ *   productConfig: Extract<Awaited<ReturnType<typeof loadProductServiceConfig>>, { type: 'success' }>['config'];
+ * }
+ *
+ * export const getServerSideProps: GetServerSideProps<ProductPageProps> = async ({ params }) => {
+ *   const slug = params?.slug as string;
+ *
+ *   // Load product data during SSR
+ *   const productResult = await loadProductServiceConfig(slug);
+ *
+ *   // Handle not found case
+ *   if (productResult.type === 'notFound') {
+ *     return {
+ *       notFound: true,
+ *     };
+ *   }
+ *
+ *   return {
+ *     props: {
+ *       productConfig: productResult.config,
+ *     },
+ *   };
+ * };
+ *
+ * export default function ProductPage({ productConfig }: ProductPageProps) {
+ *   return (
+ *     <Product.Root productConfig={productConfig}>
+ *       <Product.Name>
+ *         {({ name }) => <h1>{name}</h1>}
+ *       </Product.Name>
+ *     </Product.Root>
+ *   );
+ * }
+ * ```
+ */
+export async function loadProductServiceConfig(productSlug) {
+    try {
+        // Use getProductBySlug directly - single API call with comprehensive fields
+        const productResponse = await loadProductBySlug(productSlug);
+        if (!productResponse.product) {
+            return { type: 'notFound' };
+        }
+        return {
+            type: 'success',
+            config: {
+                product: productResponse.product,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`Failed to load product for slug "${productSlug}":`, error);
+        return { type: 'notFound' };
+    }
+}

package/dist/services/products-list-search-service.js

@@ -0,0 +1 @@
+"use strict";