@swan-io/lake 1.0.0

package/src/utils/__tests__/array.test.js

@@ -0,0 +1,127 @@
+import { describe, expect, test } from "vitest";
+import { first, groupBy, last, partition, sortBy, sortedIndexOf } from "../array";
+describe("first", () => {
+    test("returns the first element of an array", () => {
+        const numberArray = [1, 2, 3];
+        const stringArray = [];
+        expect(first(numberArray)).toBe(1);
+        expect(first(stringArray)).toBe(undefined);
+    });
+});
+describe("last", () => {
+    test("returns the last element of an array", () => {
+        const emptyArray = [];
+        const stringArray = ["foo", "bar"];
+        expect(last(emptyArray)).toBe(undefined);
+        expect(last(stringArray)).toBe("bar");
+    });
+});
+describe("partition", () => {
+    test("Returns the first element as truth if id_verified = true, and the second element as false", () => {
+        const output = [
+            {
+                id: "123",
+                id_verified: true,
+                email: "joe@gmail.com",
+            },
+            {
+                id: "456",
+                id_verified: false,
+                email: "doe@gmail.com",
+            },
+            {
+                id: "789",
+                id_verified: true,
+                email: "john@gmail.com",
+            },
+        ];
+        expect(partition(output, member => member.id_verified === true)).toStrictEqual([
+            [
+                {
+                    id: "123",
+                    id_verified: true,
+                    email: "joe@gmail.com",
+                },
+                {
+                    id: "789",
+                    id_verified: true,
+                    email: "john@gmail.com",
+                },
+            ],
+            [
+                {
+                    id: "456",
+                    id_verified: false,
+                    email: "doe@gmail.com",
+                },
+            ],
+        ]);
+    });
+    test("Returns 2 empty arrays if the output is empty", () => {
+        const output = [];
+        expect(partition(output, member => member.id_verified === true)).toStrictEqual([[], []]);
+    });
+    test("Returns an empty first array, and a second containing the output if the function is looking for an inexistant parameter", () => {
+        const output = [
+            {
+                id: "123",
+                id_verified: true,
+                email: "joe@gmail.com",
+            },
+            {
+                id: "456",
+                id_verified: false,
+                email: "doe@gmail.com",
+            },
+        ];
+        expect(partition(output, member => member.id_verified === undefined)).toStrictEqual([
+            [],
+            [
+                {
+                    id: "123",
+                    id_verified: true,
+                    email: "joe@gmail.com",
+                },
+                {
+                    id: "456",
+                    id_verified: false,
+                    email: "doe@gmail.com",
+                },
+            ],
+        ]);
+    });
+});
+describe("sortBy", () => {
+    test("should sort", () => {
+        expect(sortBy([
+            { a: 1, b: 2 },
+            { a: 2, b: 2 },
+            { a: 1, b: 1 },
+        ], ["a", "b"])).toEqual([
+            { a: 1, b: 1 },
+            { a: 1, b: 2 },
+            { a: 2, b: 2 },
+        ]);
+    });
+});
+describe("sortedIndexOf", () => {
+    test("should find", () => {
+        expect(sortedIndexOf(Array.from({ length: 1000 }, (_, index) => index), 25)).toEqual(25);
+    });
+    test("should return -1 if not found", () => {
+        expect(sortedIndexOf(Array.from({ length: 1000 }, (_, index) => index), 1001)).toEqual(-1);
+    });
+});
+describe("groupBy", () => {
+    test("groups", () => {
+        expect(groupBy([1, 2, 3, 4, 5, 6], item => (item % 2 === 0 ? "even" : "odd"))).toEqual({
+            even: [2, 4, 6],
+            odd: [1, 3, 5],
+        });
+        expect(groupBy([0, 1, 2, 3, 4, 5, 6], item => item === 0 ? "zero" : item % 2 === 0 ? "even" : "odd")).toEqual({
+            zero: [0],
+            even: [2, 4, 6],
+            odd: [1, 3, 5],
+        });
+    });
+});

package/src/utils/__tests__/base64.test.d.ts

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

package/src/utils/__tests__/base64.test.js

