@lana-commerce/core 11.0.0

package/cjs/modules/cart.js

@@ -0,0 +1,708 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCart = void 0;
+const tslib_1 = require("tslib");
+const effector_1 = require("effector");
+const lite_1 = require("dequal/lite");
+const json_1 = require("klona/json");
+const request_js_1 = require("../request.js");
+const cartOperation_js_1 = require("../cartOperation.js");
+const controlledQueue_js_1 = require("../controlledQueue.js");
+const codes_js_1 = require("../generated/codes.js");
+const persist_js_1 = require("./persist.js");
+const mapResponseData_js_1 = require("../mapResponseData.js");
+const nonNull_js_1 = require("../nonNull.js");
+class RelaxedCartActivityReporter {
+    constructor(delay, onActivity) {
+        this.delay = delay;
+        this.onActivity = onActivity;
+        this.lastReported = "idle";
+    }
+    reportDelayed(activity) {
+        const { onActivity } = this;
+        if (!onActivity)
+            return;
+        this.timer = setTimeout(() => {
+            this.lastReported = activity;
+            onActivity(activity);
+        }, this.delay);
+    }
+    report(activity) {
+        var _a;
+        if (this.timer)
+            clearTimeout(this.timer);
+        if (this.lastReported !== "idle" && activity === "idle") {
+            this.reportDelayed("idle");
+        }
+        else {
+            this.lastReported = activity;
+            (_a = this.onActivity) === null || _a === void 0 ? void 0 : _a.call(this, activity);
+        }
+    }
+}
+function apiStateToLineItems(state, predictedLineItems) {
+    var _a, _b, _c;
+    const out = [];
+    for (let i = 0; i < state.line_items.length; i++) {
+        const li = state.line_items[i];
+        const ci = li.custom_item_index >= 0 ? (_a = state.custom_items) === null || _a === void 0 ? void 0 : _a[li.custom_item_index] : undefined;
+        // we will use fake custom item id as variant id, variant id is used for addressing in the API
+        const variantID = ci ? ci.id : (0, nonNull_js_1.nonNull)(li.variant_id, "line item variant_id");
+        const variant = li.variant || ((_b = predictedLineItems === null || predictedLineItems === void 0 ? void 0 : predictedLineItems.find((pli) => pli.variantID === variantID)) === null || _b === void 0 ? void 0 : _b.variant);
+        out.push({
+            quantity: li.quantity,
+            variant,
+            variantID,
+            discountPreview: li.discount_preview,
+            fieldSetID: ((_c = li.field_set) === null || _c === void 0 ? void 0 : _c.id) || "",
+            fields: li.fields,
+            subscriptionPlanIndex: li.subscription_plan_index,
+            customItemIndex: li.custom_item_index,
+            customItem: ci ? { id: ci.id, title: ci.title, price: ci.price } : undefined,
+        });
+    }
+    return out;
+}
+function doApplyOperationsToLineItems(lineItems, operations) {
+    let newLineItems = (0, json_1.klona)(lineItems);
+    for (const op of operations) {
+        if (op.kind === "change") {
+            const li = newLineItems.find((li) => li.variantID === op.variantID);
+            if (li) {
+                const hasDiscountPreview = li.discountPreview > 0;
+                if (hasDiscountPreview) {
+                    li.discountPreview /= li.quantity;
+                }
+                li.quantity += op.quantityDelta;
+                if (hasDiscountPreview) {
+                    li.discountPreview *= li.quantity;
+                    li.discountPreview = Math.round(li.discountPreview);
+                }
+                if (op.fieldSetID !== undefined && op.fields !== undefined) {
+                    li.fields = op.fields;
+                    li.fieldSetID = op.fieldSetID;
+                }
+                if (op.subscriptionPlanIndex !== undefined) {
+                    li.subscriptionPlanIndex = op.subscriptionPlanIndex;
+                }
+                if (op.customItemIndex !== undefined) {
+                    li.customItemIndex = op.customItemIndex;
+                }
+            }
+            else if (op.quantityDelta > 0) {
+                newLineItems.push({
+                    quantity: op.quantityDelta,
+                    variant: op.variant,
+                    variantID: op.variantID,
+                    discountPreview: 0,
+                    fieldSetID: op.fieldSetID || "",
+                    fields: op.fields,
+                    subscriptionPlanIndex: op.subscriptionPlanIndex,
+                    customItemIndex: op.customItemIndex,
+                });
+            }
+            else {
+                // this should never happen
+                console.error(`line item not found (${op.variantID}) and quantity delta is ${op.quantityDelta}`);
+            }
+        }
+        else if (op.kind === "remove") {
+            newLineItems = newLineItems.filter((li) => li.variantID !== op.variantID);
+        }
+        else if (op.kind === "set") {
+            const li = newLineItems.find((li) => li.variantID === op.variantID);
+            if (op.quantity <= 0) {
+                // this should never happen
+                console.error(`negative quantity on set operation ${op.variantID}: ${op.quantity}`);
+            }
+            else if (li) {
+                if (li.discountPreview > 0) {
+                    li.discountPreview /= li.quantity;
+                    li.discountPreview *= op.quantity;
+                    li.discountPreview = Math.round(li.discountPreview);
+                }
+                li.quantity = op.quantity;
+                if (op.fieldSetID !== undefined && op.fields !== undefined) {
+                    li.fields = op.fields;
+                    li.fieldSetID = op.fieldSetID;
+                }
+                if (op.subscriptionPlanIndex !== undefined) {
+                    li.subscriptionPlanIndex = op.subscriptionPlanIndex;
+                }
+                if (op.customItemIndex !== undefined) {
+                    li.customItemIndex = op.customItemIndex;
+                }
+            }
+            else {
+                newLineItems.push({
+                    quantity: op.quantity,
+                    variant: op.variant,
+                    variantID: op.variantID,
+                    discountPreview: 0,
+                    fieldSetID: op.fieldSetID || "",
+                    fields: op.fields,
+                    subscriptionPlanIndex: op.subscriptionPlanIndex,
+                    customItemIndex: op.customItemIndex,
+                });
+            }
+        }
+    }
+    if (newLineItems.some((li) => li.quantity <= 0)) {
+        newLineItems = newLineItems.filter((li) => li.quantity > 0);
+    }
+    return newLineItems;
+}
+function lineItemsToAPIMutation(lineItems) {
+    return lineItems.map((li) => ({
+        variant_id: li.variantID.startsWith("ci_") ? "" : li.variantID,
+        quantity: li.quantity,
+        field_set_id: li.fieldSetID,
+        fields: li.fields,
+        subscription_plan_index: li.subscriptionPlanIndex !== undefined ? { value: li.subscriptionPlanIndex } : undefined,
+        custom_item_index: li.customItemIndex !== undefined ? { value: li.customItemIndex } : undefined,
+    }));
+}
+/**
+ * Create the Cart instance with a given config and init option. Note that if init option is not "new", cart
+ * will start fetching its state from the server right away.
+ */
+function createCart(config, init) {
+    let initialized = false;
+    let configWithJWT = Object.assign({}, config);
+    let savedCurrency = "";
+    const queue = new controlledQueue_js_1.ControlledQueue();
+    const setActivity = (0, effector_1.createEvent)();
+    const setLocked = (0, effector_1.createEvent)();
+    const setCartData = (0, effector_1.createEvent)();
+    const setLineItems = (0, effector_1.createEvent)();
+    const setLineItemsIfChanged = (0, effector_1.createEvent)();
+    const setCurrencyValue = (0, effector_1.createEvent)();
+    const applyOperationsToLineItems = (0, effector_1.createEvent)();
+    const setDiscountCodeResult = (0, effector_1.createEvent)();
+    const setDiscountCodePending = (0, effector_1.createEvent)();
+    const setDiscountCodeResultAndPending = (0, effector_1.createEvent)();
+    const setDiscountCodeInput = (0, effector_1.createEvent)();
+    const setAllState = (0, effector_1.createEvent)();
+    const discountCodeInput = (0, effector_1.restore)(setDiscountCodeInput, "")
+        .reset((0, effector_1.guard)({ source: setDiscountCodeResult, filter: (v) => v.kind === "ok" }))
+        .on(setAllState, (_, v) => v.discountCodeInput);
+    const activity = (0, effector_1.restore)(setActivity, "idle").on(setAllState, (_, v) => v.activity);
+    const locked = (0, effector_1.restore)(setLocked, false).on(setAllState, (_, v) => v.locked);
+    const lineItems = (0, effector_1.restore)(setLineItems, [])
+        .on(applyOperationsToLineItems, doApplyOperationsToLineItems)
+        .on(setLineItemsIfChanged, (lineItems, newLineItems) => !(0, lite_1.dequal)(lineItems, newLineItems) ? newLineItems : undefined)
+        .on(setAllState, (_, v) => v.lineItems);
+    const cartData = (0, effector_1.restore)(setCartData, null).on(setAllState, (_, v) => v.cartData);
+    const discountCode = (0, effector_1.createStore)("")
+        .on(setCartData, (_, v) => (v === null || v === void 0 ? void 0 : v.cart.discount_code) || "")
+        .on(setAllState, (_, v) => v.discountCode);
+    const discountCodePending = (0, effector_1.restore)(setDiscountCodePending, false).on(setAllState, (_, v) => v.discountCodePending);
+    const discountCodeResult = (0, effector_1.restore)(setDiscountCodeResult, { kind: "ok" }).on(setAllState, (_, v) => v.discountCodeResult);
+    const currency = (0, effector_1.restore)(setCurrencyValue, "")
+        .on(setCartData, (_, v) => (v === null || v === void 0 ? void 0 : v.cart.currency) || "")
+        .on(setAllState, (_, v) => v.currency);
+    let persistLoaded = false;
+    if (config.persist) {
+        const VERSION = 1;
+        const { load, save, onChange, maxAgeMs } = config.persist;
+        const realMaxAgeMs = Math.max(maxAgeMs !== null && maxAgeMs !== void 0 ? maxAgeMs : 0, 0) || 1800000;
+        const allState = (0, effector_1.combine)({
+            discountCodeInput,
+            activity,
+            locked,
+            lineItems,
+            cartData,
+            discountCode,
+            discountCodePending,
+            discountCodeResult,
+            currency,
+        });
+        if (init.kind === "load_or") {
+            const allState = (0, persist_js_1.deserialize)(load(), VERSION, realMaxAgeMs);
+            if (allState) {
+                setAllState(allState);
+                persistLoaded = true;
+            }
+        }
+        allState.updates.watch((data) => {
+            if (data.activity === "idle") {
+                // We only save cart when it's idle.
+                save((0, persist_js_1.serialize)(data, VERSION));
+            }
+        });
+        onChange((data) => {
+            const newAllState = (0, persist_js_1.deserialize)(data, VERSION, realMaxAgeMs);
+            if (newAllState) {
+                queue.exec(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    if (allState.getState().activity === "idle") {
+                        // Only set new state if the cart is idle. It's better to ignore state updates from other browser tabs
+                        // than to disrupt the current cart flow, whatever it is. Cart has recovery mechanisms for dealing with
+                        // out-of-date state.
+                        setAllState(newAllState);
+                    }
+                }));
+            }
+        });
+    }
+    // api sync queue is drained as soon as possible and is used to update "lastAPIState"
+    const apiSyncQueue = [];
+    // prediction queue is drained as soon as possible and is used to produce "lineItems"
+    const predictionQueue = [];
+    const relaxedActivityReporter = new RelaxedCartActivityReporter(400, setActivity);
+    (0, effector_1.forward)({
+        from: setDiscountCodeResultAndPending.map(([r, _code, _p]) => r),
+        to: setDiscountCodeResult,
+    });
+    (0, effector_1.forward)({
+        from: setDiscountCodeResultAndPending.map(([_r, _code, p]) => p),
+        to: setDiscountCodePending,
+    });
+    // init never fails
+    queue.exec(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (init.kind === "load_or") {
+            if (persistLoaded) {
+                initialized = true;
+                applyPredictionsIfInitialized();
+            }
+            else {
+                yield initCart(init.init);
+            }
+        }
+        else {
+            yield initCart(init);
+        }
+    }));
+    function reportActivity(activity) {
+        relaxedActivityReporter.report(activity);
+    }
+    function applyLastAPIState(cart, predictedLineItems) {
+        const cartData = {
+            cart,
+            lineItems: apiStateToLineItems(cart, predictedLineItems),
+        };
+        setCartData(cartData);
+        return cartData;
+    }
+    function initCart(init) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { graphql: { getCartQuery, getLastCartQuery }, shopID, opts, } = configWithJWT;
+            let resp;
+            if (init.kind === "fetch_by_id") {
+                reportActivity("init");
+                resp = (0, mapResponseData_js_1.firstResponseData)(yield (0, request_js_1.request)(getCartQuery)({ shopID, id: init.id, uuid: init.uuid }, opts));
+                reportActivity("idle");
+            }
+            else if (init.kind === "fetch_last") {
+                reportActivity("init");
+                resp = yield (0, request_js_1.request)(getLastCartQuery)({ shopID }, opts);
+                reportActivity("idle");
+            }
+            else if (init.kind === "fetch_last_or_by_id") {
+                reportActivity("init");
+                resp = yield (0, request_js_1.request)(getLastCartQuery)({ shopID }, opts);
+                if (resp.kind === "error" && ((_a = resp.error.apiError) === null || _a === void 0 ? void 0 : _a.code) === codes_js_1.ErrorCode.NotFound) {
+                    resp = (0, mapResponseData_js_1.firstResponseData)(yield (0, request_js_1.request)(getCartQuery)({ shopID, id: init.id, uuid: init.uuid }, opts));
+                }
+                reportActivity("idle");
+            }
+            else if (init.kind === "new") {
+                // do nothing, new cart will be initialized lazily
+            }
+            if (resp) {
+                if (resp.kind === "data") {
+                    if (resp.data.state === "cart") {
+                        setLineItems(applyLastAPIState(resp.data).lineItems);
+                    }
+                    else {
+                        // for non-cart state we also do nothing
+                        // TODO: unreserve reserved orders
+                        console.error("order is not in cart state");
+                    }
+                }
+                else {
+                    // print error and do nothing, we'll start a new cart
+                    console.error((0, request_js_1.prettyPrintRequestResponseError)(resp));
+                }
+            }
+            initialized = true;
+            applyPredictionsIfInitialized();
+        });
+    }
+    function drainPredictionQueue() {
+        const operations = (0, cartOperation_js_1.compactCartOperations)(predictionQueue);
+        predictionQueue.length = 0;
+        return operations;
+    }
+    function drainAPISyncQueue() {
+        const operations = (0, cartOperation_js_1.compactCartOperations)(apiSyncQueue);
+        apiSyncQueue.length = 0;
+        return operations;
+    }
+    function applyPredictionsIfInitialized() {
+        if (!initialized)
+            return;
+        const operations = drainPredictionQueue();
+        if (operations.length === 0)
+            return;
+        applyOperationsToLineItems(operations);
+    }
+    function launchLineItemsSyncTaskIfInitialized() {
+        if (!initialized)
+            return;
+        queue.exec((controller) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const respError = yield lineItemsSync();
+            if (respError) {
+                controller.discard();
+            }
+            return respError;
+        }));
+    }
+    function submitOperationsToAPIOnce(operations) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { graphql: { createCartMutation, modifyCartMutation }, shopID, opts, } = configWithJWT;
+            let predictedLineItems;
+            let resp;
+            const cd = cartData.getState();
+            if (!cd) {
+                predictedLineItems = doApplyOperationsToLineItems([], (0, cartOperation_js_1.filterOutNonCreateOpertions)(operations));
+                resp = yield (0, request_js_1.request)(createCartMutation)({
+                    shopID,
+                    data: { line_items: lineItemsToAPIMutation(predictedLineItems), currency: savedCurrency || undefined },
+                }, opts);
+            }
+            else {
+                predictedLineItems = doApplyOperationsToLineItems(cd.lineItems, operations);
+                resp = yield (0, request_js_1.request)(modifyCartMutation)({
+                    shopID,
+                    id: cd.cart.id,
+                    uuid: cd.cart.uuid,
+                    updatedAt: cd.cart.updated_at,
+                    data: { line_items: lineItemsToAPIMutation(predictedLineItems) },
+                }, opts);
+            }
+            if (resp.kind === "data") {
+                applyLastAPIState(resp.data[0], predictedLineItems);
+            }
+            else {
+                return resp;
+            }
+        });
+    }
+    function submitOperationsToAPI(operations) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                const respError = yield submitOperationsToAPIOnce(operations);
+                if (!respError) {
+                    // if there was no error, return
+                    return;
+                }
+                const cd = cartData.getState();
+                if (respError.kind === "error" && ((_a = respError.error.apiError) === null || _a === void 0 ? void 0 : _a.code) === codes_js_1.ErrorCode.VersionMismatch && cd) {
+                    // if it was version mismatch, fetch the cart again and retry
+                    const { id, uuid } = cd.cart;
+                    const respError = yield refetchCart(id, uuid);
+                    if (respError) {
+                        return respError;
+                    }
+                    continue;
+                }
+                else {
+                    // otherwise, some unknown error? return it
+                    return respError;
+                }
+            }
+        });
+    }
+    function refetchCart(id, uuid) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { graphql: { getCartQuery }, shopID, opts, } = configWithJWT;
+            const resp = yield (0, request_js_1.request)(getCartQuery)({ shopID, id, uuid }, opts);
+            if (resp.kind === "data") {
+                // TODO: what if it's not in cart state?
+                applyLastAPIState(resp.data[0]);
+            }
+            else {
+                return resp;
+            }
+        });
+    }
+    function lineItemsSync() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // exit early if there is nothing to do
+            if (apiSyncQueue.length === 0)
+                return undefined;
+            let error;
+            reportActivity("sync");
+            while (true) {
+                const operations = drainAPISyncQueue();
+                if (operations.length === 0)
+                    break;
+                error = yield submitOperationsToAPI(operations);
+                if (error) {
+                    // if there was an error, operations were not applied, return them to queue and break out of the loop
+                    apiSyncQueue.splice(0, 0, ...operations);
+                }
+                break;
+            }
+            reportActivity("idle");
+            if (error) {
+                initialized = false;
+                setLocked(true);
+            }
+            else {
+                // correct prediction if it's required
+                const cd = cartData.getState();
+                if (cd) {
+                    setLineItemsIfChanged(cd.lineItems);
+                }
+            }
+            return error;
+        });
+    }
+    function applyOp(op) {
+        predictionQueue.push(op);
+        apiSyncQueue.push(op);
+        applyPredictionsIfInitialized();
+        launchLineItemsSyncTaskIfInitialized();
+    }
+    function makeSureNotLocked() {
+        if (locked.getState()) {
+            throw new Error("Cart is locked due to synchronization error. Please reload() it before continuing its usage.");
+        }
+    }
+    function postInit() {
+        var _a;
+        initialized = true;
+        applyPredictionsIfInitialized();
+        if (apiSyncQueue.length > 0) {
+            // successful init, we might have some items in the queue, let's drain them
+            launchLineItemsSyncTaskIfInitialized();
+        }
+        else {
+            // successful init, but no operations to apply, make sure there is no stale state
+            setLineItemsIfChanged(((_a = cartData.getState()) === null || _a === void 0 ? void 0 : _a.lineItems) || []);
+        }
+    }
+    function applyDiscountCodeImpl(discount_code) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (discountCodePending.getState())
+                return;
+            setDiscountCodePending(true);
+            const result = yield queue.exec(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const { shopID, opts, graphql: { createCartMutation, modifyCartMutation }, } = configWithJWT;
+                while (true) {
+                    let resp;
+                    reportActivity("discount");
+                    const cd = cartData.getState();
+                    if (!cd) {
+                        resp = yield (0, request_js_1.request)(createCartMutation)({ shopID, data: { currency: savedCurrency || undefined, discount_code } }, opts);
+                    }
+                    else {
+                        const { id, uuid, updated_at: updatedAt } = cd.cart;
+                        resp = yield (0, request_js_1.request)(modifyCartMutation)({ shopID, id, uuid, updatedAt, data: { discount_code } }, opts);
+                    }
+                    reportActivity("idle");
+                    if (resp.kind === "data") {
+                        const lis = applyLastAPIState(resp.data[0], lineItems.getState()).lineItems;
+                        if (apiSyncQueue.length === 0) {
+                            // only sync items if there is nothing in the sync queue, otherwise let api sync loop to
+                            // do the job, this also plays better with prediction model
+                            setLineItemsIfChanged(lis);
+                        }
+                        return { kind: "ok" };
+                    }
+                    else if (resp.kind === "system_error" || resp.kind === "custom_error") {
+                        return { kind: "unexpected_error", error: resp };
+                    }
+                    else {
+                        const apiError = resp.error.apiError;
+                        if ((apiError === null || apiError === void 0 ? void 0 : apiError.code) === codes_js_1.ErrorCode.VersionMismatch && cd) {
+                            const { id, uuid } = cd.cart;
+                            const respError = yield refetchCart(id, uuid);
+                            if (respError) {
+                                return { kind: "unexpected_error", error: respError };
+                            }
+                            continue; // retry
+                        }
+                        else if ((apiError === null || apiError === void 0 ? void 0 : apiError.code) === codes_js_1.ErrorCode.NotFound && apiError.field === "[0].discount_code") {
+                            return { kind: "not_found" };
+                        }
+                        else if ((apiError === null || apiError === void 0 ? void 0 : apiError.code) === codes_js_1.ErrorCode.InvalidInput) {
+                            const fields = (_a = apiError.meta) === null || _a === void 0 ? void 0 : _a.fields;
+                            if (fields &&
+                                fields.length === 1 &&
+                                fields[0].field === "[0].customer_id" &&
+                                fields[0].problem === "mandatory") {
+                                return { kind: "customer_id_required" };
+                            }
+                        }
+                        return { kind: "unexpected_error", error: resp };
+                    }
+                }
+            }));
+            setDiscountCodeResultAndPending([
+                result.kind === "discarded" ? { kind: "discarded" } : result.value,
+                discount_code,
+                false,
+            ]);
+        });
+    }
+    function reload() {
+        if (!locked.getState()) {
+            throw new Error("You can reload() the cart only if it was locked due to synchronization errors previously.");
+        }
+        const cd = cartData.getState();
+        if (!cd) {
+            // if cart failed during "create cart" operation, there is nothing to restore, just unlock
+            setLocked(false);
+            postInit();
+        }
+        else {
+            // if cart failed during "modify cart" operation, we should attempt to refetch it
+            const { id, uuid } = cd.cart;
+            setLocked(false);
+            queue.exec((controller) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                reportActivity("init");
+                const respError = yield refetchCart(id, uuid);
+                reportActivity("idle");
+                if (respError) {
+                    controller.discard();
+                    setLocked(true);
+                }
+                else {
+                    postInit();
+                }
+                return respError;
+            }));
+        }
+    }
+    function setItem(variantID, variant, quantity, fieldSetID, fields, subscriptionPlanIndex) {
+        makeSureNotLocked();
+        applyOp({ kind: "set", quantity, variant, variantID, fieldSetID, fields, subscriptionPlanIndex });
+    }
+    function changeItem(variantID, variant, quantityDelta, fieldSetID, fields, subscriptionPlanIndex) {
+        makeSureNotLocked();
+        applyOp({ kind: "change", quantityDelta, variant, variantID, fieldSetID, fields, subscriptionPlanIndex });
+    }
+    function removeItem(variantID) {
+        makeSureNotLocked();
+        applyOp({ kind: "remove", variantID });
+    }
+    function removeDiscountCode() {
+        makeSureNotLocked();
+        applyDiscountCodeImpl("");
+    }
+    function applyDiscountCode() {
+        makeSureNotLocked();
+        applyDiscountCodeImpl(discountCodeInput.getState());
+    }
+    function checkout(callback) {
+        makeSureNotLocked();
+        queue.exec(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield callback();
+        }));
+    }
+    function setCurrency(currency, mode) {
+        makeSureNotLocked();
+        queue.exec((controller) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const cd = cartData.getState();
+            if (cd && cd.cart.currency !== currency) {
+                // Soft mode means we only set currency if there is no cart yet.
+                if (mode === "soft")
+                    return;
+                const { shopID, opts, graphql: { modifyCartMutation }, } = configWithJWT;
+                const { id, uuid, updated_at: updatedAt } = cd.cart;
+                reportActivity("currency");
+                const resp = yield (0, request_js_1.request)(modifyCartMutation)({ shopID, id, uuid, updatedAt, data: { currency } }, opts);
+                reportActivity("idle");
+                if (resp.kind === "data") {
+                    const lis = applyLastAPIState(resp.data[0], lineItems.getState()).lineItems;
+                    if (apiSyncQueue.length === 0) {
+                        // only sync items if there is nothing in the sync queue, otherwise let api sync loop to
+                        // do the job, this also plays better with prediction model
+                        setLineItemsIfChanged(lis);
+                    }
+                    savedCurrency = currency;
+                }
+                else {
+                    controller.discard();
+                    setLocked(true);
+                }
+            }
+            else {
+                savedCurrency = currency;
+                setCurrencyValue(currency);
+            }
+        }));
+    }
+    config.locale.updates.watch((locale) => {
+        makeSureNotLocked();
+        queue.exec((controller) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            configWithJWT = Object.assign(Object.assign({}, configWithJWT), { opts: Object.assign(Object.assign({}, configWithJWT.opts), { locale }) });
+            const cd = cartData.getState();
+            if (cd) {
+                const { id, uuid } = cd.cart;
+                reportActivity("init");
+                const respError = yield refetchCart(id, uuid);
+                reportActivity("idle");
+                if (respError) {
+                    controller.discard();
+                    setLocked(true);
+                }
+                else {
+                    postInit();
+                }
+            }
+        }));
+    });
+    config.jwt.updates.watch((jwt) => {
+        makeSureNotLocked();
+        queue.exec((controller) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            configWithJWT = Object.assign(Object.assign({}, configWithJWT), { opts: Object.assign(Object.assign({}, configWithJWT.opts), { authToken: jwt }) });
+            // when there is no jwt, just apply it and we'll continue using id/uuid from now on
+            if (!jwt)
+                return;
+            const { graphql: { getLastCartQuery }, shopID, opts, } = configWithJWT;
+            reportActivity("init");
+            const resp = yield (0, request_js_1.request)(getLastCartQuery)({ shopID }, opts);
+            reportActivity("idle");
+            if (resp.kind === "error" && ((_a = resp.error.apiError) === null || _a === void 0 ? void 0 : _a.code) === codes_js_1.ErrorCode.NotFound) {
+                // if there is no last cart, do nothing
+                return;
+            }
+            if (resp.kind === "data") {
+                applyLastAPIState(resp.data);
+                postInit();
+            }
+            else {
+                controller.discard();
+                setLocked(true);
+            }
+        }));
+    });
+    return {
+        setDiscountCodeInput,
+        discountCodeInput,
+        activity,
+        locked,
+        lineItems,
+        cartData,
+        discountCode,
+        discountCodePending,
+        discountCodeResult,
+        reload,
+        setItem,
+        changeItem,
+        removeItem,
+        applyDiscountCode,
+        removeDiscountCode,
+        checkout,
+        currency,
+        setCurrency,
+    };
+}
+exports.createCart = createCart;