@plasmicpkgs/commerce 0.0.1

package/dist/auth/use-login.d.ts

@@ -0,0 +1,6 @@
+import type { MutationHook, HookFetcherFn } from '../utils/types';
+import type { LoginHook } from '../types/login';
+export declare type UseLogin<H extends MutationHook<LoginHook<any>> = MutationHook<LoginHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<LoginHook>;
+declare const useLogin: UseLogin;
+export default useLogin;

package/dist/auth/use-login.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.auth?.useLogin;
+const useLogin = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useLogin;

package/dist/auth/use-logout.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../utils/types';
+import type { LogoutHook } from '../types/logout';
+export declare type UseLogout<H extends MutationHook<LogoutHook<any>> = MutationHook<LogoutHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<LogoutHook>;
+declare const useLogout: UseLogout;
+export default useLogout;

package/dist/auth/use-logout.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.auth?.useLogout;
+const useLogout = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useLogout;

package/dist/auth/use-signup.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../utils/types';
+import type { SignupHook } from '../types/signup';
+export declare type UseSignup<H extends MutationHook<SignupHook<any>> = MutationHook<SignupHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<SignupHook>;
+declare const useSignup: UseSignup;
+export default useSignup;

package/dist/auth/use-signup.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.auth?.useSignup;
+const useSignup = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useSignup;

package/dist/cart/use-add-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../utils/types';
+import type { AddItemHook } from '../types/cart';
+export declare type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<AddItemHook>;
+declare const useAddItem: UseAddItem;
+export default useAddItem;

package/dist/cart/use-add-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.cart?.useAddItem;
+const useAddItem = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useAddItem;

package/dist/cart/use-cart.d.ts

@@ -0,0 +1,6 @@
+import type { SWRHook, HookFetcherFn } from '../utils/types';
+import type { GetCartHook } from '../types/cart';
+export declare type UseCart<H extends SWRHook<GetCartHook<any>> = SWRHook<GetCartHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<GetCartHook>;
+declare const useCart: UseCart;
+export default useCart;

package/dist/cart/use-cart.js

@@ -0,0 +1,18 @@
+import Cookies from 'js-cookie';
+import { useHook, useSWRHook } from '../utils/use-hook';
+import { useCommerce } from '..';
+export const fetcher = async ({ options, input: { cartId }, fetch, }) => {
+    return cartId ? await fetch(options) : null;
+};
+const fn = (provider) => provider.cart?.useCart;
+const useCart = (input) => {
+    const hook = useHook(fn);
+    const { cartCookie } = useCommerce();
+    const fetcherFn = hook.fetcher ?? fetcher;
+    const wrapper = (context) => {
+        context.input.cartId = Cookies.get(cartCookie);
+        return fetcherFn(context);
+    };
+    return useSWRHook({ ...hook, fetcher: wrapper })(input);
+};
+export default useCart;

package/dist/cart/use-remove-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../utils/types';
+import type { RemoveItemHook } from '../types/cart';
+export declare type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<RemoveItemHook>;
+declare const useRemoveItem: UseRemoveItem;
+export default useRemoveItem;

package/dist/cart/use-remove-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.cart?.useRemoveItem;
+const useRemoveItem = (input) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(input);
+};
+export default useRemoveItem;

package/dist/cart/use-update-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../utils/types';
+import type { UpdateItemHook } from '../types/cart';
+export declare type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<UpdateItemHook>;
+declare const useUpdateItem: UseUpdateItem;
+export default useUpdateItem;

package/dist/cart/use-update-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.cart?.useUpdateItem;
+const useUpdateItem = (input) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(input);
+};
+export default useUpdateItem;

package/dist/checkout/use-checkout.d.ts

@@ -0,0 +1,6 @@
+import type { SWRHook, HookFetcherFn } from '../utils/types';
+import type { GetCheckoutHook } from '../types/checkout';
+export declare type UseCheckout<H extends SWRHook<GetCheckoutHook<any>> = SWRHook<GetCheckoutHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<GetCheckoutHook>;
+declare const useCheckout: UseCheckout;
+export default useCheckout;

package/dist/checkout/use-checkout.js

@@ -0,0 +1,18 @@
+import Cookies from 'js-cookie';
+import { useHook, useSWRHook } from '../utils/use-hook';
+import { useCommerce } from '..';
+export const fetcher = async ({ options, input: { cartId }, fetch, }) => {
+    return cartId ? await fetch(options) : null;
+};
+const fn = (provider) => provider.checkout?.useCheckout;
+const useCheckout = (input) => {
+    const hook = useHook(fn);
+    const { cartCookie } = useCommerce();
+    const fetcherFn = hook.fetcher ?? fetcher;
+    const wrapper = (context) => {
+        context.input.cartId = Cookies.get(cartCookie);
+        return fetcherFn(context);
+    };
+    return useSWRHook({ ...hook, fetcher: wrapper })(input);
+};
+export default useCheckout;