@@ -0,0 +1,27 @@
+import { expect, test } from "vitest";
+import { decodeBase64, encodeBase64 } from "../base64";
+test("decodeBase64", () => {
+    expect(decodeBase64("ZA==")).toBe("d");
+    expect(decodeBase64("ZGE=")).toBe("da");
+    expect(decodeBase64("ZGFu")).toBe("dan");
+    expect(decodeBase64("Z A==")).toBe("d");
+    expect(decodeBase64("ZG E=")).toBe("da");
+    expect(decodeBase64("ZGF u")).toBe("dan");
+    expect(decodeBase64("AA==")).toBe("\0");
+    expect(decodeBase64("AAA=")).toBe("\0\0");
+    expect(decodeBase64("AAAA")).toBe("\0\0\0");
+    expect(decodeBase64("5bCP6aO85by+")).toBe("小飼弾");
+    expect(decodeBase64("5bCP6aO85by-")).toBe("小飼弾");
+    expect(decodeBase64("8KCut+mHjuWutg==")).toBe("𠮷野家");
+    expect(decodeBase64("8KCut-mHjuWutg")).toBe("𠮷野家");
+});
+test("encodeBase64", () => {
+    expect(encodeBase64("d")).toBe("ZA==");
+    expect(encodeBase64("da")).toBe("ZGE=");
+    expect(encodeBase64("dan")).toBe("ZGFu");
+    expect(encodeBase64("\0")).toBe("AA==");
+    expect(encodeBase64("\0\0")).toBe("AAA=");
+    expect(encodeBase64("\0\0\0")).toBe("AAAA");
+    expect(encodeBase64("小飼弾")).toBe("5bCP6aO85by+");
+    expect(encodeBase64("𠮷野家")).toBe("8KCut+mHjuWutg==");
+});

package/src/utils/__tests__/function.test.d.ts

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

package/src/utils/__tests__/function.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "vitest";
+import { identity, memoize, noop, stubTrue } from "../function";
+describe("stubTrue", () => {
+    test("returns true", () => {
+        expect(stubTrue()).toBe(true);
+    });
+});
+describe("identity", () => {
+    test("returns the first argument", () => {
+        const obj = {
+            val: 1,
+        };
+        expect(identity(obj)).toBe(obj);
+    });
+});
+describe("noop", () => {
+    test("returns `undefined`", () => {
+        expect(noop()).toBe(undefined);
+    });
+});
+describe("memoize", () => {
+    test("memoizes", () => {
+        let callCount = 0;
+        const expensiveFunction = (input) => {
+            ++callCount;
+            return input * 2;
+        };
+        const memoizedExpensiveFunction = memoize(expensiveFunction, x => String(x));
+        expect(memoizedExpensiveFunction(1)).toEqual(2);
+        expect(memoizedExpensiveFunction(1)).toEqual(2);
+        expect(callCount).toEqual(1);
+        expect(memoizedExpensiveFunction(2)).toEqual(4);
+        expect(memoizedExpensiveFunction(2)).toEqual(4);
+        expect(callCount).toEqual(2);
+    });
+});

package/src/utils/__tests__/object.test.d.ts

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

package/src/utils/__tests__/object.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, test } from "vitest";
+import { isPlainObject, pick } from "../object";
+describe("isPlainObject", () => {
+    test("returns true if it's a plain object", () => {
+        const json = {
+            foo: "foo",
+            bar: false,
+            baz: 1,
+        };
+        expect(isPlainObject(json)).toBe(true);
+    });
+});
+describe("pick", () => {
+    test("picks", () => {
+        expect(pick({ foo: 1, bar: 2, baz: 3, quux: 4 }, ["foo", "bar"])).toEqual({ foo: 1, bar: 2 });
+    });
+});

package/src/utils/__tests__/rifm.test.d.ts

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

package/src/utils/__tests__/rifm.test.js

