@meeovi/layer-commerce 1.0.3 → 1.0.5

package/dist/composables/useContent.js

@@ -0,0 +1,55 @@
+import { useAlternateContext } from '@meeovi/core';
+export function useContentFallback() {
+    try {
+        const ctx = useAlternateContext();
+        const adapter = ctx.getAdapter('catalog');
+        // If a content-capable adapter is available and exposes methods, use it
+        if (adapter && typeof adapter.listShops === 'function') {
+            return {
+                adapter,
+                listShops: (opts) => adapter.listShops(opts),
+                getBrandBySlug: (slug) => adapter.getBrandBySlug?.(slug),
+                getPage: (id) => adapter.getPage?.(id)
+            };
+        }
+    }
+    catch (e) {
+        // ignore
+    }
+    // Fallback to Directus via Nuxt runtime
+    return {
+        adapter: null,
+        async listShops(params) {
+            const nuxtApp = useNuxtApp();
+            if (nuxtApp?.$directus && nuxtApp.$readItems) {
+                const res = await nuxtApp.$directus.request(nuxtApp.$readItems('shops', params || {}));
+                return res || [];
+            }
+            return [];
+        },
+        async listBrands(params) {
+            const nuxtApp = useNuxtApp();
+            if (nuxtApp?.$directus && nuxtApp.$readItems) {
+                const res = await nuxtApp.$directus.request(nuxtApp.$readItems('brands', params || {}));
+                return res || [];
+            }
+            return [];
+        },
+        async getBrandBySlug(slug) {
+            const nuxtApp = useNuxtApp();
+            if (nuxtApp?.$directus && nuxtApp.$readItems) {
+                const res = await nuxtApp.$directus.request(nuxtApp.$readItems('brands', { filter: { slug: { _eq: slug } }, limit: 1 }));
+                return res?.[0] || null;
+            }
+            return null;
+        },
+        async getPage(id) {
+            const nuxtApp = useNuxtApp();
+            if (nuxtApp?.$directus && nuxtApp.$readItem) {
+                return await nuxtApp.$directus.request(nuxtApp.$readItem('pages', id));
+            }
+            return null;
+        }
+    };
+}
+export default useContentFallback;

package/dist/composables/useCustomer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCustomer';
+export * from './types';

package/dist/composables/useCustomer/index.js

@@ -0,0 +1,2 @@
+export * from './useCustomer';
+export * from './types';

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

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import type { Maybe, SfCustomer } from '../_types';
+export interface UseCustomerState {
+    data: Maybe<SfCustomer>;
+    loading: boolean;
+}
+export type FetchCustomer = () => Promise<Ref<Maybe<SfCustomer>>>;
+export interface UseCustomer {
+    data: Readonly<Ref<UseCustomerState['data']>>;
+    loading: Readonly<Ref<boolean>>;
+    fetchCustomer: FetchCustomer;
+}
+export type UseCustomerReturn = () => UseCustomer;

package/dist/composables/useCustomer/types.js

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

package/dist/composables/useCustomer/useCustomer.d.ts

@@ -0,0 +1,8 @@
+import type { UseCustomerReturn } from './types';
+/**
+ * @description Composable managing customer data
+ * @returns {@link UseCustomerReturn}
+ * @example
+ * const { data, loading, fetchCustomer } = useCustomer();
+ */
+export declare const useCustomer: UseCustomerReturn;

package/dist/composables/useCustomer/useCustomer.js

@@ -0,0 +1,34 @@
+import { toRefs } from '@vueuse/shared';
+import { computed } from 'vue';
+import { getCommerceClient } from '../../utils/client';
+import { useAsyncData, useState } from 'nuxt/app';
+import { useHandleError } from '../useHandleError';
+/**
+ * @description Composable managing customer data
+ * @returns {@link UseCustomerReturn}
+ * @example
+ * const { data, loading, fetchCustomer } = useCustomer();
+ */
+export const useCustomer = () => {
+    const state = useState('useCustomer', () => ({
+        data: null,
+        loading: false,
+    }));
+    /** Function for fetching customer data
+     * @example
+     * fetchCustomer();
+     */
+    const fetchCustomer = async () => {
+        state.value.loading = true;
+        const client = getCommerceClient();
+        const { data, error } = await useAsyncData(() => client.getCustomer?.());
+        useHandleError(error.value);
+        state.value.data = data.value;
+        state.value.loading = false;
+        return computed(() => state.value.data);
+    };
+    return {
+        fetchCustomer,
+        ...toRefs(state.value),
+    };
+};