package/dist/checkout/use-submit-checkout.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../utils/types';
+import type { SubmitCheckoutHook } from '../types/checkout';
+export declare type UseSubmitCheckout<H extends MutationHook<SubmitCheckoutHook<any>> = MutationHook<SubmitCheckoutHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<SubmitCheckoutHook>;
+declare const useSubmitCheckout: UseSubmitCheckout;
+export default useSubmitCheckout;

package/dist/checkout/use-submit-checkout.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../utils/use-hook';
+import { mutationFetcher } from '../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.checkout?.useSubmitCheckout;
+const useSubmitCheckout = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useSubmitCheckout;

package/dist/contexts.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import { Product } from "./types/product";
+export declare const ProductContext: React.Context<Product | undefined>;
+export declare function useProduct(_useProductPlaceholder?: boolean): Product | undefined;
+export declare const ProductCollectionContext: React.Context<Product[] | undefined>;
+export declare function useProductCollection(_useProductCollectionPlaceholder?: boolean): Product[] | undefined;
+export declare const CommerceProviderContext: React.Context<any>;

package/dist/contexts.js

@@ -0,0 +1,46 @@
+import React, { useContext } from "react";
+export const ProductContext = React.createContext(undefined);
+function useProductPlaceholder() {
+    const [product, setProduct] = React.useState();
+    React.useEffect(() => {
+        (async () => {
+            const response = await fetch(`/api/catalog/products`);
+            const { products } = await response.json();
+            setProduct(products[2]);
+        })();
+    }, []);
+    return product;
+}
+export function useProduct(_useProductPlaceholder) {
+    const product = useContext(ProductContext);
+    if (product) {
+        return product;
+    }
+    if (_useProductPlaceholder) {
+        return useProductPlaceholder();
+    }
+    return undefined;
+}
+export const ProductCollectionContext = React.createContext(undefined);
+function useProductCollectionPlaceholder() {
+    const [collection, setCollection] = React.useState();
+    React.useEffect(() => {
+        (async () => {
+            const response = await fetch(`/api/catalog/products`);
+            const { products } = await response.json();
+            setCollection(products);
+        })();
+    }, []);
+    return collection;
+}
+export function useProductCollection(_useProductCollectionPlaceholder) {
+    const collection = useContext(ProductCollectionContext);
+    if (collection) {
+        return collection;
+    }
+    if (_useProductCollectionPlaceholder) {
+        return useProductCollectionPlaceholder();
+    }
+    return undefined;
+}
+export const CommerceProviderContext = React.createContext(undefined);

package/dist/customer/address/use-add-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../../utils/types';
+import type { AddItemHook } from '../../types/customer/address';
+export declare type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<AddItemHook>;
+declare const useAddItem: UseAddItem;
+export default useAddItem;

package/dist/customer/address/use-add-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../../utils/use-hook';
+import { mutationFetcher } from '../../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.customer?.address?.useAddItem;
+const useAddItem = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useAddItem;

package/dist/customer/address/use-addresses.d.ts

@@ -0,0 +1,6 @@
+import type { SWRHook, HookFetcherFn } from '../../utils/types';
+import type { GetAddressesHook } from '../../types/customer/address';
+export declare type UseAddresses<H extends SWRHook<GetAddressesHook<any>> = SWRHook<GetAddressesHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<GetAddressesHook>;
+declare const useAddresses: UseAddresses;
+export default useAddresses;

package/dist/customer/address/use-addresses.js

@@ -0,0 +1,18 @@
+import Cookies from 'js-cookie';
+import { useHook, useSWRHook } from '../../utils/use-hook';
+import { useCommerce } from '../..';
+export const fetcher = async ({ options, input: { cartId }, fetch, }) => {
+    return cartId ? await fetch(options) : null;
+};
+const fn = (provider) => provider.customer?.address?.useAddresses;
+const useAddresses = (input) => {
+    const hook = useHook(fn);
+    const { cartCookie } = useCommerce();
+    const fetcherFn = hook.fetcher ?? fetcher;
+    const wrapper = (context) => {
+        context.input.cartId = Cookies.get(cartCookie);
+        return fetcherFn(context);
+    };
+    return useSWRHook({ ...hook, fetcher: wrapper })(input);
+};
+export default useAddresses;

