@lana-commerce/core 11.0.0

package/esm/rfc3339Normalize.js

@@ -0,0 +1,6 @@
+export function rfc3339Normalize(s) {
+    return s
+        .replace("z", "Z")
+        .replace(/(\d\d-\d\d-\d\d)./, "$1T")
+        .replace(/([:.]\d+)(z|Z|[+-]\d\d:\d\d)$/, (_, m0, m1) => m0.startsWith(".") ? `${m0.padEnd(10, "0")}${m1}` : `${m0}.000000000${m1}`);
+}

package/esm/script.js

@@ -0,0 +1,157 @@
+import { BUILD_CONFIG } from "./buildconfig.js";
+import { arrayToDict } from "./arrayToDict.js";
+import { shopDomain } from "./shopDomain.js";
+const DEFAULT_CDN = BUILD_CONFIG.CDN_URL;
+const DEFAULT_BEACON = BUILD_CONFIG.BEACON_URL;
+async function getLatestUIVersion(tag) {
+    try {
+        const resp = await fetch(`https://registry.npmjs.org/${BUILD_CONFIG.UI_LIB}`);
+        return (await resp.json())["dist-tags"][tag || "latest"];
+    }
+    catch {
+        // ugly result, but it will work in some CDNs
+        return "latest";
+    }
+}
+async function getLatestAnalyticsVersion(cdn) {
+    try {
+        const resp = await fetch(`${cdn}/static/system/latest.txt`);
+        return (await resp.text()).trim();
+    }
+    catch {
+        // this will not work, but what can we do
+        return "latest";
+    }
+}
+export async function embedUI(config) {
+    const latestVersion = await getLatestUIVersion(config.tag);
+    const stripeGateway = config.gateways.find((gw) => gw.type === "stripe")?.stripe || undefined;
+    const loadConfig = {
+        shopID: config.shop.id,
+        opts: config.opts || {},
+        cdn: config.cdn || DEFAULT_CDN,
+        shopDomain: shopDomain(config.shop),
+        shopCurrency: config.shop.currency,
+        shopCurrencies: arrayToDict(config.currencies, (c) => c.currency.code),
+        tipsVariantID: config.shop.tips_enabled ? config.shop.tips_variant?.id : undefined,
+        oauth2Providers: config.shop.customer_oauth_providers,
+        stripe: stripeGateway
+            ? {
+                accountID: stripeGateway.account_id,
+                publishableKey: stripeGateway.publishable_key,
+            }
+            : undefined,
+    };
+    const loadConfigJSON = JSON.stringify(loadConfig);
+    const fontTagHref = "https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap";
+    const styleTagHref = `https://unpkg.com/${BUILD_CONFIG.UI_LIB}@${latestVersion}/bundle/ui.css`;
+    const scriptTagSrc = `https://unpkg.com/${BUILD_CONFIG.UI_LIB}@${latestVersion}/bundle/ui.js`;
+    const scriptThemeEditorTagSrc = `https://unpkg.com/${BUILD_CONFIG.UI_LIB}@${latestVersion}/bundle/theme-editor.js`;
+    const scriptInitTagContent = `window.addEventListener("DOMContentLoaded", function() { ${BUILD_CONFIG.UI_LIB_GLOBAL}.load(${loadConfigJSON}); });`;
+    const fontTag = `<link href="${fontTagHref}" rel="stylesheet">`;
+    const styleTag = `<link rel="stylesheet" href="${styleTagHref}">`;
+    const scriptTag = `<script defer src="${scriptTagSrc}"></script>`;
+    const scriptInitTag = `<script>${scriptInitTagContent}</script>`;
+    const scriptThemeEditorTag = `<script defer src="${scriptThemeEditorTagSrc}"></script>`;
+    const essentialTags = [fontTag, styleTag, scriptTag, scriptInitTag].join("\n");
+    return {
+        fontTagHref,
+        styleTagHref,
+        scriptTagSrc,
+        scriptInitTagContent,
+        scriptThemeEditorTagSrc,
+        fontTag,
+        styleTag,
+        scriptTag,
+        scriptInitTag,
+        scriptThemeEditorTag,
+        essentialTags,
+    };
+}
+const generateAnalyticsScriptTag = (version, cdn, init) => `window.analytics || (window.analytics = {});
+window.analyticsLoaded = false;
+window.analyticsQueue || (window.analyticsQueue = []);
+(function() {
+  var methods = ['identify', 'reset', 'track', 'trackLink', 'trackForm', 'trackClick', 'trackSubmit', 'page', 'pageview', 'ab', 'alias', 'ready', 'group', 'on', 'once', 'off'];
+  var factory = function(method) {
+    return function () {
+      var args = Array.prototype.slice.call(arguments);
+      args.unshift(method);
+      analyticsQueue.push(args);
+      return window.analytics;
+    };
+  };
+  for (var i = 0; i < methods.length; i++) {
+    var method = methods[i];
+    window.analytics[method] = factory(method);
+  }
+})();
+analytics.load = function(callback) {
+  var script = document.createElement('script');
+  script.async = true;
+  script.type = 'text/javascript';
+  script.src = '${cdn}/static/system/${version}/system.min.js';
+  if (script.addEventListener) {
+    script.addEventListener('load', function(e) {
+      if (typeof callback === 'function') {
+        callback(e);
+      }
+    }, false);
+  } else {
+    script.onreadystatechange = function () {
+      if (this.readyState == 'complete' || this.readyState == 'loaded') {
+        callback(window.event);
+      }
+    };
+  }
+  var firstScript = document.getElementsByTagName('script')[0];
+  firstScript.parentNode.insertBefore(script, firstScript);
+};
+analytics.load(function() {
+	analyticsLoaded = true;
+  analytics.debug();
+  analytics.initialize(${JSON.stringify(init)});
+  analytics.ready(function() {
+    while (window.analyticsQueue.length > 0) {
+      var item = window.analyticsQueue.shift();
+      var method = item.shift();
+      if (analytics[method]) analytics[method].apply(analytics, item);
+    }
+  })
+});`;
+export async function embedAnalytics(config) {
+    const lastVersion = await getLatestAnalyticsVersion(config.cdn || DEFAULT_CDN);
+    const googleAnalytics = config.branding.fields.find((f) => f.id === "google_analytics");
+    const googleAnalyticsTrackingID = config.branding.fields.find((f) => f.id === "google_analytics_tracking_id");
+    const googleAnalyticsAnonymize = config.branding.fields.find((f) => f.id === "google_analytics_anonymize");
+    const facebookPixel = config.branding.fields.find((f) => f.id === "facebook_pixel");
+    const facebookPixelID = config.branding.fields.find((f) => f.id === "facebook_pixel_id");
+    const init = {
+        [BUILD_CONFIG.ANALYTICS_INTEGRATION_NAME]: {
+            shopID: config.shop.id,
+            currency: config.shop.currency,
+            url: config.beacon || DEFAULT_BEACON,
+        },
+    };
+    if (googleAnalytics?.boolean && googleAnalyticsTrackingID?.string) {
+        init["Google Analytics"] = {
+            trackingId: googleAnalyticsTrackingID.string,
+            sendUserId: true,
+            enhancedEcommerce: true,
+            anonymizeIp: googleAnalyticsAnonymize?.boolean || false,
+        };
+    }
+    if (facebookPixel?.boolean && facebookPixelID?.string) {
+        init["Facebook Pixel"] = {
+            pixelId: facebookPixelID.string,
+        };
+    }
+    const cdn = config.cdn || DEFAULT_CDN;
+    const scriptTagContent = generateAnalyticsScriptTag(lastVersion, cdn, init);
+    const scriptTag = `<script>${scriptTagContent}</script>`;
+    return {
+        scriptTagContent,
+        scriptTag,
+        allTags: scriptTag,
+    };
+}