package/dist/composables/useCustomerAddress/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCustomerAddress';
+export * from './types';

package/dist/composables/useCustomerAddress/index.js

@@ -0,0 +1,2 @@
+export * from './useCustomerAddress';
+export * from './types';

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

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import type { Maybe, SfAddress } from '../_types';
+export interface UseCustomerAddressState {
+    data: Maybe<SfAddress>;
+    loading: boolean;
+}
+export type FetchCustomerAddress = () => Promise<Ref<Maybe<SfAddress>>>;
+export interface UseCustomerAddress {
+    data: Readonly<Ref<UseCustomerAddressState['data']>>;
+    loading: Readonly<Ref<boolean>>;
+    fetchCustomerAddress: FetchCustomerAddress;
+}
+export type UseCustomerAddressReturn = () => UseCustomerAddress;

package/dist/composables/useCustomerAddress/types.js

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

package/dist/composables/useCustomerAddress/useCustomerAddress.d.ts

@@ -0,0 +1,8 @@
+import type { UseCustomerAddressReturn } from './types';
+/**
+ * @description Composable managing address data
+ * @returns {@link UseCustomerAddressReturn}
+ * @example
+ * const { data, loading, fetchCustomerAddress } = useCustomerAddress();
+ */
+export declare const useCustomerAddress: UseCustomerAddressReturn;

package/dist/composables/useCustomerAddress/useCustomerAddress.js

@@ -0,0 +1,43 @@
+import { toRefs } from '@vueuse/shared';
+import { computed } from 'vue';
+import { useAsyncData, useState } from 'nuxt/app';
+import { useHandleError } from '../useHandleError';
+/**
+ * @description Composable managing address data
+ * @returns {@link UseCustomerAddressReturn}
+ * @example
+ * const { data, loading, fetchCustomerAddress } = useCustomerAddress();
+ */
+export const useCustomerAddress = () => {
+    const state = useState(`useCustomerAddress`, () => ({
+        data: null,
+        loading: false,
+    }));
+    /** Function for fetching address data
+     * @example
+     * fetchCustomerAddress();
+     */
+    const fetchCustomerAddress = async () => {
+        state.value.loading = true;
+        const { data, error } = await useAsyncData(() => Promise.resolve({
+            firstName: 'Hieronim',
+            lastName: 'Anonim',
+            address1: 'Oak Drive',
+            address2: '3633',
+            city: 'Colonie',
+            country: 'US',
+            phoneNumber: '+1 321 765 0987',
+            postalCode: '12205',
+            state: 'NY',
+            titleCode: '',
+        }));
+        useHandleError(error.value);
+        state.value.data = data.value;
+        state.value.loading = false;
+        return computed(() => state.value.data);
+    };
+    return {
+        fetchCustomerAddress,
+        ...toRefs(state.value),
+    };
+};

package/dist/composables/useCustomerOrder/adress.d.ts

@@ -0,0 +1,11 @@
+declare const _default: {
+    firstName: string;
+    lastName: string;
+    phoneNumber: string;
+    address1: string;
+    address2: string;
+    city: string;
+    state: string;
+    postalCode: string;
+};
+export default _default;

package/dist/composables/useCustomerOrder/adress.js

@@ -0,0 +1,10 @@
+export default {
+    firstName: 'Hieronim',
+    lastName: 'Anonim',
+    phoneNumber: '+1 321 765 0987',
+    address1: '3633',
+    address2: 'Oak Drive',
+    city: 'Colonie',
+    state: 'NY',
+    postalCode: '12205',
+};

package/dist/composables/useCustomerOrder/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCustomerOrder';
+export * from './types';

package/dist/composables/useCustomerOrder/index.js

@@ -0,0 +1,2 @@
+export * from './useCustomerOrder';
+export * from './types';

package/dist/composables/useCustomerOrder/product.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    name: string;
+    quantity: number;
+    price: {
+        value: {
+            currency: string;
+            amount: number;
+            precisionAmount: string;
+        };
+        isDiscounted: boolean;
+        regularPrice: {
+            currency: string;
+            amount: number;
+            precisionAmount: string;
+        };
+    };
+    gallery: {
+        alt: string;
+        url: string;
+    }[];
+    attributes: {
+        label: string;
+        name: string;
+        value: string;
+        valueLabel: string;
+    }[];
+};
+export default _default;

package/dist/composables/useCustomerOrder/product.js