package/dist/customer/address/use-remove-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../../utils/types';
+import type { RemoveItemHook } from '../../types/customer/address';
+export declare type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<RemoveItemHook>;
+declare const useRemoveItem: UseRemoveItem;
+export default useRemoveItem;

package/dist/customer/address/use-remove-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../../utils/use-hook';
+import { mutationFetcher } from '../../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.customer?.address?.useRemoveItem;
+const useRemoveItem = (input) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(input);
+};
+export default useRemoveItem;

package/dist/customer/address/use-update-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../../utils/types';
+import type { UpdateItemHook } from '../../types/customer/address';
+export declare type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<UpdateItemHook>;
+declare const useUpdateItem: UseUpdateItem;
+export default useUpdateItem;

package/dist/customer/address/use-update-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../../utils/use-hook';
+import { mutationFetcher } from '../../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.customer?.address?.useUpdateItem;
+const useUpdateItem = (input) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(input);
+};
+export default useUpdateItem;

package/dist/customer/card/use-add-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../../utils/types';
+import type { AddItemHook } from '../../types/customer/card';
+export declare type UseAddItem<H extends MutationHook<AddItemHook<any>> = MutationHook<AddItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<AddItemHook>;
+declare const useAddItem: UseAddItem;
+export default useAddItem;

package/dist/customer/card/use-add-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../../utils/use-hook';
+import { mutationFetcher } from '../../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.customer?.card?.useAddItem;
+const useAddItem = (...args) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(...args);
+};
+export default useAddItem;

package/dist/customer/card/use-cards.d.ts

@@ -0,0 +1,6 @@
+import type { SWRHook, HookFetcherFn } from '../../utils/types';
+import type { GetCardsHook } from '../../types/customer/card';
+export declare type UseCards<H extends SWRHook<GetCardsHook<any>> = SWRHook<GetCardsHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<GetCardsHook>;
+declare const useCards: UseCards;
+export default useCards;

package/dist/customer/card/use-cards.js

@@ -0,0 +1,18 @@
+import Cookies from 'js-cookie';
+import { useHook, useSWRHook } from '../../utils/use-hook';
+import { useCommerce } from '../..';
+export const fetcher = async ({ options, input: { cartId }, fetch, }) => {
+    return cartId ? await fetch(options) : null;
+};
+const fn = (provider) => provider.customer?.card?.useCards;
+const useCards = (input) => {
+    const hook = useHook(fn);
+    const { cartCookie } = useCommerce();
+    const fetcherFn = hook.fetcher ?? fetcher;
+    const wrapper = (context) => {
+        context.input.cartId = Cookies.get(cartCookie);
+        return fetcherFn(context);
+    };
+    return useSWRHook({ ...hook, fetcher: wrapper })(input);
+};
+export default useCards;

package/dist/customer/card/use-remove-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../../utils/types';
+import type { RemoveItemHook } from '../../types/customer/card';
+export declare type UseRemoveItem<H extends MutationHook<RemoveItemHook<any>> = MutationHook<RemoveItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<RemoveItemHook>;
+declare const useRemoveItem: UseRemoveItem;
+export default useRemoveItem;

package/dist/customer/card/use-remove-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../../utils/use-hook';
+import { mutationFetcher } from '../../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider.customer?.card?.useRemoveItem;
+const useRemoveItem = (input) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(input);
+};
+export default useRemoveItem;

package/dist/customer/card/use-update-item.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, MutationHook } from '../../utils/types';
+import type { UpdateItemHook } from '../../types/customer/card';
+export declare type UseUpdateItem<H extends MutationHook<UpdateItemHook<any>> = MutationHook<UpdateItemHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<UpdateItemHook>;
+declare const useUpdateItem: UseUpdateItem;
+export default useUpdateItem;

package/dist/customer/card/use-update-item.js

@@ -0,0 +1,9 @@
+import { useHook, useMutationHook } from '../../utils/use-hook';
+import { mutationFetcher } from '../../utils/default-fetcher';
+export const fetcher = mutationFetcher;
+const fn = (provider) => provider?.customer?.card?.useUpdateItem;
+const useUpdateItem = (input) => {
+    const hook = useHook(fn);
+    return useMutationHook({ fetcher, ...hook })(input);
+};
+export default useUpdateItem;

package/dist/customer/use-customer.d.ts

@@ -0,0 +1,6 @@
+import type { CustomerHook } from '../types/customer';
+import type { HookFetcherFn, SWRHook } from '../utils/types';
+export declare type UseCustomer<H extends SWRHook<CustomerHook<any>> = SWRHook<CustomerHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<CustomerHook>;
+declare const useCustomer: UseCustomer;
+export default useCustomer;

