@meeovi/layer-commerce 1.0.4 → 1.0.5

package/app/components/catalog/product/ProductAccordion/types.ts

@@ -1,4 +1,4 @@
-import type { Product } from '../../../composables/_types'
+import type { Product } from '../../../../composables/_types'
 
 export type ProductAccordionPropsType = {
   product: Product

package/app/components/catalog/product/ProductProperties/types.ts

@@ -1,4 +1,4 @@
-import type { Product } from '../../../composables/_types'
+import type { Product } from '../../../../composables/_types'
 
 export type ProductPropertiesProps = {
   product: Product

package/app/components/catalog/product/ProductSlider/types.ts

@@ -1,5 +1,5 @@
 import type { HTMLAttributes } from 'vue'
-import type { Product } from '../../../composables/_types'
+import type { Product } from '../../../../composables/_types'
 
 export type ProductSliderProps = {
   items?: Product[]

package/app/components/catalog/product/RecommendedProducts/types.ts

@@ -1,4 +1,4 @@
-import type { Product } from '../../../composables/_types'
+import type { Product } from '../../../../composables/_types'
 
 export type RecommendedProductsProps = {
   products: Product[]

package/app/components/sales/CheckoutAddress/types.ts

@@ -1,4 +1,4 @@
-import type { Maybe } from '../../composables/_types'
+import type { Maybe } from '../../../composables/_types'
 
 export interface Address {
   streetNumber?: Maybe<string>

package/app/components/sales/OrderSummary/types.ts

@@ -1,4 +1,4 @@
-import type { Cart } from '../../composables/_types'
+import type { Cart } from '../../../composables/_types'
 
 export type OrderSummaryPropsType = {
   cart: Cart

package/app/composables/_types.ts

@@ -1,10 +1,11 @@
 export type Maybe<T> = T | null | undefined;
 
 // Re-export or alias common legacy names expected by the composables
-export type SfProduct = import('@meeovi/commerce').Product;
-export type Product = import('@meeovi/commerce').Product;
-export type SfCart = import('@meeovi/commerce').Cart;
-export type Cart = import('@meeovi/commerce').Cart;
+// Fallback permissive types for isolated builds
+export type SfProduct = any;
+export type Product = any;
+export type SfCart = any;
+export type Cart = any;
 
 // No direct equivalents in @meeovi/commerce yet — use permissive any types
 export type SfCustomer = any;
@@ -14,4 +15,4 @@ export type SfShippingMethods = any;
 export type SfAttribute = any;
 
 // Export additional useful types from the commerce package if needed
-export type Category = import('@meeovi/commerce').Category;
+export type Category = any;

package/app/composables/stores/cart.ts

@@ -1,6 +1,6 @@
 import { ref, computed, readonly } from 'vue'
 import type { Cart, CartItem, Product } from '../types'
-import { useCart } from '../composables/cart/useCart'
+import { useCart } from '../cart/useCart'
 import { defineStore } from 'pinia'
 
 export const useCartStore = defineStore('cart', () => {
@@ -19,7 +19,7 @@ export const useCartStore = defineStore('cart', () => {
     clearCart,
     setShippingOption: setShippingOptionFn
     ,createCheckoutSession: createCheckoutSessionFn
-  } = useCart()
+  } = useCart() as any
   
   const initializeCart = async () => {
     loading.value = true

package/app/composables/useProductReviews/useProductReviews.ts

@@ -32,7 +32,7 @@ export const useProductReviews: UseProductReviews = (slug) => {
   const fetchProductReviews: FetchProductReviews = async (slug) => {
     state.value.loading = true;
     const client = getCommerceClient();
-    const { data, error } = await useAsyncData(() => client.listProductReviews?.(productId) ?? client.listReviews?.(productId));
+      const { data, error } = await useAsyncData(() => client.listProductReviews?.(slug) ?? client.listReviews?.(slug));
     useHandleError(error.value);
     state.value.data = data.value as unknown as Maybe<SfProductReview[]>;
     state.value.loading = false;

package/app/modules/vue-head/composables/useHead.ts

@@ -0,0 +1,3 @@
+export default function useHead(_: any = {}) {
+  return {}
+}

package/dist/components/catalog/product/ProductAccordion/types.d.ts

@@ -0,0 +1,4 @@
+import type { Product } from '../../../../composables/_types';
+export type ProductAccordionPropsType = {
+    product: Product;
+};

package/dist/components/catalog/product/ProductAccordion/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/catalog/product/ProductProperties/types.d.ts

@@ -0,0 +1,4 @@
+import type { Product } from '../../../../composables/_types';
+export type ProductPropertiesProps = {
+    product: Product;
+};

package/dist/components/catalog/product/ProductProperties/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/catalog/product/ProductSlider/types.d.ts

@@ -0,0 +1,6 @@
+import type { HTMLAttributes } from 'vue';
+import type { Product } from '../../../../composables/_types';
+export type ProductSliderProps = {
+    items?: Product[];
+    wrapperClass?: HTMLAttributes['class'];
+};

package/dist/components/catalog/product/ProductSlider/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/catalog/product/RecommendedProducts/types.d.ts

@@ -0,0 +1,4 @@
+import type { Product } from '../../../../composables/_types';
+export type RecommendedProductsProps = {
+    products: Product[];
+};

package/dist/components/catalog/product/RecommendedProducts/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/sales/CheckoutAddress/types.d.ts

@@ -0,0 +1,14 @@
+import type { Maybe } from '../../../composables/_types';
+export interface Address {
+    streetNumber?: Maybe<string>;
+    phone?: Maybe<string>;
+    streetName?: Maybe<string>;
+    [key: string]: any;
+}
+export type CheckoutAddressProps = {
+    type: 'billingAddress' | 'shippingAddress';
+    heading: string;
+    description: string;
+    buttonText: string;
+    savedAddress?: Maybe<Address>;
+};

package/dist/components/sales/CheckoutAddress/types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/sales/CheckoutPayment/types.d.ts

@@ -0,0 +1,10 @@
+export declare enum PaymentMethod {
+    CreditCard = "credit-card",
+    PayPal = "pay-pal",
+    ApplePay = "apple-pay",
+    GooglePay = "google-pay"
+}
+export type CheckoutPaymentProps = {
+    activePayment: string;
+};
+export type CheckoutPaymentEmits = (event: 'update:activePayment', parameter: PaymentMethod) => void;

package/dist/components/sales/CheckoutPayment/types.js

@@ -0,0 +1,7 @@
+export var PaymentMethod;
+(function (PaymentMethod) {
+    PaymentMethod["CreditCard"] = "credit-card";
+    PaymentMethod["PayPal"] = "pay-pal";
+    PaymentMethod["ApplePay"] = "apple-pay";
+    PaymentMethod["GooglePay"] = "google-pay";
+})(PaymentMethod || (PaymentMethod = {}));

package/dist/components/sales/OrderSummary/types.d.ts

@@ -0,0 +1,4 @@
+import type { Cart } from '../../../composables/_types';
+export type OrderSummaryPropsType = {
+    cart: Cart;
+};

package/dist/components/sales/OrderSummary/types.js

@@ -0,0 +1 @@
+export {};

package/dist/composables/_types.d.ts

@@ -0,0 +1,11 @@
+export type Maybe<T> = T | null | undefined;
+export type SfProduct = any;
+export type Product = any;
+export type SfCart = any;
+export type Cart = any;
+export type SfCustomer = any;
+export type SfAddress = any;
+export type SfProductReview = any;
+export type SfShippingMethods = any;
+export type SfAttribute = any;
+export type Category = any;

package/dist/composables/_types.js

@@ -0,0 +1 @@
+export {};

package/dist/composables/adapters/abstract/productAdapter.d.ts

@@ -0,0 +1,6 @@
+import { Product } from "../../domain/product";
+export interface ProductAdapter {
+    list(): Promise<Product[]>;
+    get(id: string): Promise<Product | null>;
+    search(query: string): Promise<Product[]>;
+}

package/dist/composables/adapters/abstract/productAdapter.js

@@ -0,0 +1 @@
+export {};

package/dist/composables/cart/registry.d.ts

@@ -0,0 +1,4 @@
+import { CartProvider } from "./types";
+export declare function registerCartProvider(name: string, provider: CartProvider): void;
+export declare function getCartProvider(name: string): CartProvider;
+export declare function registerCartProviderRuntime(name: string, provider: CartProvider): void;

package/dist/composables/cart/registry.js

@@ -0,0 +1,16 @@
+const providers = {};
+export function registerCartProvider(name, provider) {
+    providers[name] = provider;
+}
+export function getCartProvider(name) {
+    const provider = providers[name];
+    if (!provider)
+        throw new Error(`Cart provider "${name}" not found`);
+    return provider;
+}
+// Runtime helper for adapter packages to register themselves when the
+// app boots. Adapter packages can import this and call it from their
+// plugin entry to wire into the commerce cart provider registry.
+export function registerCartProviderRuntime(name, provider) {
+    registerCartProvider(name, provider);
+}

package/dist/composables/cart/types.d.ts

@@ -0,0 +1,16 @@
+export interface CartItem {
+    id: string;
+    quantity: number;
+    product: any;
+}
+export interface Cart {
+    id: string;
+    items: CartItem[];
+    total: number;
+}
+export interface CartProvider {
+    getCart(): Promise<Cart>;
+    addItem(productId: string, quantity?: number): Promise<Cart>;
+    removeItem(productId: string): Promise<Cart>;
+    clearCart(): Promise<Cart>;
+}

package/dist/composables/cart/types.js

@@ -0,0 +1 @@
+export {};

package/dist/composables/cart/useCart.d.ts

@@ -0,0 +1,6 @@
+export declare function useCart(): {
+    getCart: () => Promise<import("./types").Cart>;
+    addItem: (productId: string, quantity?: number) => Promise<import("./types").Cart>;
+    removeItem: (productId: string) => Promise<import("./types").Cart>;
+    clearCart: () => Promise<import("./types").Cart>;
+};

package/dist/composables/cart/useCart.js

@@ -0,0 +1,13 @@
+import { getCartProvider } from './registry';
+import { useRuntimeConfig } from '#imports';
+export function useCart() {
+    const config = useRuntimeConfig();
+    const providerName = config.public.cartProvider || 'directus';
+    const provider = getCartProvider(providerName);
+    return {
+        getCart: provider.getCart,
+        addItem: provider.addItem,
+        removeItem: provider.removeItem,
+        clearCart: provider.clearCart
+    };
+}

package/dist/composables/config.d.ts

@@ -0,0 +1,7 @@
+export interface CommerceConfig {
+    productProvider: string;
+    cartProvider: string;
+    categoryProvider: string;
+}
+export declare function setCommerceConfig(newConfig: Partial<CommerceConfig>): void;
+export declare function getCommerceConfig(): CommerceConfig;

package/dist/composables/config.js

@@ -0,0 +1,11 @@
+let config = {
+    productProvider: 'directus',
+    cartProvider: 'directus',
+    categoryProvider: 'directus'
+};
+export function setCommerceConfig(newConfig) {
+    config = { ...config, ...newConfig };
+}
+export function getCommerceConfig() {
+    return config;
+}

package/dist/composables/defs/apiDefinitions.d.ts

@@ -0,0 +1,7 @@
+import type { DefineAddCustomFields, NormalizersConstraint } from "./types";
+import type { UnifiedMethods } from "../methods";
+export type DefineApi<TContext = Record<string, unknown>> = {
+    [TKey in keyof UnifiedMethods]: (fn: (context: TContext, ...args: Parameters<UnifiedMethods[TKey]>) => ReturnType<UnifiedMethods[TKey]>) => (context: TContext, ...args: Parameters<UnifiedMethods[TKey]>) => ReturnType<UnifiedMethods[TKey]>;
+};
+export declare function getApiDefinitions<TContext = Record<string, unknown>>(): DefineApi<TContext>;
+export declare function defineAddCustomFieldsFactory<TNormalizers extends NormalizersConstraint>(): <TInput extends DefineAddCustomFields<TNormalizers>>(input: TInput) => TInput;

package/dist/composables/defs/apiDefinitions.js

@@ -0,0 +1,39 @@
+export function getApiDefinitions() {
+    return {
+        getCategories: (fn) => fn,
+        getCategory: (fn) => fn,
+        getCart: (fn) => fn,
+        addCartLineItem: (fn) => fn,
+        updateCartLineItem: (fn) => fn,
+        removeCartLineItem: (fn) => fn,
+        applyCouponToCart: (fn) => fn,
+        removeCouponFromCart: (fn) => fn,
+        setCustomerEmail: (fn) => fn,
+        setCartAddress: (fn) => fn,
+        getAvailableShippingMethods: (fn) => fn,
+        setShippingMethod: (fn) => fn,
+        registerCustomer: (fn) => fn,
+        loginCustomer: (fn) => fn,
+        getCustomer: (fn) => fn,
+        logoutCustomer: (fn) => fn,
+        updateCustomer: (fn) => fn,
+        changeCustomerPassword: (fn) => fn,
+        searchProducts: (fn) => fn,
+        getProducts: (fn) => fn,
+        getProductDetails: (fn) => fn,
+        getProductReviews: (fn) => fn,
+        createCustomerAddress: (fn) => fn,
+        getCustomerAddresses: (fn) => fn,
+        updateCustomerAddress: (fn) => fn,
+        deleteCustomerAddress: (fn) => fn,
+        getCurrencies: (fn) => fn,
+        getOrders: (fn) => fn,
+        getOrderDetails: (fn) => fn,
+        placeOrder: (fn) => fn,
+    };
+}
+export function defineAddCustomFieldsFactory() {
+    return (input) => {
+        return input;
+    };
+}

package/dist/composables/defs/extension.d.ts

@@ -0,0 +1,91 @@
+type ApiMethods = Record<string, (...args: any[]) => any>;
+import type { CreateUnifiedExtensionParams, DefineAddCustomFields, NormalizersConstraint, UnifiedConfig, UnifiedExtensionContextConstraint, UnifiedExtensionFactoryParams } from "./types";
+/**
+ * @description A factory function which builds the default normalizers and default API methods into unified extension.
+ * It expects the type of the API methods, normalizers, and config as generics.
+ *
+ * @returns A `createUnifiedExtension` function which can be used by the user to create a unified extension.
+ *
+ * @example
+ * ```ts
+ * export const createUnifiedExtension = unifiedExtensionFactory<
+ *   typeof apiMethods,
+ *   Normalizers,
+ *   Config
+ * >({
+ *   extendApiMethods: apiMethods,
+ *   normalizers,
+ * });
+ * ```
+ */
+export declare function unifiedExtensionFactory<TApiMethods extends ApiMethods, TNormalizers extends NormalizersConstraint, TConfig extends UnifiedConfig>(factoryParams: UnifiedExtensionFactoryParams<TApiMethods, TNormalizers>): <TAddCustomFieldsArray extends [DefineAddCustomFields<TNormalizers>, ...DefineAddCustomFields<TNormalizers>[]]>(params: CreateUnifiedExtensionParams<TConfig, TApiMethods, TNormalizers, TAddCustomFieldsArray>) => {
+    name: string;
+    extendApiMethods: TApiMethods;
+    hooks(req: any, res: any): {
+        beforeCall({ args, configuration }: {
+            args: any;
+            configuration: any;
+        }): any;
+    };
+    isNamespaced: boolean;
+    normalizers: TNormalizers;
+    /**
+     * @internal You shouldn't use this field. It's present only to infer the type of addCustomFields
+     */
+    _addCustomFields: TAddCustomFieldsArray;
+};
+/**
+ * @description A factory function which builds the default normalizers and default API methods into unified extension.
+ * It expects the type of the API methods, normalizers, and config as generics.
+ *
+ * @returns A Middleware extension which can be registered in the API client.
+ *
+ * @example
+ * ```ts
+ * export const createUnifiedExtension = createUnifiedCmsExtension({
+ *   extendApiMethods: {
+ *     getPage,
+ *   },
+ *   normalizers,
+ *   getAdditionalNormalizerContext: () => ({
+ *     documentToHtmlString,
+ *   }),
+ * });
+ * ```
+ */
+export declare function createUnifiedCmsExtension<TApiMethods extends ApiMethods, TNormalizers extends NormalizersConstraint>(params: UnifiedExtensionFactoryParams<TApiMethods, TNormalizers>): {
+    name: string;
+    extendApiMethods: TApiMethods;
+    isNamespaced: boolean;
+    hooks(req: any, res: any): {
+        beforeCall({ args, configuration }: {
+            args: any;
+            configuration: any;
+        }): any;
+    };
+};
+/**
+ * A helper function to get the normalizers from the context.
+ * @param context Context passed to the API method
+ * @returns normalizers
+ *
+ * @example
+ * ```ts
+ * const { normalizeProduct } = getNormalizers(context);
+ * ```
+ */
+export declare function getNormalizers<TContext extends UnifiedExtensionContextConstraint>(context: TContext): TContext["config"]["normalizerContext"]["normalizers"];
+/**
+ * A helper function to assign values to the normalizer context.
+ * @param context Context passed to the API method
+ * @param overrides Object with the values to override in the normalizer context
+ * @returns void - it mutates the context
+ *
+ * @example
+ * ```ts
+ * assignToNormalizerContext(context, { locale: "de" });
+ * ```
+ */
+export declare function assignToNormalizerContext<TContext extends UnifiedExtensionContextConstraint>(context: TContext, overrides: Partial<TContext["config"]["normalizerContext"]>): void;
+export declare function mergeNormalizers<TNormalizers extends NormalizersConstraint>(baseNormalizers: TNormalizers, addCustomFields: DefineAddCustomFields<TNormalizers>[]): TNormalizers;
+export {};

package/dist/composables/defs/extension.js

@@ -0,0 +1,154 @@
+import { mergeDeepRight } from "ramda";
+import { toContextualizedNormalizers } from "../helpers";
+const Logger = console;
+const CURRENCY_COOKIE = "vsf-currency";
+const LOCALE_COOKIE = "vsf-locale";
+/**
+ * @description A factory function which builds the default normalizers and default API methods into unified extension.
+ * It expects the type of the API methods, normalizers, and config as generics.
+ *
+ * @returns A `createUnifiedExtension` function which can be used by the user to create a unified extension.
+ *
+ * @example
+ * ```ts
+ * export const createUnifiedExtension = unifiedExtensionFactory<
+ *   typeof apiMethods,
+ *   Normalizers,
+ *   Config
+ * >({
+ *   extendApiMethods: apiMethods,
+ *   normalizers,
+ * });
+ * ```
+ */
+export function unifiedExtensionFactory(factoryParams) {
+    return function createUnifiedExtension(params) {
+        const { extendApiMethods: defaultApiMethods, normalizers: defaultNormalizers, getAdditionalNormalizerContext, } = factoryParams;
+        const baseNormalizers = { ...defaultNormalizers, ...params.normalizers.override };
+        const normalizers = mergeNormalizers(baseNormalizers, params.normalizers.addCustomFields);
+        const { config: extensionConfig, methods, isNamespaced = factoryParams.isNamespaced } = params;
+        return {
+            name: "unified",
+            extendApiMethods: {
+                ...defaultApiMethods,
+                ...methods?.override,
+            },
+            hooks(req, res) {
+                return {
+                    beforeCall({ args, configuration }) {
+                        if (!req.cookies[CURRENCY_COOKIE] && extensionConfig) {
+                            req.cookies[CURRENCY_COOKIE] = extensionConfig.defaultCurrency;
+                        }
+                        configuration.unified = extensionConfig;
+                        if (!configuration.normalizerContext) {
+                            configuration.normalizerContext = createNormalizerContext(normalizers, getAdditionalNormalizerContext, { req, res, config: configuration });
+                            configuration.normalizerContext.currency =
+                                req.cookies?.[CURRENCY_COOKIE] ?? extensionConfig.defaultCurrency ?? "USD";
+                        }
+                        return args;
+                    },
+                };
+            },
+            isNamespaced,
+            normalizers,
+            /**
+             * @internal You shouldn't use this field. It's present only to infer the type of addCustomFields
+             */
+            _addCustomFields: {},
+        };
+    };
+}
+/**
+ * @description A factory function which builds the default normalizers and default API methods into unified extension.
+ * It expects the type of the API methods, normalizers, and config as generics.
+ *
+ * @returns A Middleware extension which can be registered in the API client.
+ *
+ * @example
+ * ```ts
+ * export const createUnifiedExtension = createUnifiedCmsExtension({
+ *   extendApiMethods: {
+ *     getPage,
+ *   },
+ *   normalizers,
+ *   getAdditionalNormalizerContext: () => ({
+ *     documentToHtmlString,
+ *   }),
+ * });
+ * ```
+ */
+export function createUnifiedCmsExtension(params) {
+    const { extendApiMethods, normalizers: defaultNormalizers, getAdditionalNormalizerContext, isNamespaced = true, } = params;
+    return {
+        name: "unified",
+        extendApiMethods,
+        isNamespaced,
+        hooks(req, res) {
+            return {
+                beforeCall({ args, configuration }) {
+                    if (!configuration.normalizerContext) {
+                        const unifiedConfig = configuration?.unified ?? {};
+                        const baseNormalizers = {
+                            ...defaultNormalizers,
+                            ...unifiedConfig.normalizers?.override,
+                        };
+                        const normalizers = mergeNormalizers(baseNormalizers, unifiedConfig.normalizers?.addCustomFields ?? []);
+                        configuration.normalizerContext = createNormalizerContext(normalizers, getAdditionalNormalizerContext, { req, res, config: configuration });
+                    }
+                    return args;
+                },
+            };
+        },
+    };
+}
+/**
+ * A helper function to get the normalizers from the context.
+ * @param context Context passed to the API method
+ * @returns normalizers
+ *
+ * @example
+ * ```ts
+ * const { normalizeProduct } = getNormalizers(context);
+ * ```
+ */
+export function getNormalizers(context) {
+    return context.config.normalizerContext.normalizers;
+}
+/**
+ * A helper function to assign values to the normalizer context.
+ * @param context Context passed to the API method
+ * @param overrides Object with the values to override in the normalizer context
+ * @returns void - it mutates the context
+ *
+ * @example
+ * ```ts
+ * assignToNormalizerContext(context, { locale: "de" });
+ * ```
+ */
+export function assignToNormalizerContext(context, overrides) {
+    Object.assign(context.config.normalizerContext, overrides);
+}
+function createNormalizerContext(normalizers, getAdditionalNormalizerContext, { req, res, config }) {
+    const logger = Logger;
+    const normalizerContext = {
+        locale: req.cookies?.[LOCALE_COOKIE] ?? "en",
+        ...getAdditionalNormalizerContext({ req, res, config }),
+        logger,
+    };
+    normalizerContext.normalizers = toContextualizedNormalizers(normalizers, () => normalizerContext);
+    return normalizerContext;
+}
+export function mergeNormalizers(baseNormalizers, addCustomFields) {
+    const normalizers = { ...baseNormalizers };
+    addCustomFields.forEach((customFieldsNormalizers) => {
+        Object.entries(customFieldsNormalizers).forEach(([name, customFields]) => {
+            const currentNormalizer = normalizers[name];
+            if (normalizers[name] && customFields) {
+                normalizers[name] = (input, context) => mergeDeepRight(currentNormalizer(input, context), {
+                    $custom: customFields(input, context),
+                });
+            }
+        });
+    });
+    return normalizers;
+}