@tiledev/sdk-shopify 0.2.5

package/dist/react/ShopifyProvider.js

@@ -0,0 +1,785 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShopifyProvider = ShopifyProvider;
+exports.useShopify = useShopify;
+exports.useCart = useCart;
+exports.useWishlist = useWishlist;
+exports.useCustomer = useCustomer;
+exports.useCheckout = useCheckout;
+exports.useShopifyMessage = useShopifyMessage;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const shopify_1 = require("../shopify");
+const cartPolicy_1 = require("../cartPolicy");
+const errors_1 = require("../errors");
+const messages_1 = require("../messages");
+/**
+ * Shopify rejecting the *contents* of a mutation rather than failing to answer it: only
+ * `userErrors` populate `ShopifyError.errors`, so transport and GraphQL failures arrive empty.
+ */
+function isLineRejection(error) {
+    return (0, errors_1.isUserErrorRejection)(error);
+}
+function sameAttributes(a, b) {
+    return (a.length === b.length &&
+        a.every((one) => b.some((other) => other.key === one.key && other.value === one.value)));
+}
+/**
+ * The line a just-sent input became. Shopify merges an add into an existing line only when the
+ * attributes match too, so a per-add attribute yields a *new* line for the same variant.
+ */
+function lineFor(cart, input) {
+    const candidates = cart.lines.filter((line) => { var _a; return ((_a = line.merchandise) === null || _a === void 0 ? void 0 : _a.id) === input.merchandiseId; });
+    if (candidates.length === 0)
+        return null;
+    const exact = candidates.find((line) => { var _a; return sameAttributes((_a = input.attributes) !== null && _a !== void 0 ? _a : [], line.attributes); });
+    return exact !== null && exact !== void 0 ? exact : candidates[candidates.length - 1];
+}
+const ShopifyContext = (0, react_1.createContext)(undefined);
+const CART_STORAGE_KEY = "shopify:cart-id:v1";
+const CUSTOMER_TOKEN_KEY = "shopify:customer-token:v1";
+/** Alert-carrying events and the message key each resolves. */
+const EVENT_MESSAGE = {
+    "cart:add": "cart.added",
+    "cart:remove": "cart.removed",
+    "cart:limitExceeded": "cart.limitExceeded",
+    "cart:outOfStock": "cart.outOfStock",
+    "wishlist:add": "wishlist.added",
+    "wishlist:remove": "wishlist.removed",
+    "auth:loginSuccess": "auth.loginSuccess",
+    "auth:loginFailed": "auth.loginFailed",
+    "auth:logout": "auth.loggedOut",
+    "auth:recoverSent": "auth.resetLinkSent",
+    "checkout:orderPlaced": "checkout.orderPlaced",
+    "checkout:paymentFailed": "checkout.paymentFailed",
+};
+const ERROR_EVENTS = new Set([
+    "cart:limitExceeded",
+    "cart:outOfStock",
+    "auth:loginFailed",
+    "checkout:paymentFailed",
+]);
+function defaultStorage() {
+    if (typeof globalThis !== "undefined" && typeof globalThis.localStorage !== "undefined") {
+        return globalThis.localStorage;
+    }
+    return null;
+}
+function ShopifyProvider({ children, config, storage, onEvent, cartGuard, wishlistKeepDeleted, messages, translate, cartPolicy, }) {
+    const [ready, setReady] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    const [cart, setCart] = (0, react_1.useState)(null);
+    const [cartLoading, setCartLoad] = (0, react_1.useState)(false);
+    const [wlItems, setWlItems] = (0, react_1.useState)([]);
+    const [customer, setCustomer] = (0, react_1.useState)(null);
+    const [token, setToken] = (0, react_1.useState)(null);
+    const [authLoading, setAuthLoad] = (0, react_1.useState)(false);
+    const [restoring, setRestoring] = (0, react_1.useState)(true);
+    const wlUnsubRef = (0, react_1.useRef)(null);
+    const storageRef = (0, react_1.useRef)(null);
+    storageRef.current = storage !== null && storage !== void 0 ? storage : defaultStorage();
+    // In a ref so the cart callbacks keep their identity when the host passes a new guard object.
+    const guardRef = (0, react_1.useRef)(cartGuard);
+    guardRef.current = cartGuard;
+    // Same for onEvent: a host that passes an inline arrow would otherwise rebuild
+    // every cart callback on each render.
+    const onEventRef = (0, react_1.useRef)(onEvent);
+    onEventRef.current = onEvent;
+    /**
+     * Resolves the copy for `type` and hands the event to the host. A throwing
+     * listener must not fail the write that triggered it — the mutation already
+     * landed, so swallowing here is the only honest option.
+     */
+    const emit = (0, react_1.useCallback)((type, error) => {
+        const listener = onEventRef.current;
+        if (!listener)
+            return;
+        const key = EVENT_MESSAGE[type];
+        const max = (0, cartPolicy_1.maxLineItems)();
+        const event = {
+            type,
+            severity: ERROR_EVENTS.has(type) ? "error" : key ? "success" : "info",
+            ...(key
+                ? {
+                    messageKey: key,
+                    message: type === "cart:limitExceeded" && max !== null
+                        ? (0, messages_1.limitExceededMessage)(max)
+                        : (0, messages_1.message)(key),
+                }
+                : {}),
+            ...(error === undefined ? {} : { error }),
+        };
+        try {
+            listener(event);
+        }
+        catch (listenerError) {
+            console.warn("[ShopifyProvider] onEvent threw", listenerError);
+        }
+    }, []);
+    /**
+     * Alert copy and cart rules, re-applied whenever the host passes new ones so a
+     * Live Layer publish lands without a re-init. `config` values are the base;
+     * the props win, which is what makes the panel's value authoritative.
+     */
+    const resolvedMessages = (0, react_1.useMemo)(() => { var _a; return ({ ...((_a = config.messages) !== null && _a !== void 0 ? _a : {}), ...(messages !== null && messages !== void 0 ? messages : {}) }); }, [config.messages, messages]);
+    const resolvedPolicy = cartPolicy !== null && cartPolicy !== void 0 ? cartPolicy : config.cart;
+    const resolvedTranslate = translate !== null && translate !== void 0 ? translate : config.translate;
+    /**
+     * Applied DURING render, not in an effect. The context value below reports the
+     * resolved limit in this same pass, and an effect-queued write would leave
+     * `cart.maxLineItems` at null until some unrelated re-render happened to
+     * recompute it. These are idempotent writes to module singletons, so a
+     * StrictMode double render costs nothing.
+     */
+    const appliedRef = (0, react_1.useRef)(null);
+    if (!appliedRef.current || appliedRef.current.messages !== resolvedMessages) {
+        shopify_1.shopify.alerts.setMessages(resolvedMessages);
+    }
+    if (!appliedRef.current || appliedRef.current.policy !== resolvedPolicy) {
+        shopify_1.shopify.alerts.setPolicy(resolvedPolicy);
+    }
+    if (!appliedRef.current || appliedRef.current.translate !== resolvedTranslate) {
+        (0, messages_1.setMessageResolver)(resolvedTranslate);
+    }
+    appliedRef.current = {
+        messages: resolvedMessages,
+        policy: resolvedPolicy,
+        translate: resolvedTranslate,
+    };
+    /**
+     * Re-applies what the render above already applied. `shopify.init()` sets both
+     * from `config` for the benefit of non-React consumers, so it runs AFTER this
+     * render and would otherwise clobber the props with the config's (often
+     * absent) values — the props are the authority.
+     */
+    const reapplyAlertConfig = (0, react_1.useCallback)(() => {
+        const applied = appliedRef.current;
+        if (!applied)
+            return;
+        shopify_1.shopify.alerts.setMessages(applied.messages);
+        shopify_1.shopify.alerts.setPolicy(applied.policy);
+        (0, messages_1.setMessageResolver)(applied.translate);
+    }, []);
+    /**
+     * Shopify rejects concurrent writes to one cart ("The cart conflicted with another request"), so
+     * every mutation waits for the one before it. The chain is never poisoned by a failure: the next
+     * write runs either way, while the caller still sees its own error.
+     */
+    const writeQueue = (0, react_1.useRef)(Promise.resolve());
+    const serialize = (0, react_1.useCallback)((write) => {
+        const run = writeQueue.current.then(write, write);
+        writeQueue.current = run.catch(() => undefined);
+        return run;
+    }, []);
+    /**
+     * A guard is advisory: a hook that throws must not take the cart down with it. `fallback` is what
+     * that failure means — approval for the `before*` hooks, nothing for the observers.
+     */
+    const runGuard = (0, react_1.useCallback)(async (work, fallback) => {
+        try {
+            return await work();
+        }
+        catch (guardError) {
+            console.warn("[ShopifyProvider] cartGuard failed; continuing", guardError);
+            return fallback;
+        }
+    }, []);
+    const approveAdd = (0, react_1.useCallback)(async (input) => {
+        const guard = guardRef.current;
+        if (!(guard === null || guard === void 0 ? void 0 : guard.beforeAdd))
+            return input;
+        return runGuard(() => guard.beforeAdd(input), input);
+    }, [runGuard]);
+    /** Hands back units the guard approved for a write that then failed. */
+    const releaseRejected = (0, react_1.useCallback)((input) => {
+        const guard = guardRef.current;
+        if (!(guard === null || guard === void 0 ? void 0 : guard.onReleased))
+            return;
+        void runGuard(() => guard.onReleased({
+            variantId: input.merchandiseId,
+            quantity: input.quantity,
+            reason: "rejected",
+            line: null,
+            cart: null,
+        }), undefined);
+    }, [runGuard]);
+    const announceLanded = (0, react_1.useCallback)((input, next) => {
+        const guard = guardRef.current;
+        if (!(guard === null || guard === void 0 ? void 0 : guard.onLanded))
+            return;
+        void runGuard(() => guard.onLanded({
+            variantId: input.merchandiseId,
+            quantity: input.quantity,
+            line: lineFor(next, input),
+            cart: next,
+        }), undefined);
+    }, [runGuard]);
+    (0, react_1.useEffect)(() => {
+        let mounted = true;
+        (async () => {
+            var _a;
+            try {
+                await shopify_1.shopify.init(config);
+                reapplyAlertConfig();
+                setCartLoad(true);
+                try {
+                    const s = storageRef.current;
+                    const savedId = s ? await Promise.resolve(s.getItem(CART_STORAGE_KEY)) : null;
+                    let next = null;
+                    if (savedId)
+                        next = await shopify_1.shopify.cart.get(savedId);
+                    if (!next) {
+                        next = await shopify_1.shopify.cart.create();
+                        if (s)
+                            await Promise.resolve(s.setItem(CART_STORAGE_KEY, next.id));
+                    }
+                    if (mounted)
+                        setCart(next);
+                }
+                finally {
+                    if (mounted)
+                        setCartLoad(false);
+                }
+                const initialItems = await shopify_1.shopify.wishlist.init({
+                    storage: (_a = storageRef.current) !== null && _a !== void 0 ? _a : undefined,
+                    keepDeleted: wishlistKeepDeleted,
+                });
+                if (mounted)
+                    setWlItems(initialItems);
+                wlUnsubRef.current = shopify_1.shopify.wishlist.onChange((items) => {
+                    if (mounted)
+                        setWlItems(items);
+                });
+                // Restore a stored session. A token that no longer resolves is dropped
+                // silently — an expired login is not a failed one, and firing
+                // `auth:loginFailed` on app open would toast at a shopper who did nothing.
+                try {
+                    const s = storageRef.current;
+                    const savedToken = s ? await Promise.resolve(s.getItem(CUSTOMER_TOKEN_KEY)) : null;
+                    if (savedToken) {
+                        const profile = await shopify_1.shopify.customer.profile(savedToken);
+                        if (mounted && profile) {
+                            setCustomer(profile);
+                            setToken(savedToken);
+                        }
+                        else if (s && !profile) {
+                            await Promise.resolve(s.removeItem(CUSTOMER_TOKEN_KEY));
+                        }
+                    }
+                }
+                catch (sessionError) {
+                    console.warn("[ShopifyProvider] session restore failed", sessionError);
+                }
+                finally {
+                    if (mounted)
+                        setRestoring(false);
+                }
+                if (mounted)
+                    setReady(true);
+            }
+            catch (e) {
+                console.error("[ShopifyProvider] init failed", e);
+                if (mounted) {
+                    setError(e instanceof Error ? e.message : String(e));
+                    setRestoring(false);
+                    // Ready so downstream UIs render an error state rather than an indefinite spinner.
+                    setReady(true);
+                }
+            }
+        })();
+        return () => {
+            var _a;
+            mounted = false;
+            (_a = wlUnsubRef.current) === null || _a === void 0 ? void 0 : _a.call(wlUnsubRef);
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const persistCart = (0, react_1.useCallback)(async (next) => {
+        setCart(next);
+        const s = storageRef.current;
+        if (!s)
+            return;
+        if (next)
+            await Promise.resolve(s.setItem(CART_STORAGE_KEY, next.id));
+        else
+            await Promise.resolve(s.removeItem(CART_STORAGE_KEY));
+    }, []);
+    const ensureCartId = (0, react_1.useCallback)(async () => {
+        if (cart === null || cart === void 0 ? void 0 : cart.id)
+            return cart.id;
+        const created = await shopify_1.shopify.cart.create();
+        await persistCart(created);
+        return created.id;
+    }, [cart, persistCart]);
+    /**
+     * Classifies a failed cart write and emits the matching alert before the error
+     * carries on to the caller. Returns true when it was an out-of-stock refusal,
+     * which the batch retry treats differently from a dead request.
+     */
+    const reportCartFailure = (0, react_1.useCallback)((failure) => {
+        if ((0, errors_1.isOutOfStockError)(failure)) {
+            emit("cart:outOfStock", failure);
+            return true;
+        }
+        return false;
+    }, [emit]);
+    const cartAddLine = (0, react_1.useCallback)(async (input) => {
+        const approved = await approveAdd(input);
+        if (!approved)
+            return { ok: false, reason: "guard", cart };
+        // Checked before the write so a refusal costs no round trip, and so the
+        // shopper reads the configured message rather than a Shopify error.
+        if ((0, cartPolicy_1.wouldExceedLineLimit)(cart, [approved])) {
+            emit("cart:limitExceeded");
+            const max = (0, cartPolicy_1.maxLineItems)();
+            return {
+                ok: false,
+                reason: "limit",
+                message: max !== null ? (0, messages_1.limitExceededMessage)(max) : undefined,
+                cart,
+            };
+        }
+        setCartLoad(true);
+        try {
+            const id = await ensureCartId();
+            let next;
+            try {
+                next = await serialize(() => shopify_1.shopify.cart.addLines(id, [approved]));
+            }
+            catch (addError) {
+                releaseRejected(approved);
+                reportCartFailure(addError);
+                throw addError;
+            }
+            await persistCart(next);
+            emit("cart:add");
+            announceLanded(approved, next);
+            return { ok: true, cart: next };
+        }
+        finally {
+            setCartLoad(false);
+        }
+    }, [cart, approveAdd, releaseRejected, announceLanded, ensureCartId, persistCart, emit, reportCartFailure, serialize]);
+    const cartAddLines = (0, react_1.useCallback)(async (requested) => {
+        if (requested.length === 0)
+            return cart;
+        // Vetted up front so a guard's veto does not cost the other lines their fast path.
+        const inputs = (await Promise.all(requested.map(approveAdd))).filter((input) => input !== null);
+        if (inputs.length === 0)
+            return null;
+        // The whole batch is judged against the limit, not line by line — landing
+        // half a "add these 5" is worse than refusing it with the message.
+        if ((0, cartPolicy_1.wouldExceedLineLimit)(cart, inputs)) {
+            emit("cart:limitExceeded");
+            return null;
+        }
+        setCartLoad(true);
+        try {
+            const id = await ensureCartId();
+            let next = null;
+            // Which inputs landed, so the guard hears about exactly those.
+            let landed = [];
+            try {
+                next = await serialize(() => shopify_1.shopify.cart.addLines(id, inputs));
+                landed = inputs;
+            }
+            catch (batchError) {
+                // A transport or GraphQL failure would fail all N the same way, so retrying it would turn
+                // one dead request into N and still end at null. Only line rejections are worth retrying.
+                if (!isLineRejection(batchError)) {
+                    inputs.forEach(releaseRejected);
+                    reportCartFailure(batchError);
+                    throw batchError;
+                }
+                // The batch is all-or-nothing, so retry one line at a time and keep the successes. They
+                // accumulate server-side, so `next` ends up holding the whole accepted set.
+                let anyOutOfStock = false;
+                for (let i = 0; i < inputs.length; i += 1) {
+                    const input = inputs[i];
+                    try {
+                        next = await serialize(() => shopify_1.shopify.cart.addLines(id, [input]));
+                        landed.push(input);
+                    }
+                    catch (lineError) {
+                        releaseRejected(input);
+                        if ((0, errors_1.isOutOfStockError)(lineError))
+                            anyOutOfStock = true;
+                        // Anything but a rejection means the retry itself is failing, so stop.
+                        if (!isLineRejection(lineError)) {
+                            inputs.slice(i + 1).forEach(releaseRejected);
+                            reportCartFailure(lineError);
+                            throw lineError;
+                        }
+                    }
+                }
+                // One alert for the batch: N unsellable lines is one thing that went
+                // wrong from the shopper's side, not N toasts.
+                if (anyOutOfStock)
+                    emit("cart:outOfStock", batchError);
+                // Every line individually rejected. Surface the original rather than an empty success,
+                // which reads as "nothing to add" instead of "none of this is sellable".
+                if (landed.length === 0)
+                    throw batchError;
+            }
+            if (next) {
+                await persistCart(next);
+                emit("cart:add");
+                const settled = next;
+                landed.forEach((input) => announceLanded(input, settled));
+            }
+            return next;
+        }
+        finally {
+            setCartLoad(false);
+        }
+    }, [cart, approveAdd, releaseRejected, announceLanded, ensureCartId, persistCart, emit, reportCartFailure, serialize]);
+    const cartSetBuyerIdentity = (0, react_1.useCallback)(async (identity) => {
+        // Deliberately does NOT create a cart — that would mint an empty one checkout never sees.
+        if (!(cart === null || cart === void 0 ? void 0 : cart.id))
+            return false;
+        setCartLoad(true);
+        try {
+            const next = await serialize(() => shopify_1.shopify.cart.setBuyerIdentity(cart.id, identity));
+            await persistCart(next);
+            emit("cart:buyerIdentity");
+            return true;
+        }
+        finally {
+            setCartLoad(false);
+        }
+    }, [cart, persistCart, emit, serialize]);
+    const cartUpdateLine = (0, react_1.useCallback)(async (lineId, quantity, attributes) => {
+        var _a;
+        if (!(cart === null || cart === void 0 ? void 0 : cart.id))
+            return false;
+        const guard = guardRef.current;
+        const previous = (_a = cart.lines.find((line) => line.id === lineId)) !== null && _a !== void 0 ? _a : null;
+        const delta = previous ? quantity - previous.quantity : 0;
+        // Only an increase can be vetted; a decrease is reported after the fact, once Shopify has
+        // actually taken the units back.
+        let update = { id: lineId, quantity, ...(attributes ? { attributes } : {}) };
+        if (previous && delta > 0 && (guard === null || guard === void 0 ? void 0 : guard.beforeIncrease)) {
+            const approved = await runGuard(() => guard.beforeIncrease(previous, quantity), update);
+            if (!approved)
+                return false;
+            update = approved;
+        }
+        setCartLoad(true);
+        try {
+            let next;
+            try {
+                next = await serialize(() => shopify_1.shopify.cart.updateLines(cart.id, [update]));
+            }
+            catch (updateError) {
+                if (previous && delta > 0) {
+                    releaseRejected({ merchandiseId: previous.merchandise.id, quantity: delta });
+                }
+                reportCartFailure(updateError);
+                throw updateError;
+            }
+            await persistCart(next);
+            // A quantity change is not one of the panel's alerts — emitted as a state
+            // signal so a host can refresh a badge, with no copy attached.
+            emit("cart:update");
+            if (previous && delta < 0 && (guard === null || guard === void 0 ? void 0 : guard.onReleased)) {
+                void runGuard(() => guard.onReleased({
+                    variantId: previous.merchandise.id,
+                    quantity: -delta,
+                    reason: "decreased",
+                    line: previous,
+                    cart: next,
+                }), undefined);
+            }
+            return true;
+        }
+        finally {
+            setCartLoad(false);
+        }
+    }, [cart, persistCart, runGuard, releaseRejected, emit, reportCartFailure, serialize]);
+    const cartRemoveLine = (0, react_1.useCallback)(async (lineId) => {
+        var _a;
+        if (!(cart === null || cart === void 0 ? void 0 : cart.id))
+            return;
+        const guard = guardRef.current;
+        const previous = (_a = cart.lines.find((line) => line.id === lineId)) !== null && _a !== void 0 ? _a : null;
+        setCartLoad(true);
+        try {
+            const next = await serialize(() => shopify_1.shopify.cart.removeLines(cart.id, [lineId]));
+            await persistCart(next);
+            // The panel's "Removed From Cart" alert. Previously nothing fired here, so
+            // the configured copy had no trigger at all.
+            emit("cart:remove");
+            if (previous && (guard === null || guard === void 0 ? void 0 : guard.onReleased)) {
+                void runGuard(() => guard.onReleased({
+                    variantId: previous.merchandise.id,
+                    quantity: previous.quantity,
+                    reason: "removed",
+                    line: previous,
+                    cart: next,
+                }), undefined);
+            }
+        }
+        finally {
+            setCartLoad(false);
+        }
+    }, [cart, persistCart, runGuard, emit, serialize]);
+    const cartApplyDiscounts = (0, react_1.useCallback)(async (codes) => {
+        if (!(cart === null || cart === void 0 ? void 0 : cart.id))
+            return;
+        setCartLoad(true);
+        try {
+            const next = await serialize(() => shopify_1.shopify.cart.applyDiscountCodes(cart.id, codes));
+            await persistCart(next);
+        }
+        finally {
+            setCartLoad(false);
+        }
+    }, [cart, persistCart, serialize]);
+    const cartRefresh = (0, react_1.useCallback)(async () => {
+        if (!(cart === null || cart === void 0 ? void 0 : cart.id))
+            return null;
+        const next = await shopify_1.shopify.cart.get(cart.id);
+        if (next)
+            await persistCart(next);
+        return next;
+    }, [cart, persistCart]);
+    const cartAdopt = (0, react_1.useCallback)(async (cartId) => {
+        const next = await shopify_1.shopify.cart.get(cartId);
+        if (next)
+            await persistCart(next);
+        return next;
+    }, [persistCart]);
+    const cartReset = (0, react_1.useCallback)(async () => {
+        const created = await shopify_1.shopify.cart.create();
+        await persistCart(created);
+    }, [persistCart]);
+    // The wishlist module owns storage and hydration; these just wrap the mutating methods and
+    // rely on onChange to keep React in sync.
+    const wlAdd = (0, react_1.useCallback)(async (p) => { await shopify_1.shopify.wishlist.add(p); emit("wishlist:add"); }, [emit]);
+    // `remove` emits too. It used not to, so "Removed From Wishlist" only ever
+    // fired via `toggle` — a dedicated remove button showed nothing.
+    const wlRemove = (0, react_1.useCallback)(async (id) => {
+        const removed = await shopify_1.shopify.wishlist.remove(id);
+        if (removed)
+            emit("wishlist:remove");
+    }, [emit]);
+    const wlToggle = (0, react_1.useCallback)(async (p) => {
+        const nowSaved = await shopify_1.shopify.wishlist.toggle(p);
+        emit(nowSaved ? "wishlist:add" : "wishlist:remove");
+        return nowSaved;
+    }, [emit]);
+    const wlClear = (0, react_1.useCallback)(async () => { await shopify_1.shopify.wishlist.clear(); }, []);
+    const wlRefresh = (0, react_1.useCallback)(async () => { await shopify_1.shopify.wishlist.refresh({ keepDeleted: wishlistKeepDeleted }); }, [wishlistKeepDeleted]);
+    const wlHas = (0, react_1.useCallback)((id) => shopify_1.shopify.wishlist.has(id), []);
+    // ── Customer session ────────────────────────────────────────────────────────
+    // Wraps `shopify.customer` with token persistence and the four Login alerts.
+    // Bad credentials resolve `false` rather than throwing: it is an expected
+    // answer to a login form, and every caller would otherwise need a try/catch to
+    // tell it apart from the store being unreachable (which still throws).
+    const persistToken = (0, react_1.useCallback)(async (next) => {
+        setToken(next);
+        const s = storageRef.current;
+        if (!s)
+            return;
+        if (next)
+            await Promise.resolve(s.setItem(CUSTOMER_TOKEN_KEY, next));
+        else
+            await Promise.resolve(s.removeItem(CUSTOMER_TOKEN_KEY));
+    }, []);
+    const authLogin = (0, react_1.useCallback)(async (email, password) => {
+        setAuthLoad(true);
+        try {
+            let accessToken;
+            try {
+                const minted = await shopify_1.shopify.customer.login({ email, password });
+                accessToken = minted.accessToken;
+            }
+            catch (loginError) {
+                // Only a credential problem is a "Login Failed" toast; a network failure
+                // is not the shopper's mistake, so it propagates instead.
+                if ((0, errors_1.classifyAuthFailure)(loginError) === "unknown")
+                    throw loginError;
+                emit("auth:loginFailed", loginError);
+                return false;
+            }
+            const profile = await shopify_1.shopify.customer.profile(accessToken);
+            await persistToken(accessToken);
+            setCustomer(profile);
+            emit("auth:loginSuccess");
+            return true;
+        }
+        finally {
+            setAuthLoad(false);
+        }
+    }, [emit, persistToken]);
+    const authSignup = (0, react_1.useCallback)(async (input) => {
+        setAuthLoad(true);
+        try {
+            let created;
+            try {
+                created = await shopify_1.shopify.customer.signup(input);
+            }
+            catch (signupError) {
+                if ((0, errors_1.classifyAuthFailure)(signupError) === "unknown")
+                    throw signupError;
+                emit("auth:loginFailed", signupError);
+                return false;
+            }
+            await persistToken(created.accessToken.accessToken);
+            setCustomer(created.customer);
+            // Signup mints a token, so the shopper IS logged in — both events fire, and
+            // a host that only toasts on `auth:loginSuccess` still says the right thing.
+            emit("auth:signup");
+            emit("auth:loginSuccess");
+            return true;
+        }
+        finally {
+            setAuthLoad(false);
+        }
+    }, [emit, persistToken]);
+    const authLogout = (0, react_1.useCallback)(async () => {
+        const current = token;
+        setAuthLoad(true);
+        try {
+            if (current) {
+                try {
+                    await shopify_1.shopify.customer.logout(current);
+                }
+                catch (logoutError) {
+                    // The local session ends regardless — leaving a shopper "logged in"
+                    // because Shopify was unreachable is the worse failure.
+                    console.warn("[ShopifyProvider] token delete failed; clearing locally", logoutError);
+                }
+            }
+            await persistToken(null);
+            setCustomer(null);
+            emit("auth:logout");
+        }
+        finally {
+            setAuthLoad(false);
+        }
+    }, [token, emit, persistToken]);
+    const authRecover = (0, react_1.useCallback)(async (email) => {
+        setAuthLoad(true);
+        try {
+            await shopify_1.shopify.customer.recoverPassword(email);
+            emit("auth:recoverSent");
+        }
+        finally {
+            setAuthLoad(false);
+        }
+    }, [emit]);
+    const authRefresh = (0, react_1.useCallback)(async () => {
+        if (!token)
+            return null;
+        const profile = await shopify_1.shopify.customer.profile(token);
+        if (!profile) {
+            // Token expired or revoked. Clear it silently — see the mount restore.
+            await persistToken(null);
+            setCustomer(null);
+            return null;
+        }
+        setCustomer(profile);
+        return profile;
+    }, [token, persistToken]);
+    // ── Checkout outcome ────────────────────────────────────────────────────────
+    const checkoutOrderPlaced = (0, react_1.useCallback)(async (details) => {
+        emit("checkout:orderPlaced", details);
+        // The old cart is spent once an order exists; keeping it would show the
+        // shopper their purchased items still sitting in the bag.
+        try {
+            await cartReset();
+        }
+        catch (resetError) {
+            console.warn("[ShopifyProvider] cart reset after order failed", resetError);
+        }
+    }, [emit, cartReset]);
+    const checkoutPaymentFailed = (0, react_1.useCallback)((paymentError) => {
+        emit("checkout:paymentFailed", paymentError);
+    }, [emit]);
+    const value = (0, react_1.useMemo)(() => {
+        var _a, _b;
+        return ({
+            ready, error,
+            message: messages_1.message,
+            cart: {
+                cart, loading: cartLoading, itemCount: (_a = cart === null || cart === void 0 ? void 0 : cart.totalQuantity) !== null && _a !== void 0 ? _a : 0,
+                lineCount: (_b = cart === null || cart === void 0 ? void 0 : cart.lines.length) !== null && _b !== void 0 ? _b : 0,
+                maxLineItems: (0, cartPolicy_1.maxLineItems)(),
+                addLine: cartAddLine,
+                addLines: cartAddLines,
+                updateLine: cartUpdateLine,
+                removeLine: cartRemoveLine,
+                applyDiscountCodes: cartApplyDiscounts,
+                setBuyerIdentity: cartSetBuyerIdentity,
+                refresh: cartRefresh,
+                adopt: cartAdopt,
+                reset: cartReset,
+            },
+            wishlist: {
+                items: wlItems,
+                count: wlItems.length,
+                has: wlHas,
+                isWishlisted: wlHas,
+                add: wlAdd,
+                remove: wlRemove,
+                toggle: wlToggle,
+                clear: wlClear,
+                refresh: wlRefresh,
+            },
+            customer: {
+                customer,
+                loggedIn: !!customer,
+                accessToken: token,
+                loading: authLoading,
+                restoring,
+                login: authLogin,
+                signup: authSignup,
+                logout: authLogout,
+                recoverPassword: authRecover,
+                refresh: authRefresh,
+            },
+            checkout: {
+                reportOrderPlaced: checkoutOrderPlaced,
+                reportPaymentFailed: checkoutPaymentFailed,
+            },
+        });
+    }, [
+        ready, error,
+        // A new policy changes `cart.maxLineItems`, so the memo must see it.
+        resolvedPolicy,
+        cart, cartLoading, cartAddLine, cartAddLines, cartUpdateLine, cartRemoveLine, cartApplyDiscounts, cartSetBuyerIdentity, cartRefresh, cartAdopt, cartReset,
+        wlItems, wlHas, wlAdd, wlRemove, wlToggle, wlClear, wlRefresh,
+        customer, token, authLoading, restoring, authLogin, authSignup, authLogout, authRecover, authRefresh,
+        checkoutOrderPlaced, checkoutPaymentFailed,
+    ]);
+    return (0, jsx_runtime_1.jsx)(ShopifyContext.Provider, { value: value, children: children });
+}
+function useShopify() {
+    const ctx = (0, react_1.useContext)(ShopifyContext);
+    if (!ctx)
+        throw new Error("useShopify must be used within a ShopifyProvider");
+    return ctx;
+}
+function useCart() {
+    return useShopify().cart;
+}
+function useWishlist() {
+    return useShopify().wishlist;
+}
+/** Customer session — the source of the four Login alerts. */
+function useCustomer() {
+    return useShopify().customer;
+}
+/** Reports a hosted-checkout outcome so the two Checkout alerts can fire. */
+function useCheckout() {
+    return useShopify().checkout;
+}
+/**
+ * Resolved alert copy, for UI that isn't a toast — the empty-wishlist
+ * placeholder (`wishlist.empty`) is configurable but has no event.
+ */
+function useShopifyMessage() {
+    return useShopify().message;
+}
+//# sourceMappingURL=ShopifyProvider.js.map