package/esm/seo.js

@@ -0,0 +1 @@
+export {};

package/esm/shopDomain.js

@@ -0,0 +1,4 @@
+import { BUILD_CONFIG } from "./buildconfig.js";
+export function shopDomain(shop) {
+    return shop.primary_domain ? shop.primary_domain.domain : `${shop.app_domain}.${BUILD_CONFIG.APP_DOMAIN}`;
+}

package/esm/shopLinks.js

@@ -0,0 +1,47 @@
+import { shopDomain } from "./shopDomain.js";
+function domain(shop) {
+    return typeof shop === "string" ? shop : shopDomain(shop);
+}
+export function shopBuyURL(shop, id) {
+    return `https://${domain(shop)}/buy/${encodeURIComponent(id)}`;
+}
+export function shopCheckoutBaseURL(shop) {
+    return `https://${domain(shop)}/checkout`;
+}
+export function shopCheckoutOrderURL(shop, orderID, orderUUID) {
+    return `https://${domain(shop)}/checkout/${encodeURIComponent(orderID)}/${encodeURIComponent(orderUUID)}`;
+}
+export function shopCheckoutTrackingURL(shop, orderID, orderUUID) {
+    return `https://${domain(shop)}/checkout/${encodeURIComponent(orderID)}/${encodeURIComponent(orderUUID)}/tracking`;
+}
+export function shopEmailConfirmationURL(shop, token) {
+    return `https://${domain(shop)}/confirm/${encodeURIComponent(token)}`;
+}
+export function shopPasswordResetURL(shop) {
+    return `https://${domain(shop)}/reset`;
+}
+export function shopNewPasswordURL(shop, code, email) {
+    return `https://${domain(shop)}/password/${encodeURIComponent(code)}/${encodeURIComponent(email)}`;
+}
+export function shopReviewURL(shop, productID, email) {
+    return email
+        ? `https://${domain(shop)}/reviews/${encodeURIComponent(productID)}/${encodeURIComponent(email)}`
+        : `https://${domain(shop)}/reviews/${encodeURIComponent(productID)}`;
+}
+export function shopQuestionURL(shop, productID, email) {
+    return email
+        ? `https://${domain(shop)}/questions/${encodeURIComponent(productID)}/${encodeURIComponent(email)}`
+        : `https://${domain(shop)}/questions/${encodeURIComponent(productID)}`;
+}
+export function shopConnectURL(shop) {
+    return `https://${domain(shop)}/connect`;
+}
+export function shopRemoteURL(shop) {
+    return `https://${domain(shop)}/remote`;
+}
+export function shopUnsubscribeURL(shop, token, email) {
+    return `https://${domain(shop)}/unsubscribe/${encodeURIComponent(token)}/${encodeURIComponent(email)}`;
+}
+export function shopSubscriptionURL(shop, subscriptionID, email) {
+    return `https://${domain(shop)}/subscriptions/${encodeURIComponent(subscriptionID)}/${encodeURIComponent(email)}`;
+}

