@swan-io/lake 1.0.0

package/src/utils/popper.js

@@ -0,0 +1,30 @@
+export const getRootElement = (element) => {
+    let current = element;
+    while (current) {
+        const { parentElement: parent } = current;
+        if (!parent) {
+            break;
+        }
+        if (parent === document.body || parent.matches("[aria-modal=true]")) {
+            return current;
+        }
+        current = parent;
+    }
+    return null;
+};
+export const matchReferenceWidthModifier = {
+    name: "matchReferenceWidth",
+    requires: ["computeStyles"],
+    enabled: false,
+    phase: "beforeWrite",
+    fn({ state }) {
+        if (state.styles.popper) {
+            state.styles.popper.width = state.rects.reference.width.toString() + "px";
+        }
+    },
+    effect({ state }) {
+        if (state.elements.reference instanceof HTMLElement) {
+            state.elements.popper.style.width = state.elements.reference.offsetWidth.toString() + "px";
+        }
+    },
+};

package/src/utils/rifm.d.ts

@@ -0,0 +1,14 @@
+import { ComponentProps } from "react";
+import { Rifm } from "rifm";
+export type Props = Required<Pick<ComponentProps<typeof Rifm>, "accept" | "append" | "format" | "mask">>;
+declare const accepted: {
+    alpha: RegExp;
+    numeric: RegExp;
+    alphanumeric: RegExp;
+};
+export declare const getRifmProps: ({ accept, charMap, maxLength, }: {
+    accept: keyof typeof accepted;
+    maxLength: number;
+    charMap: Record<number, string>;
+}) => Props;
+export {};

package/src/utils/rifm.js

@@ -0,0 +1,53 @@
+import { isNotNullish, isNullish } from "./nullish";
+const accepted = {
+    alpha: /[a-z]/gi,
+    numeric: /\d+/g,
+    alphanumeric: /[a-z\d]+/gi,
+};
+export const getRifmProps = ({ accept, charMap, maxLength, }) => {
+    const charIndexes = Object.keys(charMap).map(Number);
+    if (process.env.NODE_ENV === "development") {
+        const maxCharIndex = maxLength - 1;
+        charIndexes.forEach(charMapIndex => {
+            const char = charMap[charMapIndex];
+            if (isNullish(char)) {
+                throw new Error(`Invalid mask character value`);
+            }
+            if (char.length !== 1) {
+                throw new Error(`Invalid mask character value: "${char}"`);
+            }
+            if (charMapIndex > maxCharIndex) {
+                throw new Error(`Invalid mask character index: "${charMapIndex}"`);
+            }
+        });
+    }
+    const maxFormattedLength = maxLength + charIndexes.length;
+    const regExp = accepted[accept];
+    const shiftedCharMap = charIndexes.reduce((acc, charIndex, index) => {
+        const char = charMap[charIndex] ?? "";
+        return { ...acc, [charIndex + index]: char };
+    }, {});
+    const shiftedCharIndexes = Object.keys(shiftedCharMap).map(Number);
+    return {
+        accept: regExp,
+        mask: false,
+        append: (str) => {
+            const right = shiftedCharIndexes.includes(str.length) ? shiftedCharMap[str.length] : "";
+            return str + (right ?? "");
+        },
+        format: (str) => {
+            const chars = (str.match(regExp) ?? []).join("").split("");
+            const res = chars
+                .reduce((acc, char, index) => {
+                const center = charIndexes.includes(index) ? charMap[index] : "";
+                return acc + (center ?? "") + char;
+            }, "")
+                .substr(0, maxFormattedLength);
+            const char = shiftedCharMap[res.length];
+            return (res +
+                (isNotNullish(char) && str.endsWith(char) && shiftedCharIndexes.includes(res.length)
+                    ? char
+                    : ""));
+        },
+    };
+};

package/src/utils/string.d.ts

@@ -0,0 +1,4 @@
+export declare const safeSplitAround: (string: string, expression: string) => string[];
+export declare const deburr: (value: string) => string;
+export declare const words: (string: string) => string[];
+export declare const capitalize: (string: string) => string;

package/src/utils/string.js