package/dist/customer/use-customer.js

@@ -0,0 +1,9 @@
+import { useHook, useSWRHook } from '../utils/use-hook';
+import { SWRFetcher } from '../utils/default-fetcher';
+export const fetcher = SWRFetcher;
+const fn = (provider) => provider.customer?.useCustomer;
+const useCustomer = (input) => {
+    const hook = useHook(fn);
+    return useSWRHook({ fetcher, ...hook })(input);
+};
+export default useCustomer;

package/dist/index.d.ts

@@ -0,0 +1,71 @@
+import { ReactNode, MutableRefObject } from 'react';
+import type { Customer, Wishlist, Cart, Product, Signup, Login, Logout, Checkout } from './types';
+import type { Fetcher, SWRHook, MutationHook } from './utils/types';
+import { Registerable } from "./registerable";
+export * from "./registerable";
+export * from "./registerProductImage";
+export * from './utils/types';
+export declare type Provider = CommerceConfig & {
+    fetcher: Fetcher;
+    cart?: {
+        useCart?: SWRHook<Cart.GetCartHook>;
+        useAddItem?: MutationHook<Cart.AddItemHook>;
+        useUpdateItem?: MutationHook<Cart.UpdateItemHook>;
+        useRemoveItem?: MutationHook<Cart.RemoveItemHook>;
+    };
+    checkout?: {
+        useCheckout?: SWRHook<Checkout.GetCheckoutHook>;
+        useSubmitCheckout?: MutationHook<Checkout.SubmitCheckoutHook>;
+    };
+    wishlist?: {
+        useWishlist?: SWRHook<Wishlist.GetWishlistHook>;
+        useAddItem?: MutationHook<Wishlist.AddItemHook>;
+        useRemoveItem?: MutationHook<Wishlist.RemoveItemHook>;
+    };
+    customer?: {
+        useCustomer?: SWRHook<Customer.CustomerHook>;
+        card?: {
+            useCards?: SWRHook<Customer.Card.GetCardsHook>;
+            useAddItem?: MutationHook<Customer.Card.AddItemHook>;
+            useUpdateItem?: MutationHook<Customer.Card.UpdateItemHook>;
+            useRemoveItem?: MutationHook<Customer.Card.RemoveItemHook>;
+        };
+        address?: {
+            useAddresses?: SWRHook<Customer.Address.GetAddressesHook>;
+            useAddItem?: MutationHook<Customer.Address.AddItemHook>;
+            useUpdateItem?: MutationHook<Customer.Address.UpdateItemHook>;
+            useRemoveItem?: MutationHook<Customer.Address.RemoveItemHook>;
+        };
+    };
+    products?: {
+        useSearch?: SWRHook<Product.SearchProductsHook>;
+    };
+    auth?: {
+        useSignup?: MutationHook<Signup.SignupHook>;
+        useLogin?: MutationHook<Login.LoginHook>;
+        useLogout?: MutationHook<Logout.LogoutHook>;
+    };
+};
+export declare type CommerceConfig = {
+    locale: string;
+    cartCookie: string;
+};
+export declare type CommerceContextValue<P extends Provider> = {
+    providerRef: MutableRefObject<P>;
+    fetcherRef: MutableRefObject<Fetcher>;
+} & CommerceConfig;
+export declare type CommerceProps<P extends Provider> = {
+    children?: ReactNode;
+    provider: P;
+};
+/**
+ * These are the properties every provider should allow when implementing
+ * the core commerce provider
+ */
+export declare type CommerceProviderProps = {
+    children?: ReactNode;
+} & Partial<CommerceConfig>;
+export declare function CoreCommerceProvider<P extends Provider>({ provider, children, }: CommerceProps<P>): JSX.Element;
+export declare function getCommerceProvider<P extends Provider>(provider: P): ({ children, ...props }: CommerceProviderProps) => JSX.Element;
+export declare function useCommerce<P extends Provider>(): CommerceContextValue<P>;
+export declare function registerAll(loader?: Registerable): void;

package/dist/index.js