package/esm/slate.js

@@ -0,0 +1,364 @@
+import escapeHTML from "escape-html";
+import { BUILD_CONFIG } from "./buildconfig.js";
+import { convertImageURL } from "./convertImageURL.js";
+import { splitBy } from "./splitBy.js";
+const PREFIX = BUILD_CONFIG.SLATE_CLASS_PREFIX;
+const markConfig = {
+    bold: { begin: "<strong>", end: "</strong>" },
+    code: { begin: "<code>", end: "</code>" },
+    italic: { begin: "<em>", end: "</em>" },
+    underlined: { begin: "<u>", end: "</u>" },
+    strikethrough: { begin: "<del>", end: "</del>" },
+};
+function calcTextLength(n) {
+    let len = 0;
+    if (n.leaves) {
+        for (const l of n.leaves) {
+            len += l.text.length;
+        }
+    }
+    if (n.nodes) {
+        for (const node of n.nodes) {
+            len += calcTextLength(node);
+        }
+    }
+    return len;
+}
+function extractTextFromNodeImpl(buf, n) {
+    if (n.leaves) {
+        for (const l of n.leaves) {
+            buf.push(l.text);
+        }
+    }
+    if (n.nodes) {
+        for (const node of n.nodes) {
+            extractTextFromNodeImpl(buf, node);
+        }
+    }
+}
+function extractTextFromNode(n) {
+    const buf = [];
+    extractTextFromNodeImpl(buf, n);
+    return buf.join(" ");
+}
+function serializeLeaf(_ctx, buf, leaf) {
+    if (leaf.marks) {
+        for (const m of leaf.marks) {
+            const v = markConfig[m.type];
+            if (v)
+                buf.push(v.begin);
+        }
+    }
+    buf.push(escapeHTML(leaf.text));
+    if (leaf.marks) {
+        for (const m of leaf.marks) {
+            const v = markConfig[m.type];
+            if (v)
+                buf.push(v.end);
+        }
+    }
+}
+function serializeText(ctx, buf, n) {
+    if (n.leaves) {
+        for (const leaf of n.leaves) {
+            serializeLeaf(ctx, buf, leaf);
+        }
+    }
+}
+function serializeInline(ctx, buf, n) {
+    if (n.type === "link") {
+        const beg = `<a href="${n.data.href || ""}">`;
+        const end = `</a>`;
+        wrap(buf, beg, serializeNodesFunc(ctx, buf, n.nodes), end);
+    }
+    else if (n.type === "emoji") {
+        // TODO
+    }
+}
+function imageDataSizeToStyle(img, m) {
+    m["width"] = "100%";
+    m["max-width"] = `${Math.max(16, img.width)}px`;
+    m["height"] = `${Math.max(16, img.height)}px`;
+}
+function imageDataAlignToStyle(img, m) {
+    if (img.align === "left") {
+        m["margin-left"] = "0";
+        m["margin-right"] = "auto";
+    }
+    else if (img.align === "center") {
+        m["margin-left"] = "auto";
+        m["margin-right"] = "auto";
+    }
+    else if (img.align === "right") {
+        m["margin-left"] = "auto";
+        m["margin-right"] = "0";
+    }
+    else if (img.align === "floatLeft") {
+        m["float"] = "left";
+        m["margin"] = "15px 15px 15px 0";
+    }
+    else if (img.align === "floatRight") {
+        m["float"] = "right";
+        m["margin"] = "15px 0 15px 15px";
+    }
+    else if (img.align === "fullWidth") {
+        if (img.locked) {
+            const w = Math.max(1, img.lockedW);
+            const h = Math.max(1, img.lockedH);
+            const p = `${((h / w) * 100).toFixed(2)}%`;
+            m["width"] = "100%";
+            m["padding-bottom"] = p;
+            m["max-width"] = "none";
+        }
+        else {
+            m["width"] = "100%";
+            m["max-width"] = "none";
+            m["height"] = `${Math.max(16, img.height)}px`;
+        }
+    }
+}
+function imageDataCropToStyle(img, m) {
+    if (img.crop === "") {
+        return;
+    }
+    m["background-size"] = "cover";
+    if (img.crop === "center") {
+        m["background-position"] = "center center";
+    }
+    else if (img.crop === "top") {
+        m["background-position"] = "center 0%";
+    }
+    else if (img.crop === "top-left") {
+        m["background-position"] = "0% 0%";
+    }
+    else if (img.crop === "top-right") {
+        m["background-position"] = "100% 0%";
+    }
+    else if (img.crop === "bottom") {
+        m["background-position"] = "center 100%";
+    }
+    else if (img.crop === "bottom-left") {
+        m["background-position"] = "0% 100%";
+    }
+    else if (img.crop === "bottom-right") {
+        m["ackground-position"] = "100% 100%";
+    }
+    else if (img.crop === "left") {
+        m["background-position"] = "0% center";
+    }
+    else if (img.crop === "right") {
+        m["background-position"] = "100% center";
+    }
+}
+function stylesMapToString(m) {
+    return Object.keys(m)
+        .sort()
+        .map((k) => `${k}: ${m[k]}`)
+        .join("; ");
+}
+function imageData(n) {
+    return {
+        align: n.data.align,
+        crop: n.data.crop,
+        fileID: n.data.fileID,
+        locked: n.data.locked,
+        width: n.data.width,
+        height: n.data.height,
+        lockedW: n.data.lockedW,
+        lockedH: n.data.lockedH,
+        src: n.data.src,
+    };
+}
+const topLevelHeaderMaybe = (ctx) => (ctx.lastTopLevelHeader ? `,id-${ctx.lastTopLevelHeader}` : "");
+function serializeBlock(ctx, buf, n) {
+    if (n.type === "h1") {
+        ctx.counter++;
+        ctx.lastTopLevelHeader = ctx.counter;
+        wrap(buf, `<h1 data-anchor="id-${ctx.counter}">`, serializeNodesFunc(ctx, buf, n.nodes), `</h1>`);
+    }
+    else if (n.type === "h2") {
+        wrap(buf, `<h2 data-anchor="id-${++ctx.counter}${topLevelHeaderMaybe(ctx)}">`, serializeNodesFunc(ctx, buf, n.nodes), `</h2>`);
+    }
+    else if (n.type === "h3") {
+        wrap(buf, `<h3 data-anchor="id-${++ctx.counter}${topLevelHeaderMaybe(ctx)}">`, serializeNodesFunc(ctx, buf, n.nodes), `</h3>`);
+    }
+    else if (n.type === "ol") {
+        wrap(buf, `<ol>`, serializeNodesFunc(ctx, buf, n.nodes), `</ol>`);
+    }
+    else if (n.type === "ul") {
+        wrap(buf, `<ul>`, serializeNodesFunc(ctx, buf, n.nodes), `</ul>`);
+    }
+    else if (n.type === "li") {
+        wrap(buf, `<li>`, serializeNodesFunc(ctx, buf, n.nodes), `</li>`);
+    }
+    else if (n.type === "blockquote") {
+        wrap(buf, `<blockquote>`, serializeNodesFunc(ctx, buf, n.nodes), `</blockquote>`);
+    }
+    else if (n.type === "paragraph") {
+        const pbuf = [];
+        serializeNodesFunc(ctx, pbuf, n.nodes)();
+        let beg = `<p>`;
+        const pbufData = pbuf.join("");
+        if (pbufData.length === 0) {
+            beg = `<p class="${PREFIX}content-empty-p">`;
+        }
+        wrap(buf, beg, serializeBufferFunc(buf, pbuf), `</p>`);
+    }
+    else if (n.type === "codeblock") {
+        wrap(buf, `<div class="${PREFIX}content-code">`, serializeNodesFunc(ctx, buf, n.nodes), `</div>`);
+    }
+    else if (n.type === "code") {
+        wrap(buf, `<div class="${PREFIX}content-code-line">`, serializeNodesFunc(ctx, buf, n.nodes), `</div>`);
+    }
+    else if (n.type === "image") {
+        const img = imageData(n);
+        const styles = {};
+        imageDataSizeToStyle(img, styles);
+        imageDataAlignToStyle(img, styles);
+        const imageParams = {};
+        if (img.align !== "fullWidth") {
+            imageParams.size = `${img.width}x${img.height}`;
+        }
+        if (img.crop !== "") {
+            imageParams.crop = img.crop; // TODO: is this a bug?
+        }
+        styles["background-image"] = `url('${convertImageURL(ctx.cdnBaseURL, publicURL(img.fileID, ctx), imageParams)}')`;
+        styles["background-repeat"] = "no-repeat";
+        styles["background-size"] = "contain";
+        styles["background-position"] = "center";
+        imageDataCropToStyle(img, styles);
+        buf.push(`<div class="${PREFIX}content-image" style="${stylesMapToString(styles)}"></div>`);
+    }
+    else if (n.type === "video") {
+        const img = imageData(n);
+        const iframeStyles = {
+            position: "absolute",
+            top: "0",
+            left: "0",
+            width: "100%",
+            height: "100%",
+        };
+        const styles = {};
+        imageDataSizeToStyle(img, styles);
+        imageDataAlignToStyle(img, styles);
+        const iframe = `<iframe allowfullscreen style="${stylesMapToString(iframeStyles)}" frameborder="0" src="${img.src}"></iframe>`;
+        buf.push(`<div class="${PREFIX}content-video" style="${stylesMapToString(styles)}">${iframe}</div>`);
+    }
+}
+function serializeNode(ctx, buf, n) {
+    if (n.object === "block") {
+        serializeBlock(ctx, buf, n);
+    }
+    else if (n.object === "inline") {
+        serializeInline(ctx, buf, n);
+    }
+    else if (n.object === "text") {
+        serializeText(ctx, buf, n);
+    }
+}
+function serializeBufferFunc(buf, srcbuf) {
+    return () => {
+        buf.push(...srcbuf);
+    };
+}
+function serializeNodesFunc(ctx, buf, nodes) {
+    return () => {
+        if (nodes) {
+            for (const n of nodes) {
+                serializeNode(ctx, buf, n);
+            }
+        }
+    };
+}
+function wrap(buf, begin, cb, end) {
+    buf.push(begin);
+    cb();
+    buf.push(end);
+}
+export function splitIntoNamed(v) {
+    const out = [];
+    const nodeGroups = split(v);
+    for (const ng of nodeGroups) {
+        const n = ng.length > 1 ? ng[0] : undefined;
+        if (n && n.object === "block" && (n.type === "h1" || n.type === "h2" || n.type === "h3")) {
+            // first node is a header, extract it into title :-)
+            out.push({ title: extractTextFromNode(n), nodes: ng.slice(1) });
+        }
+        else {
+            // no title T_T
+            out.push({ title: "", nodes: ng });
+        }
+    }
+    return out;
+}
+export function split(v) {
+    return splitBy(v.document.nodes, (n) => n.type === "separator");
+}
+export function isEmpty(v) {
+    let len = 0;
+    for (const node of v.document.nodes) {
+        len += calcTextLength(node);
+    }
+    return len === 0;
+}
+export function extractText(v) {
+    return v.document.nodes.map(extractTextFromNode).join(" ");
+}
+export function extractTextFromParagraphs(v) {
+    const paragraphNodes = v.document.nodes.filter((n) => n.object === "block" && n.type === "paragraph");
+    return paragraphNodes.map(extractTextFromNode).join(" ");
+}
+export function extractHeaders(v) {
+    const headers = [];
+    let counter = 0;
+    let lastTopLevel = null;
+    for (const n of v.document.nodes) {
+        if (n.object === "block") {
+            if (n.type === "h1") {
+                lastTopLevel = {
+                    id: `id-${++counter}`,
+                    text: extractTextFromNode(n),
+                    children: [],
+                };
+                headers.push(lastTopLevel);
+            }
+            else if (n.type === "h2" && lastTopLevel) {
+                lastTopLevel.children.push({
+                    id: `id-${++counter}`,
+                    text: extractTextFromNode(n),
+                });
+            }
+            else if (n.type === "h3" && lastTopLevel) {
+                lastTopLevel.children.push({
+                    id: `id-${++counter}`,
+                    text: extractTextFromNode(n),
+                });
+            }
+        }
+    }
+    return headers;
+}
+function publicURL(fileID, ctx) {
+    for (const f of ctx.contentImageFiles) {
+        if (f.id === fileID) {
+            return f.public_url;
+        }
+    }
+    return "";
+}
+export function nodesToHTML(cdnBaseURL, nodes, contentImageFiles) {
+    const buf = [];
+    const ctx = {
+        cdnBaseURL,
+        lastTopLevelHeader: undefined,
+        counter: 0,
+        contentImageFiles,
+    };
+    wrap(buf, `<div class="${PREFIX}content-root">`, serializeNodesFunc(ctx, buf, nodes), `</div>`);
+    return buf.join("");
+}
+export function toHTML(cdnBaseURL, v, contentImageFiles) {
+    return split(v).map((nodes) => {
+        return nodesToHTML(cdnBaseURL, nodes, contentImageFiles);
+    });
+}