@@ -0,0 +1,124 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cleanup, fireEvent, render } from "@testing-library/react";
+import { useState } from "react";
+import { Rifm } from "rifm";
+import { afterEach, expect, test } from "vitest";
+import { getRifmProps } from "../rifm";
+const typeInInput = (input, value) => fireEvent.input(input, { target: { value } });
+const clearInput = (input) => fireEvent.input(input, { target: { value: "" } });
+afterEach(() => {
+    cleanup();
+});
+test('it respects accept: "alpha" param', async () => {
+    const props = getRifmProps({
+        accept: "alpha",
+        charMap: { 2: " ", 4: "/" },
+        maxLength: 6,
+    });
+    const Test = () => {
+        const [value, setValue] = useState("");
+        return (_jsx(Rifm, { ...props, value: value, onChange: setValue, children: ({ value, onChange }) => _jsx("input", { type: "text", value: value, onChange: onChange }) }));
+    };
+    const utils = render(_jsx(Test, {}));
+    const input = await utils.findByRole("textbox");
+    typeInInput(input, "test");
+    expect(input).toHaveValue("te st/");
+    clearInput(input);
+    typeInInput(input, "1234");
+    expect(input).toHaveValue("");
+    clearInput(input);
+    typeInInput(input, "te34");
+    expect(input).toHaveValue("te ");
+    clearInput(input);
+});
+test('it respects accept: "numeric" param', async () => {
+    const props = getRifmProps({
+        accept: "numeric",
+        charMap: { 2: " ", 4: "/" },
+        maxLength: 6,
+    });
+    const Test = () => {
+        const [value, setValue] = useState("");
+        return (_jsx(Rifm, { ...props, value: value, onChange: setValue, children: ({ value, onChange }) => _jsx("input", { type: "text", value: value, onChange: onChange }) }));
+    };
+    const utils = render(_jsx(Test, {}));
+    const input = await utils.findByRole("textbox");
+    typeInInput(input, "test");
+    expect(input).toHaveValue("");
+    clearInput(input);
+    typeInInput(input, "1234");
+    expect(input).toHaveValue("12 34/");
+    clearInput(input);
+    typeInInput(input, "te34");
+    expect(input).toHaveValue("34 ");
+    clearInput(input);
+});
+test('it respects accept: "alphanumeric" param', async () => {
+    const props = getRifmProps({
+        accept: "alphanumeric",
+        charMap: { 2: " ", 4: "/" },
+        maxLength: 6,
+    });
+    const Test = () => {
+        const [value, setValue] = useState("");
+        return (_jsx(Rifm, { ...props, value: value, onChange: setValue, children: ({ value, onChange }) => _jsx("input", { type: "text", value: value, onChange: onChange }) }));
+    };
+    const utils = render(_jsx(Test, {}));
+    const input = await utils.findByRole("textbox");
+    typeInInput(input, "test");
+    expect(input).toHaveValue("te st/");
+    clearInput(input);
+    typeInInput(input, "1234");
+    expect(input).toHaveValue("12 34/");
+    clearInput(input);
+    typeInInput(input, "te34");
+    expect(input).toHaveValue("te 34/");
+    clearInput(input);
+    typeInInput(input, "t__4");
+    expect(input).toHaveValue("t4 ");
+    clearInput(input);
+});
+test("it appends characters at given indexes", async () => {
+    const props = getRifmProps({
+        accept: "numeric",
+        charMap: { 2: " ", 4: "/" },
+        maxLength: 6,
+    });
+    const Test = () => {
+        const [value, setValue] = useState("");
+        return (_jsx(Rifm, { ...props, value: value, onChange: setValue, children: ({ value, onChange }) => _jsx("input", { type: "text", value: value, onChange: onChange }) }));
+    };
+    const utils = render(_jsx(Test, {}));
+    const input = await utils.findByRole("textbox");
+    typeInInput(input, "12");
+    expect(input).toHaveValue("12 ");
+    clearInput(input);
+    typeInInput(input, "1234");
+    expect(input).toHaveValue("12 34/");
+    clearInput(input);
+    typeInInput(input, "123456");
+    expect(input).toHaveValue("12 34/56");
+    clearInput(input);
+});
+test("it truncates the formatted text to the maximum length", async () => {
+    const props = getRifmProps({
+        accept: "numeric",
+        charMap: { 2: " ", 4: "/" },
+        maxLength: 6,
+    });
+    const Test = () => {
+        const [value, setValue] = useState("");
+        return (_jsx(Rifm, { ...props, value: value, onChange: setValue, children: ({ value, onChange }) => _jsx("input", { type: "text", value: value, onChange: onChange }) }));
+    };
+    const utils = render(_jsx(Test, {}));
+    const input = await utils.findByRole("textbox");
+    typeInInput(input, "1234");
+    expect(input).toHaveValue("12 34/");
+    clearInput(input);
+    typeInInput(input, "123456");
+    expect(input).toHaveValue("12 34/56");
+    clearInput(input);
+    typeInInput(input, "12345678");
+    expect(input).toHaveValue("12 34/56");
+    clearInput(input);
+});

package/src/utils/__tests__/string.test.d.ts

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