@@ -0,0 +1,29 @@
+import React, { createContext, useContext, useMemo, useRef, } from 'react';
+import { registerProductCollection } from "./registerProductCollection";
+import { registerProductImage } from "./registerProductImage";
+export * from "./registerable";
+export * from "./registerProductImage";
+export * from './utils/types';
+const Commerce = createContext({});
+export function CoreCommerceProvider({ provider, children, }) {
+    const providerRef = useRef(provider);
+    // TODO: Remove the fetcherRef
+    const fetcherRef = useRef(provider.fetcher);
+    // If the parent re-renders this provider will re-render every
+    // consumer unless we memoize the config
+    const { locale, cartCookie } = providerRef.current;
+    const cfg = useMemo(() => ({ providerRef, fetcherRef, locale, cartCookie }), [locale, cartCookie]);
+    return React.createElement(Commerce.Provider, { value: cfg }, children);
+}
+export function getCommerceProvider(provider) {
+    return function CommerceProvider({ children, ...props }) {
+        return (React.createElement(CoreCommerceProvider, { provider: { ...provider, ...props } }, children));
+    };
+}
+export function useCommerce() {
+    return useContext(Commerce);
+}
+export function registerAll(loader) {
+    registerProductCollection(loader);
+    registerProductImage(loader);
+}

package/dist/product/use-price.d.ts

@@ -0,0 +1,26 @@
+export declare function formatPrice({ amount, currencyCode, locale, }: {
+    amount: number;
+    currencyCode: string;
+    locale: string;
+}): string;
+export declare function formatVariantPrice({ amount, baseAmount, currencyCode, locale, }: {
+    baseAmount: number;
+    amount: number;
+    currencyCode: string;
+    locale: string;
+}): {
+    price: string;
+    basePrice: string | null;
+    discount: string | null;
+};
+export default function usePrice(data?: {
+    amount: number;
+    baseAmount?: number;
+    currencyCode: string;
+} | null): {
+    price: string;
+    basePrice: string | null;
+    discount: string | null;
+} | {
+    price: string;
+};

package/dist/product/use-price.js

@@ -0,0 +1,33 @@
+import { useMemo } from 'react';
+import { useCommerce } from '..';
+export function formatPrice({ amount, currencyCode, locale, }) {
+    const formatCurrency = new Intl.NumberFormat(locale, {
+        style: 'currency',
+        currency: currencyCode,
+    });
+    return formatCurrency.format(amount);
+}
+export function formatVariantPrice({ amount, baseAmount, currencyCode, locale, }) {
+    const hasDiscount = baseAmount > amount;
+    const formatDiscount = new Intl.NumberFormat(locale, { style: 'percent' });
+    const discount = hasDiscount
+        ? formatDiscount.format((baseAmount - amount) / baseAmount)
+        : null;
+    const price = formatPrice({ amount, currencyCode, locale });
+    const basePrice = hasDiscount
+        ? formatPrice({ amount: baseAmount, currencyCode, locale })
+        : null;
+    return { price, basePrice, discount };
+}
+export default function usePrice(data) {
+    const { amount, baseAmount, currencyCode } = data ?? {};
+    const { locale } = useCommerce();
+    const value = useMemo(() => {
+        if (typeof amount !== 'number' || !currencyCode)
+            return '';
+        return baseAmount
+            ? formatVariantPrice({ amount, baseAmount, currencyCode, locale })
+            : formatPrice({ amount, currencyCode, locale });
+    }, [amount, baseAmount, currencyCode]);
+    return typeof value === 'string' ? { price: value } : value;
+}

package/dist/product/use-search.d.ts

@@ -0,0 +1,6 @@
+import type { HookFetcherFn, SWRHook } from '../utils/types';
+import type { SearchProductsHook } from '../types/product';
+export declare type UseSearch<H extends SWRHook<SearchProductsHook<any>> = SWRHook<SearchProductsHook>> = ReturnType<H['useHook']>;
+export declare const fetcher: HookFetcherFn<SearchProductsHook>;
+declare const useSearch: UseSearch;
+export default useSearch;

package/dist/product/use-search.js

@@ -0,0 +1,9 @@
+import { useHook, useSWRHook } from '../utils/use-hook';
+import { SWRFetcher } from '../utils/default-fetcher';
+export const fetcher = SWRFetcher;
+const fn = (provider) => provider.products?.useSearch;
+const useSearch = (input) => {
+    const hook = useHook(fn);
+    return useSWRHook({ fetcher, ...hook })(input);
+};
+export default useSearch;

package/dist/registerProductCollection.d.ts

@@ -0,0 +1,11 @@
+import { ComponentMeta } from "@plasmicapp/host/registerComponent";
+import React from "react";
+import { Registerable } from "./registerable";
+export declare const productCollectionMeta: ComponentMeta<ProductCollectionProps>;
+interface ProductCollectionProps {
+    children: React.ReactNode;
+    count: number;
+}
+export declare function ProductCollection(props: ProductCollectionProps): JSX.Element;
+export declare function registerProductCollection(loader?: Registerable, customProductCollection?: ComponentMeta<ProductCollectionProps>): void;
+export {};