@@ -0,0 +1,233 @@
+export const safeSplitAround = (string, expression) => {
+    let index = 0;
+    const splitString = [];
+    while (index < string.length) {
+        const nextIndexOfExpression = string.indexOf(expression, index);
+        if (nextIndexOfExpression === -1) {
+            splitString.push(string.slice(index));
+            return splitString;
+        }
+        if (nextIndexOfExpression > index) {
+            const endIndex = nextIndexOfExpression + expression.length;
+            splitString.push(string.slice(index, nextIndexOfExpression), string.slice(nextIndexOfExpression, endIndex));
+            index = endIndex;
+            continue;
+        }
+        if (nextIndexOfExpression === index) {
+            const endIndex = nextIndexOfExpression + expression.length;
+            splitString.push(string.slice(nextIndexOfExpression, endIndex));
+            index = endIndex;
+            continue;
+        }
+        return splitString;
+    }
+    return splitString;
+};
+/** Used to map Latin Unicode letters to basic Latin letters. */
+const deburredLetters = {
+    // Latin-1 Supplement block.
+    "\xc0": "A",
+    "\xc1": "A",
+    "\xc2": "A",
+    "\xc3": "A",
+    "\xc4": "A",
+    "\xc5": "A",
+    "\xe0": "a",
+    "\xe1": "a",
+    "\xe2": "a",
+    "\xe3": "a",
+    "\xe4": "a",
+    "\xe5": "a",
+    "\xc7": "C",
+    "\xe7": "c",
+    "\xd0": "D",
+    "\xf0": "d",
+    "\xc8": "E",
+    "\xc9": "E",
+    "\xca": "E",
+    "\xcb": "E",
+    "\xe8": "e",
+    "\xe9": "e",
+    "\xea": "e",
+    "\xeb": "e",
+    "\xcc": "I",
+    "\xcd": "I",
+    "\xce": "I",
+    "\xcf": "I",
+    "\xec": "i",
+    "\xed": "i",
+    "\xee": "i",
+    "\xef": "i",
+    "\xd1": "N",
+    "\xf1": "n",
+    "\xd2": "O",
+    "\xd3": "O",
+    "\xd4": "O",
+    "\xd5": "O",
+    "\xd6": "O",
+    "\xd8": "O",
+    "\xf2": "o",
+    "\xf3": "o",
+    "\xf4": "o",
+    "\xf5": "o",
+    "\xf6": "o",
+    "\xf8": "o",
+    "\xd9": "U",
+    "\xda": "U",
+    "\xdb": "U",
+    "\xdc": "U",
+    "\xf9": "u",
+    "\xfa": "u",
+    "\xfb": "u",
+    "\xfc": "u",
+    "\xdd": "Y",
+    "\xfd": "y",
+    "\xff": "y",
+    "\xc6": "Ae",
+    "\xe6": "ae",
+    "\xde": "Th",
+    "\xfe": "th",
+    "\xdf": "ss",
+    // Latin Extended-A block.
+    "\u0100": "A",
+    "\u0102": "A",
+    "\u0104": "A",
+    "\u0101": "a",
+    "\u0103": "a",
+    "\u0105": "a",
+    "\u0106": "C",
+    "\u0108": "C",
+    "\u010a": "C",
+    "\u010c": "C",
+    "\u0107": "c",
+    "\u0109": "c",
+    "\u010b": "c",
+    "\u010d": "c",
+    "\u010e": "D",
+    "\u0110": "D",
+    "\u010f": "d",
+    "\u0111": "d",
+    "\u0112": "E",
+    "\u0114": "E",
+    "\u0116": "E",
+    "\u0118": "E",
+    "\u011a": "E",
+    "\u0113": "e",
+    "\u0115": "e",
+    "\u0117": "e",
+    "\u0119": "e",
+    "\u011b": "e",
+    "\u011c": "G",
+    "\u011e": "G",
+    "\u0120": "G",
+    "\u0122": "G",
+    "\u011d": "g",
+    "\u011f": "g",
+    "\u0121": "g",
+    "\u0123": "g",
+    "\u0124": "H",
+    "\u0126": "H",
+    "\u0125": "h",
+    "\u0127": "h",
+    "\u0128": "I",
+    "\u012a": "I",
+    "\u012c": "I",
+    "\u012e": "I",
+    "\u0130": "I",
+    "\u0129": "i",
+    "\u012b": "i",
+    "\u012d": "i",
+    "\u012f": "i",
+    "\u0131": "i",
+    "\u0134": "J",
+    "\u0135": "j",
+    "\u0136": "K",
+    "\u0137": "k",
+    "\u0138": "k",
+    "\u0139": "L",
+    "\u013b": "L",
+    "\u013d": "L",
+    "\u013f": "L",
+    "\u0141": "L",
+    "\u013a": "l",
+    "\u013c": "l",
+    "\u013e": "l",
+    "\u0140": "l",
+    "\u0142": "l",
+    "\u0143": "N",
+    "\u0145": "N",
+    "\u0147": "N",
+    "\u014a": "N",
+    "\u0144": "n",
+    "\u0146": "n",
+    "\u0148": "n",
+    "\u014b": "n",
+    "\u014c": "O",
+    "\u014e": "O",
+    "\u0150": "O",
+    "\u014d": "o",
+    "\u014f": "o",
+    "\u0151": "o",
+    "\u0154": "R",
+    "\u0156": "R",
+    "\u0158": "R",
+    "\u0155": "r",
+    "\u0157": "r",
+    "\u0159": "r",
+    "\u015a": "S",
+    "\u015c": "S",
+    "\u015e": "S",
+    "\u0160": "S",
+    "\u015b": "s",
+    "\u015d": "s",
+    "\u015f": "s",
+    "\u0161": "s",
+    "\u0162": "T",
+    "\u0164": "T",
+    "\u0166": "T",
+    "\u0163": "t",
+    "\u0165": "t",
+    "\u0167": "t",
+    "\u0168": "U",
+    "\u016a": "U",
+    "\u016c": "U",
+    "\u016e": "U",
+    "\u0170": "U",
+    "\u0172": "U",
+    "\u0169": "u",
+    "\u016b": "u",
+    "\u016d": "u",
+    "\u016f": "u",
+    "\u0171": "u",
+    "\u0173": "u",
+    "\u0174": "W",
+    "\u0175": "w",
+    "\u0176": "Y",
+    "\u0177": "y",
+    "\u0178": "Y",
+    "\u0179": "Z",
+    "\u017b": "Z",
+    "\u017d": "Z",
+    "\u017a": "z",
+    "\u017c": "z",
+    "\u017e": "z",
+    "\u0132": "IJ",
+    "\u0133": "ij",
+    "\u0152": "Oe",
+    "\u0153": "oe",
+    "\u0149": "'n",
+    "\u017f": "s",
+};
+export const deburr = (value) => {
+    /** Used to match Latin Unicode letters (excluding mathematical operators). */
+    const reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+    return value
+        .replace(reLatin, char => deburredLetters[char] ?? "")
+        .replace(/[\u0300-\u036f]/g, "");
+};
+export const words = (string) => {
+    return string.split(/\b/).filter(x => /^[a-zA-Z0-9]+$/.test(x));
+};
+export const capitalize = (string) => {
+    return `${string.charAt(0).toUpperCase()}${string.slice(1).toLowerCase()}`;
+};