package/src/utils/__tests__/string.test.js

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+import { deburr, safeSplitAround, words } from "../string";
+test("string safeSplitAround", () => {
+    expect(safeSplitAround("bar", "foo")).toEqual(["bar"]);
+    expect(safeSplitAround("foo", "foo")).toEqual(["foo"]);
+    expect(safeSplitAround("foo bar baz foo", "foo")).toEqual(["foo", " bar baz ", "foo"]);
+    expect(safeSplitAround("foo bar baz foo", "bar")).toEqual(["foo ", "bar", " baz foo"]);
+});
+test("deburr", () => {
+    expect(deburr("Bonjour à toutes & à tous")).toEqual("Bonjour a toutes & a tous");
+});
+test("words", () => {
+    expect(words("john doe")).toEqual(["john", "doe"]);
+    expect(words("john' doe")).toEqual(["john", "doe"]);
+    expect(words("john-doe")).toEqual(["john", "doe"]);
+});

package/src/utils/a11y.d.ts

@@ -0,0 +1 @@
+export declare const getFocusableElements: (rootNode?: Element, includeRoot?: boolean) => HTMLElement[];

package/src/utils/a11y.js

@@ -0,0 +1,18 @@
+// Pulled from https://github.com/KittyGiraudel/focusable-selectors
+const FOCUSABLE_SELECTOR = [
+    'a[href]:not([tabindex^="-"])',
+    'area[href]:not([tabindex^="-"])',
+    'input:not([type="hidden"]):not([type="radio"]):not([disabled]):not([tabindex^="-"])',
+    'input[type="radio"]:not([disabled]):not([tabindex^="-"])',
+    'select:not([disabled]):not([tabindex^="-"])',
+    'textarea:not([disabled]):not([tabindex^="-"])',
+    'button:not([disabled]):not([tabindex^="-"])',
+    'iframe:not([tabindex^="-"])',
+    'audio[controls]:not([tabindex^="-"])',
+    'video[controls]:not([tabindex^="-"])',
+    '[contenteditable]:not([tabindex^="-"])',
+    '[tabindex]:not([tabindex^="-"])',
+].join(", ");
+export const getFocusableElements = (rootNode = document.documentElement, includeRoot = true) => {
+    return (includeRoot && rootNode.matches(FOCUSABLE_SELECTOR) ? [rootNode] : []).concat(Array.from(rootNode.querySelectorAll(FOCUSABLE_SELECTOR)));
+};

package/src/utils/array.d.ts

@@ -0,0 +1,6 @@
+export declare const sortBy: <K extends string, T extends Record<K, unknown>>(array: T[], keys: K[]) => T[];
+export declare const first: <T>(array: readonly T[]) => T | undefined;
+export declare const last: <T>(array: readonly T[]) => T | undefined;
+export declare const partition: <T>(array: T[], predicate: (value: T) => boolean) => [T[], T[]];
+export declare const sortedIndexOf: <T>(array: T[], value: T) => number;
+export declare const groupBy: <T, K extends string>(array: T[], getGroupName: (item: T) => K) => Partial<Record<K, T[]>>;

package/src/utils/array.js

@@ -0,0 +1,71 @@
+export const sortBy = (array, keys) => {
+    return [...array].sort((a, b) => {
+        let index = -1;
+        while (++index < keys.length) {
+            const key = keys[index];
+            if (key == undefined) {
+                return 0;
+            }
+            if (b[key] === a[key]) {
+                continue;
+            }
+            return b[key] > a[key] ? -1 : 1;
+        }
+        return 0;
+    });
+};
+export const first = (array) => {
+    return array[0];
+};
+export const last = (array) => {
+    return array[array.length - 1];
+};
+export const partition = (array, predicate) => {
+    const truthy = [];
+    const falsy = [];
+    for (const value of array) {
+        if (predicate(value)) {
+            truthy.push(value);
+        }
+        else {
+            falsy.push(value);
+        }
+    }
+    return [truthy, falsy];
+};
+export const sortedIndexOf = (array, value) => {
+    let startIndex = 0;
+    let endIndex = array.length;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const searchIndex = startIndex + Math.round((endIndex - startIndex) / 2);
+        const item = array[searchIndex];
+        if (searchIndex === endIndex || searchIndex === startIndex) {
+            if (item === value) {
+                return startIndex;
+            }
+            return -1;
+        }
+        if (item === value) {
+            return searchIndex;
+        }
+        if (typeof item === "number") {
+            if (item > value) {
+                endIndex = searchIndex;
+                continue;
+            }
+            if (item < value) {
+                startIndex = searchIndex;
+                continue;
+            }
+        }
+    }
+};
+export const groupBy = (array, getGroupName) => {
+    const grouped = {};
+    array.forEach(item => {
+        const groupName = getGroupName(item);
+        grouped[groupName] = [...(grouped[groupName] ?? []), item];
+    });
+    return grouped;
+};