@@ -0,0 +1,37 @@
+export default {
+    name: 'Smartwatch Fitness Tracker',
+    quantity: 1,
+    price: {
+        value: {
+            currency: 'Dollar',
+            amount: 295.87,
+            precisionAmount: '295.87',
+        },
+        isDiscounted: false,
+        regularPrice: {
+            currency: 'Dollar',
+            amount: 295.87,
+            precisionAmount: '295.87',
+        },
+    },
+    gallery: [
+        {
+            alt: 'Smartwatch Fitness Tracker',
+            url: '/images/watch.png',
+        },
+    ],
+    attributes: [
+        {
+            label: 'Size',
+            name: 'Size',
+            value: '1.9″',
+            valueLabel: 'value',
+        },
+        {
+            name: 'Color',
+            label: 'color',
+            value: 'Black',
+            valueLabel: 'value',
+        },
+    ],
+};

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

@@ -0,0 +1,32 @@
+import type { Ref } from 'vue';
+import type { Maybe, SfAddress, SfProduct } from '../_types';
+export type OrderData = {
+    id: string;
+    date: string;
+    paymentAmount: number;
+    status: 'Completed' | 'Shipped' | 'Open' | 'Cancelled';
+    products: Array<Omit<SfProduct, 'id' | 'sku' | 'slug' | 'description' | 'primaryImage' | 'rating' | 'variants' | 'quantityLimit'> & {
+        quantity: number;
+    }>;
+    summary: {
+        subtotal: number;
+        delivery: number;
+        estimatedTax: number;
+        total: number;
+    };
+    billingAddress: Partial<SfAddress>;
+    shippingAddress: Partial<SfAddress>;
+    paymentMethod: string;
+    shipping: string;
+};
+export interface UseCustomerOrderState {
+    data: Maybe<OrderData>;
+    loading: boolean;
+}
+export type FetchCustomerOrder = (id: string) => Promise<Ref<Maybe<OrderData>>>;
+export interface UseCustomerOrder {
+    data: Readonly<Ref<UseCustomerOrderState['data']>>;
+    loading: Readonly<Ref<boolean>>;
+    fetchCustomerOrder: FetchCustomerOrder;
+}
+export type UseCustomerOrderReturn = (id: string) => UseCustomerOrder;

package/dist/composables/useCustomerOrder/types.js

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

package/dist/composables/useCustomerOrder/useCustomerOrder.d.ts

@@ -0,0 +1,8 @@
+import type { UseCustomerOrderReturn } from './types';
+/**
+ * @description Composable managing customer order data
+ * @returns {@link UseCustomerOrderReturn}
+ * @example
+ * const { data, loading, fetchCustomerOrder } = useCustomerOrder();
+ */
+export declare const useCustomerOrder: UseCustomerOrderReturn;

package/dist/composables/useCustomerOrder/useCustomerOrder.js