package/src/utils/timer.d.ts

@@ -0,0 +1,11 @@
+export type ControllableTimeout = {
+    readonly duration: number;
+    readonly clear: () => void;
+    readonly reset: () => void;
+};
+export declare const createControllableTimeout: (config: {
+    duration: number;
+    onStart: (duration: number) => void;
+    onEnd: () => void;
+    onReset: (duration: number) => void;
+}) => ControllableTimeout;

package/src/utils/timer.js

@@ -0,0 +1,46 @@
+// based on https://gist.github.com/ncou/3a0a1f89c8e22416d0d607f621a948a9
+export const createControllableTimeout = (config) => {
+    const { duration, onStart, onReset, onEnd } = config;
+    let timerId = 0;
+    let remaining = duration;
+    const clear = () => {
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+        window.clearTimeout(timerId);
+    };
+    const start = () => {
+        if (remaining <= 0) {
+            return;
+        }
+        timerId = window.setTimeout(() => {
+            remaining = 0;
+            clear();
+            onEnd();
+        }, remaining);
+        onStart(duration);
+    };
+    const reset = () => {
+        window.clearTimeout(timerId);
+        remaining = duration;
+        timerId = window.setTimeout(() => {
+            remaining = 0;
+            clear();
+            onEnd();
+        }, duration);
+        onReset(duration);
+    };
+    const onVisibilityChange = () => {
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+        start();
+    };
+    if (document.hidden) {
+        document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    else {
+        start();
+    }
+    return {
+        duration,
+        clear,
+        reset,
+    };
+};

package/src/utils/types.d.ts

@@ -0,0 +1,8 @@
+export type GetEdge<T extends {
+    edges: unknown[];
+}> = T["edges"][number];
+export type GetNode<T extends {
+    edges: {
+        node: unknown;
+    }[];
+}> = GetEdge<T>["node"];

package/src/utils/types.js

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

package/src/utils/userAgent.d.ts

@@ -0,0 +1,4 @@
+export declare const isChrome: boolean;
+export declare const isMobile: boolean;
+export declare const isChromeMobile: boolean;
+export declare const isSafari: boolean;

package/src/utils/userAgent.js

@@ -0,0 +1,9 @@
+import { isNullish } from "./nullish";
+const CHROME_REGEXP = /Chrom(e|ium)\//;
+const MOBI_REGEXP = /Mobi/;
+const SAFARI_REGEXP = /Safari\//;
+export const isChrome = CHROME_REGEXP.test(navigator.userAgent);
+export const isMobile = MOBI_REGEXP.test(navigator.userAgent);
+export const isChromeMobile = isChrome && isMobile;
+// https://github.com/jakearchibald/safari-14-idb-fix/blob/v3.0.0/src/index.ts#L7
+export const isSafari = isNullish(navigator.userAgentData) && SAFARI_REGEXP.test(navigator.userAgent) && !isChrome;

package/src/utils/viewport.d.ts

@@ -0,0 +1 @@
+export declare const preventSafariAutoZoomOnInputs: () => void;

package/src/utils/viewport.js

@@ -0,0 +1,12 @@
+import { isNotNullish } from "./nullish";
+import { isSafari } from "./userAgent";
+// Prevents Safari from zooming automatically on inputs, still allow user to zoom manually
+export const preventSafariAutoZoomOnInputs = () => {
+    if (isSafari) {
+        const viewport = document.querySelector("meta[name=viewport]");
+        const content = viewport?.getAttribute("content");
+        if (isNotNullish(viewport) && isNotNullish(content)) {
+            viewport.setAttribute("content", content + ", maximum-scale=1.0");
+        }
+    }
+};