package/src/utils/base64.d.ts

@@ -0,0 +1,2 @@
+export declare const encodeBase64: (value: string) => string;
+export declare const decodeBase64: (base64: string) => string;

package/src/utils/base64.js

@@ -0,0 +1,20 @@
+// Extracted from https://github.com/dankogai/js-base64
+// Compared to atob / btoa, these functions are safe with non-Latin1 characters
+const decodeUTF8 = TextDecoder.prototype.decode.bind(new TextDecoder());
+const encodeUTF8 = TextEncoder.prototype.encode.bind(new TextEncoder());
+const u8From = Uint8Array.from.bind(Uint8Array);
+const fromCharCode = String.fromCharCode.bind(String);
+export const encodeBase64 = (value) => {
+    const u8 = encodeUTF8(value);
+    // cf. https://stackoverflow.com/questions/12710001/how-to-convert-uint8-array-to-base64-encoded-string/12713326#12713326
+    const maxArgs = 0x1000;
+    const data = [];
+    for (let index = 0; index < u8.length; index += maxArgs) {
+        data.push(fromCharCode(...u8.subarray(index, index + maxArgs)));
+    }
+    return btoa(data.join(""));
+};
+const unURI = (base64) => base64
+    .replace(/[-_]/g, substring => (substring == "-" ? "+" : "/"))
+    .replace(/[^A-Za-z0-9+/]/g, "");
+export const decodeBase64 = (base64) => decodeUTF8(u8From(atob(unURI(base64)), value => value.charCodeAt(0)));

package/src/utils/file.d.ts

@@ -0,0 +1,2 @@
+import type { IconName } from "../components/Icon";
+export declare const getIconNameFromFilename: (filename: string) => IconName;

package/src/utils/file.js

@@ -0,0 +1,10 @@
+import { match } from "ts-pattern";
+export const getIconNameFromFilename = (filename) => {
+    const ext = filename.split(".").pop()?.toLowerCase();
+    return match(ext)
+        .with("png", () => "lake-document-png")
+        .with("xls", () => "lake-document-xls")
+        .with("pdf", () => "lake-document-pdf")
+        .with("jpg", () => "lake-document-jpg")
+        .otherwise(() => "document-regular");
+};

package/src/utils/flagCountry.d.ts

@@ -0,0 +1 @@
+export declare const getFlagGlyphName: (flag: string) => string;

package/src/utils/flagCountry.js

@@ -0,0 +1 @@
+export const getFlagGlyphName = (flag) => `${flag.codePointAt(0)?.toString(16) ?? ""}-${flag.codePointAt(2)?.toString(16) ?? ""}`;

package/src/utils/function.d.ts

@@ -0,0 +1,4 @@
+export declare const stubTrue: () => true;
+export declare const identity: <T>(value: T) => T;
+export declare const noop: () => void;
+export declare const memoize: <Input extends unknown[], Output>(func: (...input: Input) => Output, getCacheKey: (...input: Input) => string) => (...input: Input) => Output;

package/src/utils/function.js

@@ -0,0 +1,19 @@
+export const stubTrue = () => {
+    return true;
+};
+export const identity = (value) => {
+    return value;
+};
+export const noop = () => { };
+export const memoize = (func, getCacheKey) => {
+    const cache = new Map();
+    return (...input) => {
+        const key = getCacheKey(...input);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const output = func(...input);
+        cache.set(key, output);
+        return output;
+    };
+};

package/src/utils/math.d.ts

@@ -0,0 +1,16 @@
+type InterpolateTuple = [number, number, ...number[]];
+type FixedLength<L extends number> = number[] & {
+    0: number;
+    length: L;
+};
+type InterpolateParams<T extends InterpolateTuple> = {
+    inputRange: T;
+    outputRange: FixedLength<T["length"]>;
+    clamp?: boolean;
+};
+/**
+ * This function is similar to `Animated.interpolate` except this one can be used with numbers
+ * Whereas `Animated.interpolate` works only with animated values and return a listener, not a single value
+ */
+export declare const interpolate: <T extends InterpolateTuple>({ inputRange: input, outputRange: output, clamp, }: InterpolateParams<T>) => (value: number) => number;
+export {};

package/src/utils/math.js