@@ -0,0 +1,52 @@
+import { toRefs } from '@vueuse/shared';
+import addressData from './adress';
+import productData from './product';
+import { useAsyncData, useState } from 'nuxt/app';
+import { useHandleError } from '../useHandleError';
+const order = {
+    id: '0e4fec5a-61e6-48b8-94cc-d5f77687e2b0',
+    date: '2022-08-11',
+    paymentAmount: 295.87,
+    paymentMethod: 'Credit Card',
+    shipping: 'Standard (FREE)',
+    summary: {
+        subtotal: 7037.99,
+        delivery: 0,
+        estimatedTax: 457.47,
+        total: 295.87,
+    },
+    billingAddress: addressData,
+    shippingAddress: addressData,
+    status: 'Completed',
+    products: [productData, productData],
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-vars
+const getCustomerOrder = (id) => order;
+/**
+ * @description Composable managing customer order data
+ * @returns {@link UseCustomerOrderReturn}
+ * @example
+ * const { data, loading, fetchCustomerOrder } = useCustomerOrder();
+ */
+export const useCustomerOrder = (id) => {
+    const state = useState(`useCustomerOrder-${id}`, () => ({
+        data: null,
+        loading: false,
+    }));
+    /** Function for fetching customer order data
+     * @example
+     * fetchCustomerOrder();
+     */
+    const fetchCustomerOrder = async (id) => {
+        state.value.loading = true;
+        const { data, error } = await useAsyncData(() => Promise.resolve(getCustomerOrder(id)));
+        useHandleError(error.value);
+        state.value.data = data.value;
+        state.value.loading = false;
+        return data;
+    };
+    return {
+        fetchCustomerOrder,
+        ...toRefs(state.value),
+    };
+};

package/dist/composables/useCustomerOrders/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCustomerOrders';
+export * from './types';

package/dist/composables/useCustomerOrders/index.js

@@ -0,0 +1,2 @@
+export * from './useCustomerOrders';
+export * from './types';

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

@@ -0,0 +1,15 @@
+import type { Ref } from 'vue';
+import type { Maybe } from '../_types';
+import type { OrderData } from '../useCustomerOrder/types';
+export type OrdersData = Pick<OrderData, 'id' | 'date' | 'paymentAmount' | 'status'>[];
+export interface UseCustomerOrdersState {
+    data: Maybe<OrdersData>;
+    loading: boolean;
+}
+export type FetchCustomerOrders = () => Promise<Ref<Maybe<OrdersData>>>;
+export interface UseCustomerOrders {
+    data: Readonly<Ref<UseCustomerOrdersState['data']>>;
+    loading: Readonly<Ref<boolean>>;
+    fetchCustomerOrders: FetchCustomerOrders;
+}
+export type UseCustomerOrdersReturn = () => UseCustomerOrders;

package/dist/composables/useCustomerOrders/types.js

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

package/dist/composables/useCustomerOrders/useCustomerOrders.d.ts

@@ -0,0 +1,8 @@
+import type { UseCustomerOrdersReturn } from './types';
+/**
+ * @description Composable managing customer orders data
+ * @returns {@link UseCustomerOrdersReturn}
+ * @example
+ * const { data, loading, fetchCustomerOrders } = useCustomerOrders();
+ */
+export declare const useCustomerOrders: UseCustomerOrdersReturn;

package/dist/composables/useCustomerOrders/useCustomerOrders.js

@@ -0,0 +1,42 @@
+import { toRefs } from '@vueuse/shared';
+import { computed } from 'vue';
+import { useAsyncData, useState } from 'nuxt/app';
+import { useHandleError } from '../useHandleError';
+const order = {
+    id: '0e4fec5a-61e6-48b8-94cc-d5f77687e2b0',
+    date: '2022-08-11',
+    paymentAmount: 295.87,
+};
+/**
+ * @description Composable managing customer orders data
+ * @returns {@link UseCustomerOrdersReturn}
+ * @example
+ * const { data, loading, fetchCustomerOrders } = useCustomerOrders();
+ */
+export const useCustomerOrders = () => {
+    const state = useState('useCustomerOrders', () => ({
+        data: null,
+        loading: false,
+    }));
+    /** Function for fetching customer orders data
+     * @example
+     * fetchCustomerOrders();
+     */
+    const fetchCustomerOrders = async () => {
+        state.value.loading = true;
+        const { data, error } = await useAsyncData(() => Promise.resolve([
+            { ...order, status: 'Completed' },
+            { ...order, status: 'Shipped' },
+            { ...order, status: 'Open' },
+            { ...order, status: 'Cancelled' },
+        ]));
+        useHandleError(error.value);
+        state.value.data = data.value;
+        state.value.loading = false;
+        return computed(() => state.value.data);
+    };
+    return {
+        fetchCustomerOrders,
+        ...toRefs(state.value),
+    };
+};

package/dist/composables/useCustomerReturns/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useCustomerReturns';
+export * from './types';

package/dist/composables/useCustomerReturns/index.js

@@ -0,0 +1,2 @@
+export * from './useCustomerReturns';
+export * from './types';

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

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import { Maybe } from '../_types';
+export interface UseCustomerReturnsState {
+    data: Maybe<unknown[]>;
+    loading: boolean;
+}
+export type FetchCustomerReturns = () => Promise<Ref<unknown[] | null>>;
+export interface UseCustomerReturns {
+    data: Readonly<Ref<UseCustomerReturnsState['data']>>;
+    loading: Readonly<Ref<boolean>>;
+    fetchCustomerReturns: FetchCustomerReturns;
+}
+export type UseCustomerReturnsReturn = () => UseCustomerReturns;

package/dist/composables/useCustomerReturns/types.js

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

package/dist/composables/useCustomerReturns/useCustomerReturns.d.ts

@@ -0,0 +1,8 @@
+import type { UseCustomerReturnsReturn } from './types';
+/**
+ * @description Composable managing returns data
+ * @returns {@link UseCustomerReturnsReturn}
+ * @example
+ * const { data, loading, fetchCustomerReturns } = useCustomerReturns();
+ */
+export declare const useCustomerReturns: UseCustomerReturnsReturn;

package/dist/composables/useCustomerReturns/useCustomerReturns.js

@@ -0,0 +1,32 @@
+import { toRefs } from '@vueuse/shared';
+import { computed } from 'vue';
+import { useAsyncData, useState } from 'nuxt/app';
+import { useHandleError } from '../useHandleError';
+/**
+ * @description Composable managing returns data
+ * @returns {@link UseCustomerReturnsReturn}
+ * @example
+ * const { data, loading, fetchCustomerReturns } = useCustomerReturns();
+ */
+export const useCustomerReturns = () => {
+    const state = useState(`useCustomerReturns`, () => ({
+        data: [],
+        loading: false,
+    }));
+    /** Function for fetching returns data
+     * @example
+     * fetchCustomerReturns();
+     */
+    const fetchCustomerReturns = async () => {
+        state.value.loading = true;
+        const { data, error } = await useAsyncData(() => Promise.resolve([]));
+        useHandleError(error.value);
+        state.value.data = data.value;
+        state.value.loading = false;
+        return computed(() => state.value.data);
+    };
+    return {
+        fetchCustomerReturns,
+        ...toRefs(state.value),
+    };
+};

package/dist/composables/useHandleError/index.d.ts

@@ -0,0 +1 @@
+export * from './useHandleError';

package/dist/composables/useHandleError/index.js

@@ -0,0 +1 @@
+export * from './useHandleError';

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

@@ -0,0 +1,7 @@
+import type { Maybe } from '../_types';
+import { H3Error } from 'h3';
+export type ErrorParams = Maybe<Partial<H3Error> & {
+    status?: number;
+    statusText?: string;
+}>;
+export type UseHandleError = (error: ErrorParams) => void;

package/dist/composables/useHandleError/types.js

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

package/dist/composables/useHandleError/useHandleError.d.ts

@@ -0,0 +1,10 @@
+import type { UseHandleError } from './types';
+/**
+ * @description Composable for handling errors.
+ * @param error {@link ErrorParams}
+ * @returns Throws an error if there is one.
+ * @example
+ * const { data, error } = await fetch(data);
+ * useHandleError(error.value);
+ */
+export declare const useHandleError: UseHandleError;

package/dist/composables/useHandleError/useHandleError.js

@@ -0,0 +1,24 @@
+import { createError } from 'h3';
+const defaultError = {
+    status: 500,
+    message: 'An error occurred',
+    statusMessage: 'An error occurred',
+};
+/**
+ * @description Composable for handling errors.
+ * @param error {@link ErrorParams}
+ * @returns Throws an error if there is one.
+ * @example
+ * const { data, error } = await fetch(data);
+ * useHandleError(error.value);
+ */
+export const useHandleError = (error) => {
+    if (error) {
+        throw createError({
+            statusCode: error.status || defaultError.status,
+            message: error.message ?? defaultError.message,
+            statusMessage: error.message ?? defaultError.statusMessage,
+            fatal: true,
+        });
+    }
+};

package/dist/composables/usePageTitle.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Composable for setting the page title.
+ * Used in layouts. Title can be changed in pages through the `useHead` composable.
+ */
+export declare const usePageTitle: () => void;

package/dist/composables/usePageTitle.js

@@ -0,0 +1,14 @@
+import useHead from "../modules/vue-head/composables/useHead";
+import { useAppConfig } from "nuxt/app";
+/**
+ * Composable for setting the page title.
+ * Used in layouts. Title can be changed in pages through the `useHead` composable.
+ */
+export const usePageTitle = () => {
+    const { titleSuffix } = useAppConfig();
+    useHead({
+        titleTemplate: (titleChunk) => {
+            return titleChunk ? `${titleChunk} | ${titleSuffix}` : titleSuffix;
+        },
+    });
+};

package/dist/composables/useProduct/index.d.ts

@@ -0,0 +1,2 @@
+export * from './useProduct';
+export * from './types';

package/dist/composables/useProduct/index.js

@@ -0,0 +1,2 @@
+export * from './useProduct';
+export * from './types';

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

@@ -0,0 +1,13 @@
+import type { Ref } from 'vue';
+import type { SfProduct, Maybe } from '../_types';
+export interface UseProductState {
+    data: Maybe<SfProduct>;
+    loading: boolean;
+}
+export type FetchProduct = (slug: string) => Promise<Ref<Maybe<SfProduct>>>;
+export interface UseProduct {
+    data: Readonly<Ref<UseProductState['data']>>;
+    loading: Readonly<Ref<boolean>>;
+    fetchProduct: FetchProduct;
+}
+export type UseProductReturn = (slug: string) => UseProduct;