package/esm/sleep.js

@@ -0,0 +1,3 @@
+export async function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}

package/esm/splitBy.js

@@ -0,0 +1,17 @@
+export function splitBy(v, isSep) {
+    const initial = [];
+    const state = {
+        output: [initial],
+        current: initial,
+    };
+    for (const current of v) {
+        if (isSep(current)) {
+            state.current = [];
+            state.output.push(state.current);
+        }
+        else {
+            state.current.push(current);
+        }
+    }
+    return state.output;
+}

package/esm/splitName.js

@@ -0,0 +1,22 @@
+import humanparser from "humanparser";
+export function splitName(name) {
+    const nm = humanparser.parseName(name);
+    if (nm.firstName && nm.lastName) {
+        return [nm.firstName, nm.lastName];
+    }
+    else if (nm.firstName) {
+        return [nm.firstName];
+    }
+    return [""];
+}
+export function initials(name) {
+    const [firstName, lastName] = splitName(name);
+    let out = "";
+    if (firstName) {
+        out += firstName.substr(0, 1).toUpperCase();
+    }
+    if (lastName) {
+        out += lastName.substr(0, 1).toUpperCase();
+    }
+    return out;
+}

package/esm/stripZeros.js

@@ -0,0 +1,9 @@
+export function stripZeros(v) {
+    const dotAt = v.indexOf(".");
+    if (dotAt === -1)
+        return v;
+    while (v.length > dotAt && (v[v.length - 1] === "0" || v[v.length - 1] === ".")) {
+        v = v.substring(0, v.length - 1);
+    }
+    return v;
+}