@@ -0,0 +1,47 @@
+import { isNotNullish, isNullish } from "./nullish";
+const getValue = (array, index, name) => {
+    const value = array[index];
+    if (isNullish(value)) {
+        throw new Error(`Interpolation Error: index "${index}" doesn't exists in ${name}`);
+    }
+    return value;
+};
+const clampValue = (min, max) => (value) => Math.max(Math.min(value, max), min);
+// Here we can disable no-non-null-assertion because this function is called in interpolate which have types checking if there is at least 2 values in range
+const getRangeIndexes = (range, value) => {
+    if (value < range[0]) {
+        return [0, 1];
+    }
+    const maxIndex = range.length - 1;
+    for (let i = 0; i <= maxIndex; i += 1) {
+        const nextIndex = i + 1;
+        const startRange = getValue(range, i, "range");
+        const endRange = range[nextIndex];
+        if (isNotNullish(endRange) && value > startRange && value < endRange) {
+            return [i, nextIndex];
+        }
+    }
+    // if no values was found, it means value is upper than last range value
+    return [maxIndex - 1, maxIndex];
+};
+/**
+ * This function is similar to `Animated.interpolate` except this one can be used with numbers
+ * Whereas `Animated.interpolate` works only with animated values and return a listener, not a single value
+ */
+export const interpolate = ({ inputRange: input, outputRange: output, clamp = true, }) => {
+    return (value) => {
+        const [startIndex, endIndex] = getRangeIndexes(input, value);
+        const inputStart = getValue(input, startIndex, "inputRange");
+        const inputEnd = getValue(input, endIndex, "inputRange");
+        const lastInput = getValue(input, input.length - 1, "inputRange");
+        const outputStart = getValue(output, startIndex, "outputRange");
+        const outputEnd = getValue(output, endIndex, "outputRange");
+        const inputRange = inputEnd - inputStart;
+        const outputRange = outputEnd - outputStart;
+        const valueToConvert = clamp ? clampValue(input[0], lastInput)(value) : value;
+        const valueWithoutOffset = valueToConvert - inputStart;
+        const outputWithoutOffset = (outputRange * valueWithoutOffset) / inputRange;
+        const outputValue = outputWithoutOffset + outputStart;
+        return outputValue;
+    };
+};

package/src/utils/nullish.d.ts

@@ -0,0 +1,10 @@
+type Nullish = null | undefined;
+export declare const isNullish: (value: unknown) => value is Nullish;
+export declare const isNotNullish: <T>(value: Nullish | T) => value is T;
+export declare const isEmpty: (value: unknown) => value is "";
+export declare const isNotEmpty: <T extends string>(value: T) => value is Exclude<T, "">;
+export declare const isNullishOrEmpty: (value: unknown) => value is "" | Nullish;
+export declare const isNotNullishOrEmpty: <T extends string>(value: Nullish | T) => value is Exclude<T, "">;
+export declare const emptyToUndefined: <T extends string>(value: T) => Exclude<T, ""> | undefined;
+export declare const nullishOrEmptyToUndefined: <T extends string>(value: Nullish | T) => Exclude<T, ""> | undefined;
+export {};

package/src/utils/nullish.js

@@ -0,0 +1,8 @@
+export const isNullish = (value) => value == null;
+export const isNotNullish = (value) => value != null;
+export const isEmpty = (value) => value === "";
+export const isNotEmpty = (value) => value !== "";
+export const isNullishOrEmpty = (value) => value == null || value === "";
+export const isNotNullishOrEmpty = (value) => value != null && value !== "";
+export const emptyToUndefined = (value) => isNotEmpty(value) ? value : undefined;
+export const nullishOrEmptyToUndefined = (value) => isNotNullishOrEmpty(value) ? value : undefined;

package/src/utils/object.d.ts

@@ -0,0 +1,2 @@
+export declare const isPlainObject: (value: unknown) => boolean;
+export declare const pick: <T extends Record<K, unknown>, K extends keyof T>(object: T, keys: K[]) => Pick<T, K>;

package/src/utils/object.js

@@ -0,0 +1,7 @@
+export const isPlainObject = (value) => {
+    return Object.prototype.toString.call(value) === "[object Object]";
+};
+export const pick = (object, keys) => {
+    const allowedKeys = new Set(keys);
+    return Object.fromEntries(Object.entries(object).filter(([key]) => allowedKeys.has(key)));
+};

package/src/utils/popper.d.ts

@@ -0,0 +1,3 @@
+import { Modifier } from "react-popper";
+export declare const getRootElement: (element: Element | null) => Element | null;
+export declare const matchReferenceWidthModifier: Modifier<"matchReferenceWidth">;