@blotoutio/providers-blotout-wallet-sdk 0.40.0

package/README.md

@@ -0,0 +1,11 @@
+# providers-blotout-wallet-sdk
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build providers-blotout-wallet-sdk` to build the library.
+
+## Running unit tests
+
+Run `nx test providers-blotout-wallet-sdk` to execute the unit tests via [Jest](https://jestjs.io).

package/index.cjs.js

@@ -0,0 +1,295 @@
+'use strict';
+
+const packageName = 'blotoutWallet';
+
+const canLog = () => {
+    try {
+        return localStorage.getItem('edgeTagDebug') === '1';
+    }
+    catch {
+        return false;
+    }
+};
+const logger = {
+    log: (...args) => {
+        if (canLog()) {
+            console.log(...args);
+        }
+    },
+    error: (...args) => {
+        if (canLog()) {
+            console.error(...args);
+        }
+    },
+    info: (...args) => {
+        if (canLog()) {
+            console.info(...args);
+        }
+    },
+    trace: (...args) => {
+        if (canLog()) {
+            console.trace(...args);
+        }
+    },
+    table: (...args) => {
+        if (canLog()) {
+            console.table(...args);
+        }
+    },
+    dir: (...args) => {
+        if (canLog()) {
+            console.dir(...args);
+        }
+    },
+};
+
+class APIError extends Error {
+    constructor(...args) {
+        super(...args);
+    }
+}
+class WalletAPI {
+    constructor({ baseUrl, userId }) {
+        this.listeners = new Set();
+        this._cart = null;
+        this.baseUrl = baseUrl;
+        this.userId = userId;
+    }
+    getHeaders(json = false) {
+        const headers = new Headers({
+            EdgeTagUserId: this.userId,
+        });
+        if (json) {
+            headers.set('Content-type', 'application/json; charset=utf-8');
+        }
+        return headers;
+    }
+    getUrl(path) {
+        return `${this.baseUrl}/providers/blotoutWallet${path}`;
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            try {
+                listener(this.cart);
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    }
+    get cart() {
+        return this._cart;
+    }
+    set cart(value) {
+        if (this._cart !== value) {
+            this._cart = value;
+            this.notify();
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    getCart() {
+        return fetch(this.getUrl('/cart'), {
+            method: 'GET',
+            headers: this.getHeaders(),
+        }).then(async (response) => {
+            if (!response.ok) {
+                if (response.status == 404) {
+                    return (this.cart = null);
+                }
+                throw new APIError(`Could not fetch cart contents`, {
+                    cause: response,
+                });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    addItems(items) {
+        return fetch(this.getUrl('/items'), {
+            method: 'POST',
+            headers: this.getHeaders(true),
+            body: JSON.stringify(items),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not add items`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    setItems(items) {
+        return fetch(this.getUrl('/items'), {
+            method: 'PUT',
+            headers: this.getHeaders(true),
+            body: JSON.stringify(items),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not set items`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    updateItem(item) {
+        fetch(this.getUrl(`/items/${item.itemId}`), {
+            method: 'PUT',
+            headers: this.getHeaders(true),
+            body: JSON.stringify({
+                name: item.name,
+                productId: item.productId,
+                amount: item.amount,
+                value: item.value,
+            }),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not update item`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    removeItem(itemId) {
+        fetch(this.getUrl(`/items/${itemId}`), {
+            method: 'DELETE',
+            headers: this.getHeaders(),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not remove item`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    purchase(orderId) {
+        return fetch(this.getUrl('/cart/purchase'), {
+            method: 'POST',
+            body: JSON.stringify({ orderId }),
+            headers: this.getHeaders(true),
+        }).then((response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not mark purchase`, { cause: response });
+            }
+        });
+    }
+}
+
+let api;
+let component;
+const setComponent = (_component) => {
+    component = _component;
+};
+const setAPI = (_api) => {
+    api = _api;
+};
+const getAPI = () => api;
+const getComponent = () => component;
+
+const symbol = Symbol.for('blotout-store-implementation');
+
+const getItemKey = (item) => `${item.productId}-${item.variantId}`;
+const syncCartItems = async (api, storeApi) => {
+    try {
+        const [wallet, shopItems] = await Promise.all([
+            api.getCart(),
+            storeApi.getCart(),
+        ]);
+        const lookup = new Map(wallet === null || wallet === void 0 ? void 0 : wallet.items.map((item) => [getItemKey(item), item]));
+        const missingItems = [];
+        for (const item of shopItems) {
+            const walletItem = lookup.get(getItemKey(item));
+            if (!walletItem) {
+                missingItems.push(item);
+            }
+            else if (walletItem.amount < item.amount) {
+                missingItems.push({
+                    ...item,
+                    amount: item.amount - walletItem.amount,
+                });
+            }
+        }
+        if (missingItems.length > 0) {
+            await api.addItems(missingItems);
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+const init = (params) => {
+    var _a;
+    if (window && document && !getComponent()) {
+        const element = document.createElement('blotout-wallet');
+        element.setAttribute('tag-name', params.manifest.tagName);
+        setComponent(element);
+        const api = new WalletAPI({
+            baseUrl: params.baseUrl,
+            userId: params.userId,
+        });
+        setAPI(api);
+        const store = (_a = window[symbol]) === null || _a === void 0 ? void 0 : _a.call(window);
+        if (!store) {
+            throw new Error('Implementation for store API missing!');
+        }
+        document.body.append(element);
+        syncCartItems(api, store);
+    }
+};
+
+const transformItems = (data) => {
+    var _a;
+    return (_a = data.contents) === null || _a === void 0 ? void 0 : _a.map((item) => ({
+        productId: item.id,
+        variantId: item.variantId || null,
+        name: item.description || '',
+        amount: parseInt(item.quantity.toString()),
+        value: parseFloat(item.item_price.toString()),
+    }));
+};
+const tag = (params) => {
+    const api = getAPI();
+    switch (params.eventName) {
+        case 'AddToCart': {
+            const items = transformItems(params.data);
+            if (items) {
+                api.addItems(items).catch(logger.error);
+            }
+            return;
+        }
+        case 'InitiateCheckout': {
+            const items = transformItems(params.data);
+            if (items) {
+                api.setItems(items).catch(logger.error);
+            }
+            return;
+        }
+        case 'Purchase': {
+            const { orderId } = params.data;
+            api.purchase(orderId).catch(logger.error);
+            return;
+        }
+    }
+};
+
+// eslint-disable-next-line @nx/enforce-module-boundaries
+const user = (params) => {
+    console.log(`[${packageName}]: user`, params);
+};
+
+// eslint-disable-next-line @nx/enforce-module-boundaries
+const data = {
+    name: packageName,
+    init,
+    tag,
+    user,
+};
+try {
+    if (window) {
+        window.edgetagProviders = window.edgetagProviders || [];
+        window.edgetagProviders.push(data);
+    }
+}
+catch {
+    // no window
+}
+
+module.exports = data;

package/index.js

@@ -0,0 +1,298 @@
+var ProvidersBlotoutWalletSdk = (function () {
+    'use strict';
+
+    const packageName = 'blotoutWallet';
+
+    const canLog = () => {
+        try {
+            return localStorage.getItem('edgeTagDebug') === '1';
+        }
+        catch {
+            return false;
+        }
+    };
+    const logger = {
+        log: (...args) => {
+            if (canLog()) {
+                console.log(...args);
+            }
+        },
+        error: (...args) => {
+            if (canLog()) {
+                console.error(...args);
+            }
+        },
+        info: (...args) => {
+            if (canLog()) {
+                console.info(...args);
+            }
+        },
+        trace: (...args) => {
+            if (canLog()) {
+                console.trace(...args);
+            }
+        },
+        table: (...args) => {
+            if (canLog()) {
+                console.table(...args);
+            }
+        },
+        dir: (...args) => {
+            if (canLog()) {
+                console.dir(...args);
+            }
+        },
+    };
+
+    class APIError extends Error {
+        constructor(...args) {
+            super(...args);
+        }
+    }
+    class WalletAPI {
+        constructor({ baseUrl, userId }) {
+            this.listeners = new Set();
+            this._cart = null;
+            this.baseUrl = baseUrl;
+            this.userId = userId;
+        }
+        getHeaders(json = false) {
+            const headers = new Headers({
+                EdgeTagUserId: this.userId,
+            });
+            if (json) {
+                headers.set('Content-type', 'application/json; charset=utf-8');
+            }
+            return headers;
+        }
+        getUrl(path) {
+            return `${this.baseUrl}/providers/blotoutWallet${path}`;
+        }
+        notify() {
+            for (const listener of this.listeners) {
+                try {
+                    listener(this.cart);
+                }
+                catch (err) {
+                    console.error(err);
+                }
+            }
+        }
+        get cart() {
+            return this._cart;
+        }
+        set cart(value) {
+            if (this._cart !== value) {
+                this._cart = value;
+                this.notify();
+            }
+        }
+        subscribe(listener) {
+            this.listeners.add(listener);
+            return () => {
+                this.listeners.delete(listener);
+            };
+        }
+        getCart() {
+            return fetch(this.getUrl('/cart'), {
+                method: 'GET',
+                headers: this.getHeaders(),
+            }).then(async (response) => {
+                if (!response.ok) {
+                    if (response.status == 404) {
+                        return (this.cart = null);
+                    }
+                    throw new APIError(`Could not fetch cart contents`, {
+                        cause: response,
+                    });
+                }
+                return (this.cart = await response.json());
+            });
+        }
+        addItems(items) {
+            return fetch(this.getUrl('/items'), {
+                method: 'POST',
+                headers: this.getHeaders(true),
+                body: JSON.stringify(items),
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw new APIError(`Could not add items`, { cause: response });
+                }
+                return (this.cart = await response.json());
+            });
+        }
+        setItems(items) {
+            return fetch(this.getUrl('/items'), {
+                method: 'PUT',
+                headers: this.getHeaders(true),
+                body: JSON.stringify(items),
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw new APIError(`Could not set items`, { cause: response });
+                }
+                return (this.cart = await response.json());
+            });
+        }
+        updateItem(item) {
+            fetch(this.getUrl(`/items/${item.itemId}`), {
+                method: 'PUT',
+                headers: this.getHeaders(true),
+                body: JSON.stringify({
+                    name: item.name,
+                    productId: item.productId,
+                    amount: item.amount,
+                    value: item.value,
+                }),
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw new APIError(`Could not update item`, { cause: response });
+                }
+                return (this.cart = await response.json());
+            });
+        }
+        removeItem(itemId) {
+            fetch(this.getUrl(`/items/${itemId}`), {
+                method: 'DELETE',
+                headers: this.getHeaders(),
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw new APIError(`Could not remove item`, { cause: response });
+                }
+                return (this.cart = await response.json());
+            });
+        }
+        purchase(orderId) {
+            return fetch(this.getUrl('/cart/purchase'), {
+                method: 'POST',
+                body: JSON.stringify({ orderId }),
+                headers: this.getHeaders(true),
+            }).then((response) => {
+                if (!response.ok) {
+                    throw new APIError(`Could not mark purchase`, { cause: response });
+                }
+            });
+        }
+    }
+
+    let api;
+    let component;
+    const setComponent = (_component) => {
+        component = _component;
+    };
+    const setAPI = (_api) => {
+        api = _api;
+    };
+    const getAPI = () => api;
+    const getComponent = () => component;
+
+    const symbol = Symbol.for('blotout-store-implementation');
+
+    const getItemKey = (item) => `${item.productId}-${item.variantId}`;
+    const syncCartItems = async (api, storeApi) => {
+        try {
+            const [wallet, shopItems] = await Promise.all([
+                api.getCart(),
+                storeApi.getCart(),
+            ]);
+            const lookup = new Map(wallet === null || wallet === void 0 ? void 0 : wallet.items.map((item) => [getItemKey(item), item]));
+            const missingItems = [];
+            for (const item of shopItems) {
+                const walletItem = lookup.get(getItemKey(item));
+                if (!walletItem) {
+                    missingItems.push(item);
+                }
+                else if (walletItem.amount < item.amount) {
+                    missingItems.push({
+                        ...item,
+                        amount: item.amount - walletItem.amount,
+                    });
+                }
+            }
+            if (missingItems.length > 0) {
+                await api.addItems(missingItems);
+            }
+        }
+        catch (err) {
+            logger.error(err);
+        }
+    };
+    const init = (params) => {
+        var _a;
+        if (window && document && !getComponent()) {
+            const element = document.createElement('blotout-wallet');
+            element.setAttribute('tag-name', params.manifest.tagName);
+            setComponent(element);
+            const api = new WalletAPI({
+                baseUrl: params.baseUrl,
+                userId: params.userId,
+            });
+            setAPI(api);
+            const store = (_a = window[symbol]) === null || _a === void 0 ? void 0 : _a.call(window);
+            if (!store) {
+                throw new Error('Implementation for store API missing!');
+            }
+            document.body.append(element);
+            syncCartItems(api, store);
+        }
+    };
+
+    const transformItems = (data) => {
+        var _a;
+        return (_a = data.contents) === null || _a === void 0 ? void 0 : _a.map((item) => ({
+            productId: item.id,
+            variantId: item.variantId || null,
+            name: item.description || '',
+            amount: parseInt(item.quantity.toString()),
+            value: parseFloat(item.item_price.toString()),
+        }));
+    };
+    const tag = (params) => {
+        const api = getAPI();
+        switch (params.eventName) {
+            case 'AddToCart': {
+                const items = transformItems(params.data);
+                if (items) {
+                    api.addItems(items).catch(logger.error);
+                }
+                return;
+            }
+            case 'InitiateCheckout': {
+                const items = transformItems(params.data);
+                if (items) {
+                    api.setItems(items).catch(logger.error);
+                }
+                return;
+            }
+            case 'Purchase': {
+                const { orderId } = params.data;
+                api.purchase(orderId).catch(logger.error);
+                return;
+            }
+        }
+    };
+
+    // eslint-disable-next-line @nx/enforce-module-boundaries
+    const user = (params) => {
+        console.log(`[${packageName}]: user`, params);
+    };
+
+    // eslint-disable-next-line @nx/enforce-module-boundaries
+    const data = {
+        name: packageName,
+        init,
+        tag,
+        user,
+    };
+    try {
+        if (window) {
+            window.edgetagProviders = window.edgetagProviders || [];
+            window.edgetagProviders.push(data);
+        }
+    }
+    catch {
+        // no window
+    }
+
+    return data;
+
+})();