package/esm/stripeError.js

@@ -0,0 +1,53 @@
+import { ErrorCode } from "./generated/codes.js";
+const stripeNumberErrorMap = {
+    invalid_number: true,
+    incorrect_number: true,
+    incomplete_number: true,
+    card_declined: true,
+    missing: true,
+    processing_error: true,
+};
+const stripeExpiryErrorMap = {
+    invalid_expiry_month: true,
+    invalid_expiry_year: true,
+    expired_card: true,
+    incomplete_expiry: true,
+    invalid_expiry_year_past: true,
+    invalid_expiry_month_past: true,
+};
+const stripeCVCErrorMap = {
+    invalid_cvc: true,
+    incorrect_cvc: true,
+    incomplete_cvc: true,
+};
+export function matchMap(map, code) {
+    return map[code] ? code : undefined;
+}
+export function matchNumberError(code) {
+    return matchMap(stripeNumberErrorMap, code);
+}
+export function matchExpiryError(code) {
+    return matchMap(stripeExpiryErrorMap, code);
+}
+export function matchCVCError(code) {
+    return matchMap(stripeCVCErrorMap, code);
+}
+export function matchMapFromRR(map, e) {
+    if (e.kind !== "error")
+        return undefined;
+    if (e.error.apiError?.code !== ErrorCode.StripeAPICallFailure)
+        return undefined;
+    const code = e.error.apiError.meta?.code;
+    if (!code)
+        return undefined;
+    return matchMap(map, code);
+}
+export function matchNumberErrorFromRR(e) {
+    return matchMapFromRR(stripeNumberErrorMap, e);
+}
+export function matchExpiryErrorFromRR(e) {
+    return matchMapFromRR(stripeExpiryErrorMap, e);
+}
+export function matchCVCErrorFromRR(e) {
+    return matchMapFromRR(stripeCVCErrorMap, e);
+}