@lana-commerce/core 11.0.0

package/esm/modules/helpers/cartInitOption.js

@@ -0,0 +1,18 @@
+export function cartInitOption(token, id, uuid) {
+    if (token) {
+        if (id && uuid) {
+            return { kind: "fetch_last_or_by_id", id, uuid };
+        }
+        else {
+            return { kind: "fetch_last" };
+        }
+    }
+    else {
+        if (id && uuid) {
+            return { kind: "fetch_by_id", id, uuid };
+        }
+        else {
+            return { kind: "new" };
+        }
+    }
+}

package/esm/modules/helpers/cookieConsent.js

@@ -0,0 +1,29 @@
+import { createEvent, restore } from "effector";
+export function createCookieConsent(key) {
+    let isCookieConsentClicked = false;
+    try {
+        isCookieConsentClicked = !!JSON.parse(localStorage.getItem(key) || "");
+    }
+    catch {
+        // do nothing, best effort
+    }
+    const setCookieConsentClicked = createEvent();
+    const cookieConsentClicked = restore(setCookieConsentClicked, true);
+    cookieConsentClicked.updates.watch((v) => {
+        try {
+            localStorage.setItem(key, JSON.stringify(v));
+        }
+        catch {
+            // do nothing, best effort
+        }
+    });
+    if (!isCookieConsentClicked) {
+        setTimeout(() => {
+            setCookieConsentClicked(false);
+        }, 200);
+    }
+    return {
+        setCookieConsentClicked,
+        cookieConsentClicked,
+    };
+}

package/esm/modules/helpers/customerOauth2.js

@@ -0,0 +1,53 @@
+import authRequestMutation from "../../graphql/operations/AuthRequestMutation.js";
+import { request } from "../../request.js";
+import { shopConnectURL } from "../../shopLinks.js";
+export const oauthProviders = {
+    google: {
+        url: `https://accounts.google.com/o/oauth2/auth`,
+        scope: "openid profile email",
+    },
+    facebook: {
+        url: `https://www.facebook.com/v12.0/dialog/oauth`,
+        scope: "public_profile,email",
+    },
+    gitlab: {
+        url: `https://gitlab.com/oauth/authorize`,
+        scope: "openid profile email",
+    },
+    apple: {
+        url: `https://appleid.apple.com/auth/authorize`,
+        scope: "openid name email",
+    },
+};
+export async function getProviderURL(a) {
+    const info = oauthProviders[a.kind];
+    if (!info.url) {
+        // oauth 1.0, let's get the URL from the backend
+        const resp = await request(authRequestMutation)({ shopID: a.shopID, provider: a.kind }, a.opts);
+        if (resp.kind === "data") {
+            return resp.data.url;
+        }
+        else {
+            return "";
+        }
+    }
+    return (`${info.url}` +
+        `?client_id=${encodeURIComponent(a.clientID)}` +
+        `&redirect_uri=${encodeURIComponent(shopConnectURL(a.shop))}` +
+        `&scope=${encodeURIComponent(info.scope)}` +
+        `&state=${encodeURIComponent(a.randomToken)}` +
+        `&response_type=code`);
+}
+export async function launchAndFocusProviderPopupWindow(a) {
+    const url = await getProviderURL(a);
+    if (!url)
+        throw new Error("failed getting oauth redirect url");
+    const width = 450;
+    const height = 600;
+    const left = Math.floor(window.screenX + (window.outerWidth - width) / 2);
+    const top = Math.floor(window.screenY + (window.outerHeight - height) / 2.5);
+    const externalWindow = window.open(url, undefined, `left=${left},top=${top},width=${width},height=${height},resizable=yes,scrollbars=yes,titlebar=yes`);
+    if (!externalWindow)
+        throw new Error("failed creating oauth2 window");
+    externalWindow.focus?.();
+}

package/esm/modules/helpers/getOAuth2Hook.js

@@ -0,0 +1,48 @@
+import { launchAndFocusProviderPopupWindow } from "./customerOauth2.js";
+export function getOAuth2Hook(args) {
+    let connectPromisesToResolve = [];
+    const cancelConnect = () => {
+        for (const p of connectPromisesToResolve) {
+            p.promiseResolve({ kind: "failure" });
+        }
+        connectPromisesToResolve.length = 0;
+    };
+    args.remote.then((child) => {
+        child.on("popup-connect", (item) => {
+            connectPromisesToResolve = connectPromisesToResolve.filter((p) => {
+                if (item.kind === "success" && p.expectedState === item.state) {
+                    p.promiseResolve({ kind: "success", code: item.code });
+                }
+                else if (item.kind === "success_oauth1") {
+                    p.promiseResolve({ kind: "success_oauth1", token: item.oauth_token, verifier: item.oauth_verifier });
+                }
+                else {
+                    p.promiseResolve({ kind: "failure" });
+                }
+                return false; // remove entry
+            });
+        });
+    });
+    return (req) => {
+        const provider = args.oauth2Providers.find((p) => p.kind === req.kind);
+        if (!provider)
+            return [Promise.resolve({ kind: "failure" }), cancelConnect];
+        launchAndFocusProviderPopupWindow({
+            kind: req.kind,
+            clientID: provider.client_id,
+            randomToken: req.randomToken,
+            shop: args.shopDomain,
+            shopID: args.shopID,
+            opts: args.opts,
+        });
+        return [
+            new Promise((resolve) => {
+                connectPromisesToResolve.push({
+                    expectedState: req.randomToken,
+                    promiseResolve: resolve,
+                });
+            }),
+            cancelConnect,
+        ];
+    };
+}