package/index.mjs

@@ -0,0 +1,293 @@
+const packageName = 'blotoutWallet';
+
+const canLog = () => {
+    try {
+        return localStorage.getItem('edgeTagDebug') === '1';
+    }
+    catch {
+        return false;
+    }
+};
+const logger = {
+    log: (...args) => {
+        if (canLog()) {
+            console.log(...args);
+        }
+    },
+    error: (...args) => {
+        if (canLog()) {
+            console.error(...args);
+        }
+    },
+    info: (...args) => {
+        if (canLog()) {
+            console.info(...args);
+        }
+    },
+    trace: (...args) => {
+        if (canLog()) {
+            console.trace(...args);
+        }
+    },
+    table: (...args) => {
+        if (canLog()) {
+            console.table(...args);
+        }
+    },
+    dir: (...args) => {
+        if (canLog()) {
+            console.dir(...args);
+        }
+    },
+};
+
+class APIError extends Error {
+    constructor(...args) {
+        super(...args);
+    }
+}
+class WalletAPI {
+    constructor({ baseUrl, userId }) {
+        this.listeners = new Set();
+        this._cart = null;
+        this.baseUrl = baseUrl;
+        this.userId = userId;
+    }
+    getHeaders(json = false) {
+        const headers = new Headers({
+            EdgeTagUserId: this.userId,
+        });
+        if (json) {
+            headers.set('Content-type', 'application/json; charset=utf-8');
+        }
+        return headers;
+    }
+    getUrl(path) {
+        return `${this.baseUrl}/providers/blotoutWallet${path}`;
+    }
+    notify() {
+        for (const listener of this.listeners) {
+            try {
+                listener(this.cart);
+            }
+            catch (err) {
+                console.error(err);
+            }
+        }
+    }
+    get cart() {
+        return this._cart;
+    }
+    set cart(value) {
+        if (this._cart !== value) {
+            this._cart = value;
+            this.notify();
+        }
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    getCart() {
+        return fetch(this.getUrl('/cart'), {
+            method: 'GET',
+            headers: this.getHeaders(),
+        }).then(async (response) => {
+            if (!response.ok) {
+                if (response.status == 404) {
+                    return (this.cart = null);
+                }
+                throw new APIError(`Could not fetch cart contents`, {
+                    cause: response,
+                });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    addItems(items) {
+        return fetch(this.getUrl('/items'), {
+            method: 'POST',
+            headers: this.getHeaders(true),
+            body: JSON.stringify(items),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not add items`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    setItems(items) {
+        return fetch(this.getUrl('/items'), {
+            method: 'PUT',
+            headers: this.getHeaders(true),
+            body: JSON.stringify(items),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not set items`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    updateItem(item) {
+        fetch(this.getUrl(`/items/${item.itemId}`), {
+            method: 'PUT',
+            headers: this.getHeaders(true),
+            body: JSON.stringify({
+                name: item.name,
+                productId: item.productId,
+                amount: item.amount,
+                value: item.value,
+            }),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not update item`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    removeItem(itemId) {
+        fetch(this.getUrl(`/items/${itemId}`), {
+            method: 'DELETE',
+            headers: this.getHeaders(),
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not remove item`, { cause: response });
+            }
+            return (this.cart = await response.json());
+        });
+    }
+    purchase(orderId) {
+        return fetch(this.getUrl('/cart/purchase'), {
+            method: 'POST',
+            body: JSON.stringify({ orderId }),
+            headers: this.getHeaders(true),
+        }).then((response) => {
+            if (!response.ok) {
+                throw new APIError(`Could not mark purchase`, { cause: response });
+            }
+        });
+    }
+}
+
+let api;
+let component;
+const setComponent = (_component) => {
+    component = _component;
+};
+const setAPI = (_api) => {
+    api = _api;
+};
+const getAPI = () => api;
+const getComponent = () => component;
+
+const symbol = Symbol.for('blotout-store-implementation');
+
+const getItemKey = (item) => `${item.productId}-${item.variantId}`;
+const syncCartItems = async (api, storeApi) => {
+    try {
+        const [wallet, shopItems] = await Promise.all([
+            api.getCart(),
+            storeApi.getCart(),
+        ]);
+        const lookup = new Map(wallet === null || wallet === void 0 ? void 0 : wallet.items.map((item) => [getItemKey(item), item]));
+        const missingItems = [];
+        for (const item of shopItems) {
+            const walletItem = lookup.get(getItemKey(item));
+            if (!walletItem) {
+                missingItems.push(item);
+            }
+            else if (walletItem.amount < item.amount) {
+                missingItems.push({
+                    ...item,
+                    amount: item.amount - walletItem.amount,
+                });
+            }
+        }
+        if (missingItems.length > 0) {
+            await api.addItems(missingItems);
+        }
+    }
+    catch (err) {
+        logger.error(err);
+    }
+};
+const init = (params) => {
+    var _a;
+    if (window && document && !getComponent()) {
+        const element = document.createElement('blotout-wallet');
+        element.setAttribute('tag-name', params.manifest.tagName);
+        setComponent(element);
+        const api = new WalletAPI({
+            baseUrl: params.baseUrl,
+            userId: params.userId,
+        });
+        setAPI(api);
+        const store = (_a = window[symbol]) === null || _a === void 0 ? void 0 : _a.call(window);
+        if (!store) {
+            throw new Error('Implementation for store API missing!');
+        }
+        document.body.append(element);
+        syncCartItems(api, store);
+    }
+};
+
+const transformItems = (data) => {
+    var _a;
+    return (_a = data.contents) === null || _a === void 0 ? void 0 : _a.map((item) => ({
+        productId: item.id,
+        variantId: item.variantId || null,
+        name: item.description || '',
+        amount: parseInt(item.quantity.toString()),
+        value: parseFloat(item.item_price.toString()),
+    }));
+};
+const tag = (params) => {
+    const api = getAPI();
+    switch (params.eventName) {
+        case 'AddToCart': {
+            const items = transformItems(params.data);
+            if (items) {
+                api.addItems(items).catch(logger.error);
+            }
+            return;
+        }
+        case 'InitiateCheckout': {
+            const items = transformItems(params.data);
+            if (items) {
+                api.setItems(items).catch(logger.error);
+            }
+            return;
+        }
+        case 'Purchase': {
+            const { orderId } = params.data;
+            api.purchase(orderId).catch(logger.error);
+            return;
+        }
+    }
+};
+
+// eslint-disable-next-line @nx/enforce-module-boundaries
+const user = (params) => {
+    console.log(`[${packageName}]: user`, params);
+};
+
+// eslint-disable-next-line @nx/enforce-module-boundaries
+const data = {
+    name: packageName,
+    init,
+    tag,
+    user,
+};
+try {
+    if (window) {
+        window.edgetagProviders = window.edgetagProviders || [];
+        window.edgetagProviders.push(data);
+    }
+}
+catch {
+    // no window
+}
+
+export { data as default };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@blotoutio/providers-blotout-wallet-sdk",
+  "version": "0.40.0",
+  "description": "Blotout Wallet SDK for EdgeTag",
+  "author": "Blotout",
+  "license": "MIT",
+  "homepage": "https://github.com/blotoutio/edgetag-sdk",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./index.cjs.js",
+  "module": "./index.mjs",
+  "exports": {
+    ".": {
+      "require": "./index.cjs.js",
+      "import": "./index.mjs",
+      "default": "./index.js"
+    },
+    "./stores/shopify.js": {
+      "require": "./stores/shopify/index.cjs.js",
+      "import": "./stores/shopify/index.mjs",
+      "default": "./stores/shopify/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/blotoutio/edgetag-sdk.git"
+  },
+  "files": [
+    "index.js",
+    "index.cjs.js",
+    "index.mjs",
+    "package.json",
+    "README.md",
+    "stores/shopify/index.js",
+    "stores/shopify/index.cjs.js",
+    "stores/shopify/index.mjs"
+  ]
+}

package/stores/shopify/index.cjs.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const symbol = Symbol.for('blotout-store-implementation');
+
+const createShopApi = (fetchOverride = window.fetch) => ({
+    addItems(items) {
+        return fetchOverride(`${window.Shopify.routes.root}cart/add.js`, {
+            method: 'POST',
+            body: JSON.stringify({
+                items: items.map((item) => ({
+                    id: item.productId,
+                    variant_id: item.variantId,
+                    quantity: item.amount,
+                })),
+            }),
+            headers: { 'Content-type': 'application/json' },
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new Error('Could not add items', { cause: await response.text() });
+            }
+            return this.getCart();
+        });
+    },
+    clearCart() {
+        return fetchOverride(`${window.Shopify.routes.root}cart/clear.js`, {
+            method: 'POST',
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new Error('Could not clear cart', {
+                    cause: await response.text(),
+                });
+            }
+        });
+    },
+    getCart() {
+        return fetchOverride(`${window.Shopify.routes.root}cart.js`, {
+            method: 'GET',
+            headers: { Accept: 'application/json' },
+        })
+            .then(async (response) => {
+            if (!response.ok) {
+                throw new Error('Could not fetch cart', {
+                    cause: await response.text(),
+                });
+            }
+            return response.json();
+        })
+            .then((cart) => cart.items.map(({ id, variant_id, title, quantity, price }) => ({
+            productId: id.toString(),
+            variantId: (variant_id === null || variant_id === void 0 ? void 0 : variant_id.toString()) || null,
+            name: title,
+            amount: quantity,
+            // TODO: should this be `final_price`, `discounted_price` or just `price`?
+            value: price,
+        })));
+    },
+});
+window[symbol] = createShopApi;

package/stores/shopify/index.js

@@ -0,0 +1,61 @@
+(function () {
+    'use strict';
+
+    const symbol = Symbol.for('blotout-store-implementation');
+
+    const createShopApi = (fetchOverride = window.fetch) => ({
+        addItems(items) {
+            return fetchOverride(`${window.Shopify.routes.root}cart/add.js`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    items: items.map((item) => ({
+                        id: item.productId,
+                        variant_id: item.variantId,
+                        quantity: item.amount,
+                    })),
+                }),
+                headers: { 'Content-type': 'application/json' },
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw new Error('Could not add items', { cause: await response.text() });
+                }
+                return this.getCart();
+            });
+        },
+        clearCart() {
+            return fetchOverride(`${window.Shopify.routes.root}cart/clear.js`, {
+                method: 'POST',
+            }).then(async (response) => {
+                if (!response.ok) {
+                    throw new Error('Could not clear cart', {
+                        cause: await response.text(),
+                    });
+                }
+            });
+        },
+        getCart() {
+            return fetchOverride(`${window.Shopify.routes.root}cart.js`, {
+                method: 'GET',
+                headers: { Accept: 'application/json' },
+            })
+                .then(async (response) => {
+                if (!response.ok) {
+                    throw new Error('Could not fetch cart', {
+                        cause: await response.text(),
+                    });
+                }
+                return response.json();
+            })
+                .then((cart) => cart.items.map(({ id, variant_id, title, quantity, price }) => ({
+                productId: id.toString(),
+                variantId: (variant_id === null || variant_id === void 0 ? void 0 : variant_id.toString()) || null,
+                name: title,
+                amount: quantity,
+                // TODO: should this be `final_price`, `discounted_price` or just `price`?
+                value: price,
+            })));
+        },
+    });
+    window[symbol] = createShopApi;
+
+})();

package/stores/shopify/index.mjs

@@ -0,0 +1,56 @@
+const symbol = Symbol.for('blotout-store-implementation');
+
+const createShopApi = (fetchOverride = window.fetch) => ({
+    addItems(items) {
+        return fetchOverride(`${window.Shopify.routes.root}cart/add.js`, {
+            method: 'POST',
+            body: JSON.stringify({
+                items: items.map((item) => ({
+                    id: item.productId,
+                    variant_id: item.variantId,
+                    quantity: item.amount,
+                })),
+            }),
+            headers: { 'Content-type': 'application/json' },
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new Error('Could not add items', { cause: await response.text() });
+            }
+            return this.getCart();
+        });
+    },
+    clearCart() {
+        return fetchOverride(`${window.Shopify.routes.root}cart/clear.js`, {
+            method: 'POST',
+        }).then(async (response) => {
+            if (!response.ok) {
+                throw new Error('Could not clear cart', {
+                    cause: await response.text(),
+                });
+            }
+        });
+    },
+    getCart() {
+        return fetchOverride(`${window.Shopify.routes.root}cart.js`, {
+            method: 'GET',
+            headers: { Accept: 'application/json' },
+        })
+            .then(async (response) => {
+            if (!response.ok) {
+                throw new Error('Could not fetch cart', {
+                    cause: await response.text(),
+                });
+            }
+            return response.json();
+        })
+            .then((cart) => cart.items.map(({ id, variant_id, title, quantity, price }) => ({
+            productId: id.toString(),
+            variantId: (variant_id === null || variant_id === void 0 ? void 0 : variant_id.toString()) || null,
+            name: title,
+            amount: quantity,
+            // TODO: should this be `final_price`, `discounted_price` or just `price`?
+            value: price,
+        })));
+    },
+});
+window[symbol] = createShopApi;