package/esm/modules/helpers/hookUpAnalytics.js

@@ -0,0 +1,44 @@
+import jwtDecode from "jwt-decode";
+import { sample } from "effector";
+import { analyticsProductData } from "../../analyticsProductData.js";
+import { cartViewed, identify, productsSearched } from "../../analytics.js";
+function identifyFromJWT(jwt) {
+    if (jwt) {
+        try {
+            const payload = jwtDecode(jwt);
+            identify(payload.customer_id);
+        }
+        catch {
+            // do nothing
+        }
+    }
+}
+export function hookUpAnalytics(a) {
+    // identify on JWT changes (and also now using current JWT)
+    if (a.jwt) {
+        identifyFromJWT(a.jwt.getState());
+        a.jwt.watch(identifyFromJWT);
+    }
+    // when cart is toggled, let's report "Cart Viewed"
+    if (a.cart) {
+        const { cart, cartVisible, analyticsEnv } = a.cart;
+        cartVisible.updates.watch((isVisible) => {
+            if (isVisible) {
+                const state = cart.cartData.getState();
+                if (state) {
+                    const currency = state.cart.currency;
+                    const orderID = state.cart.id;
+                    const items = state.lineItems;
+                    cartViewed(orderID, items.map((item) => ({
+                        product: analyticsProductData({ ...analyticsEnv, currency, canonicalVariantURL: analyticsEnv.canonicalVariantURL() }, item.variant, item.variantID),
+                        quantity: item.quantity,
+                    })));
+                }
+            }
+        });
+    }
+    // on search submit, report the query
+    if (a.search) {
+        sample({ source: a.search.query, clock: a.search.submit }).watch(productsSearched);
+    }
+}

package/esm/modules/helpers/loadJWT.js

@@ -0,0 +1,18 @@
+import jwtDecode from "jwt-decode";
+export function loadJWT(shopID, key) {
+    let token = undefined;
+    try {
+        token = localStorage.getItem(key) || undefined;
+    }
+    catch {
+        // do nothing
+    }
+    if (!token)
+        return undefined;
+    // protection against clashing shop ids
+    // (this is useful if shop owner decides to use a different shop on the same domain)
+    const payload = jwtDecode(token);
+    if (payload && payload.shop_id !== shopID)
+        return undefined;
+    return token;
+}

package/esm/modules/helpers/misc.js

@@ -0,0 +1,49 @@
+import { setRemoteAuth } from "../../remoteAuth.js";
+import { shopCheckoutOrderURL } from "../../shopLinks.js";
+export function saveCartDataToLocalStorage(cart, idKey, uuidKey) {
+    cart.cartData.updates.watch((state) => {
+        if (state) {
+            try {
+                localStorage.setItem(idKey, state.cart.id);
+                localStorage.setItem(uuidKey, state.cart.uuid);
+            }
+            catch {
+                // do nothing, best effort
+            }
+        }
+    });
+}
+export function saveJWTToLocalStorage(jwt, key, checkoutRemote) {
+    jwt.updates.watch((jwt) => {
+        try {
+            if (jwt) {
+                localStorage.setItem(key, jwt);
+            }
+            else {
+                localStorage.removeItem(key);
+            }
+        }
+        catch {
+            // do nothing, best effort
+        }
+        setRemoteAuth(checkoutRemote, jwt);
+    });
+}
+export function makeCartCheckoutFunction(a) {
+    return async () => {
+        const c = a.cart.cartData.getState()?.cart;
+        if (!c)
+            return;
+        // using timeout of 400ms here, remote should be loaded by now
+        await setRemoteAuth(a.checkoutRemote, a.jwt.getState(), 400);
+        document.location.href = shopCheckoutOrderURL(a.shop, c.id, c.uuid);
+    };
+}
+export function getNonEmptyStringFromLocalStorage(key) {
+    try {
+        return localStorage.getItem(key) || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/esm/modules/imageDialog.js

@@ -0,0 +1,71 @@
+import { combine, createEffect, createEvent, createStore, forward, guard, sample } from "effector";
+import { combineEvery } from "../effector/combineEvery.js";
+import { requestResponseSplit } from "../effector/requestResponse.js";
+export function createImageDialog() {
+    const config = createStore({
+        cdn: "",
+        images: [],
+        position: 0,
+        perPage: 0,
+        lastKey: "",
+        loadMore: undefined,
+    });
+    const show = createEvent();
+    const hide = createEvent();
+    const setPosition = createEvent();
+    const unexpectedError = createEvent();
+    const lastKey = createStore("").on(config, (_, cfg) => cfg.lastKey);
+    const visible = createStore(false)
+        .on(show, () => true)
+        .on(hide, () => false);
+    const images = createStore([]).on(config, (_, cfg) => cfg.images);
+    const position = createStore(0)
+        .on(config, (_, cfg) => cfg.position)
+        .on(setPosition, (_, v) => v);
+    const canLoadMore = createStore(true).reset(show);
+    const shouldLoadNextPage = combine(config, images, position, canLoadMore, (config, images, position, canLoadMore) => {
+        if (!canLoadMore)
+            return false;
+        if (!config.loadMore)
+            return false;
+        const perPage = config.perPage ?? images.length;
+        const pagesLoaded = Math.round(images.length / perPage);
+        const positionPage = Math.floor(position / perPage) + 1;
+        const nextPage = positionPage + 1;
+        return nextPage > pagesLoaded;
+    });
+    const loadNextPageFx = createEffect(async ({ config, lastKey }) => {
+        return (await config.loadMore?.(lastKey)) || { kind: "data", data: { last_key: "", items: [] } };
+    });
+    const loadNextPageResult = requestResponseSplit(loadNextPageFx.doneData);
+    // success
+    images.on(loadNextPageResult.data, (images, page) => [...images, ...page.items]);
+    lastKey.on(loadNextPageResult.data, (_, page) => page.last_key);
+    forward({
+        from: loadNextPageResult.data.filterMap((v) => (v.items.length === 0 ? false : undefined)),
+        to: canLoadMore,
+    });
+    // failure
+    forward({
+        from: loadNextPageResult.error,
+        to: unexpectedError,
+    });
+    const loadNextPageIdle = loadNextPageFx.pending.map((v) => !v);
+    guard({
+        source: sample(combine({ config, lastKey }), setPosition),
+        filter: combineEvery(loadNextPageIdle, shouldLoadNextPage),
+        target: loadNextPageFx,
+    });
+    config.on(show, (_, cfg) => cfg);
+    return {
+        config,
+        visible,
+        show,
+        hide,
+        images,
+        position,
+        setPosition,
+        unexpectedError,
+        somethingPending: loadNextPageFx.pending,
+    };
+}

package/esm/modules/persist.js

@@ -0,0 +1,49 @@
+export function serialize(data, version) {
+    const x = {
+        version,
+        createdAt: Date.now(),
+        data,
+    };
+    return JSON.stringify(x);
+}
+export function deserialize(value, version, maxAgeMs) {
+    try {
+        const data = JSON.parse(value);
+        if (data.version !== version)
+            return undefined;
+        if (Date.now() - data.createdAt > maxAgeMs)
+            return undefined;
+        return data.data;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function localStoragePersist(key, maxAgeMs) {
+    return {
+        load: () => {
+            try {
+                return localStorage.getItem(key) || "";
+            }
+            catch {
+                return "";
+            }
+        },
+        save: (data) => {
+            try {
+                localStorage.setItem(key, data);
+            }
+            catch {
+                // do nothing
+            }
+        },
+        onChange: (callback) => {
+            window.addEventListener("storage", (ev) => {
+                if (ev.storageArea === localStorage && ev.key === key && ev.newValue) {
+                    callback(ev.newValue);
+                }
+            });
+        },
+        maxAgeMs,
+    };
+}

package/esm/modules/popupMessage.js

@@ -0,0 +1,17 @@
+import { createEvent, createStore, forward } from "effector";
+import { hideOnChangeAfterDelay } from "../effector/hideOnChangeAfterDelay.js";
+export function createPopupMessage(f, defaultMessage, additionalSources) {
+    const input = createEvent();
+    const lastMessage = createStore({ visible: false, message: defaultMessage });
+    lastMessage.on(input.map((e) => ({ visible: true, message: f(e) })), (_, v) => v);
+    if (additionalSources) {
+        for (const s of additionalSources) {
+            forward({
+                from: s,
+                to: input,
+            });
+        }
+    }
+    hideOnChangeAfterDelay(lastMessage, 3000);
+    return { input, lastMessage };
+}