@swan-io/lake 14.0.0 → 15.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swan-io/lake",
-  "version": "14.0.0",
+  "version": "15.1.0",
   "engines": {
     "node": ">22.12.0"
   },

package/src/components/LakeText.d.ts

@@ -28,6 +28,7 @@ type Props = TextProps & {
     align?: TextAlign;
     children: ReactNode;
     color?: string;
+    dataSet?: Record<string, unknown>;
     userSelect?: TextStyle["userSelect"];
     variant?: TextVariant;
     tooltip?: Omit<ComponentProps<typeof LakeTooltip>, "children">;

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

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

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

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { getIconNameFromFilename } from "../file";
+describe("getIconNameFromFilename returns the file type icon based on filename", () => {
+    it("returns lake-document-png for a .png file", () => {
+        expect(getIconNameFromFilename("photo.png")).toBe("lake-document-png");
+    });
+    it("returns lake-document-xls for a .xls file", () => {
+        expect(getIconNameFromFilename("sheet.xls")).toBe("lake-document-xls");
+    });
+    it("returns lake-document-pdf for a .pdf file", () => {
+        expect(getIconNameFromFilename("report.pdf")).toBe("lake-document-pdf");
+    });
+    it("returns lake-document-jpg for a .jpg file", () => {
+        expect(getIconNameFromFilename("photo.jpg")).toBe("lake-document-jpg");
+    });
+    it("is case-insensitive on the extension", () => {
+        expect(getIconNameFromFilename("REPORT.PDF")).toBe("lake-document-pdf");
+    });
+    it("uses the last extension when the filename contains multiple dots", () => {
+        expect(getIconNameFromFilename("archive.tar.pdf")).toBe("lake-document-pdf");
+    });
+    it("returns document-regular for an unknown extension", () => {
+        expect(getIconNameFromFilename("notes.txt")).toBe("document-regular");
+    });
+    it("returns document-regular for a filename with no extension", () => {
+        expect(getIconNameFromFilename("README")).toBe("document-regular");
+    });
+    it("returns document-regular for an empty filename", () => {
+        expect(getIconNameFromFilename("")).toBe("document-regular");
+    });
+});

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

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

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

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { filterRejectionsToResult } from "../gql";
+describe("filterRejectionsToResult routes GraphQL union members to Ok or Error based on __typename", () => {
+    it("returns an Error when __typename ends with 'Rejection'", () => {
+        const input = { __typename: "AccountNotFoundRejection", message: "not found" };
+        const result = filterRejectionsToResult(input);
+        expect(result.isError()).toBe(true);
+        expect(result.isError() && result.getError()).toEqual(input);
+    });
+    it("returns an Ok when __typename does not end with 'Rejection'", () => {
+        const input = { __typename: "Account", id: "abc" };
+        const result = filterRejectionsToResult(input);
+        expect(result.isOk()).toBe(true);
+        expect(result.isOk() && result.get()).toEqual(input);
+    });
+    it("treats a __typename of exactly 'Rejection' as an Error", () => {
+        const input = { __typename: "Rejection" };
+        expect(filterRejectionsToResult(input).isError()).toBe(true);
+    });
+    it("does not match __typename that only contains 'Rejection' as a substring", () => {
+        const input = { __typename: "RejectionReason" };
+        expect(filterRejectionsToResult(input).isOk()).toBe(true);
+    });
+    it("treats an empty __typename as an Ok", () => {
+        const input = { __typename: "" };
+        expect(filterRejectionsToResult(input).isOk()).toBe(true);
+    });
+});

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

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

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

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { clampValue } from "../math";
+describe("clampValue restricts a number to a given [min, max] range", () => {
+    it("returns the value unchanged when it lies within the range", () => {
+        expect(clampValue(0, 10)(5)).toBe(5);
+    });
+    it("returns min when the value is below the range", () => {
+        expect(clampValue(0, 10)(-3)).toBe(0);
+    });
+    it("returns max when the value is above the range", () => {
+        expect(clampValue(0, 10)(42)).toBe(10);
+    });
+    it("returns the boundary value when the input equals min", () => {
+        expect(clampValue(0, 10)(0)).toBe(0);
+    });
+    it("returns the boundary value when the input equals max", () => {
+        expect(clampValue(0, 10)(10)).toBe(10);
+    });
+    it("supports negative ranges", () => {
+        expect(clampValue(-10, -5)(-20)).toBe(-10);
+        expect(clampValue(-10, -5)(0)).toBe(-5);
+    });
+});

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

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

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

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { emptyToUndefined, isEmpty, isNotEmpty, isNotNullishOrEmpty, isNullishOrEmpty, nullishOrEmptyToUndefined, } from "../nullish";
+describe("isEmpty", () => {
+    it("returns true for an empty string", () => {
+        expect(isEmpty("")).toBe(true);
+    });
+    it("returns false for a non-empty string", () => {
+        expect(isEmpty("hello")).toBe(false);
+    });
+    it("returns false for a whitespace-only string", () => {
+        expect(isEmpty(" ")).toBe(false);
+    });
+    it("returns false for null", () => {
+        expect(isEmpty(null)).toBe(false);
+    });
+    it("returns false for undefined", () => {
+        expect(isEmpty(undefined)).toBe(false);
+    });
+});
+describe("isNotEmpty", () => {
+    it("returns false for an empty string", () => {
+        expect(isNotEmpty("")).toBe(false);
+    });
+    it("returns true for a non-empty string", () => {
+        expect(isNotEmpty("hello")).toBe(true);
+    });
+    it("returns true for a whitespace-only string", () => {
+        expect(isNotEmpty(" ")).toBe(true);
+    });
+});
+describe("isNullishOrEmpty", () => {
+    it("returns true for null", () => {
+        expect(isNullishOrEmpty(null)).toBe(true);
+    });
+    it("returns true for undefined", () => {
+        expect(isNullishOrEmpty(undefined)).toBe(true);
+    });
+    it("returns true for an empty string", () => {
+        expect(isNullishOrEmpty("")).toBe(true);
+    });
+    it("returns false for a non-empty string", () => {
+        expect(isNullishOrEmpty("hello")).toBe(false);
+    });
+    it("returns false for zero", () => {
+        expect(isNullishOrEmpty(0)).toBe(false);
+    });
+});
+describe("isNotNullishOrEmpty", () => {
+    it("returns false for null", () => {
+        expect(isNotNullishOrEmpty(null)).toBe(false);
+    });
+    it("returns false for undefined", () => {
+        expect(isNotNullishOrEmpty(undefined)).toBe(false);
+    });
+    it("returns false for an empty string", () => {
+        expect(isNotNullishOrEmpty("")).toBe(false);
+    });
+    it("returns true for a non-empty string", () => {
+        expect(isNotNullishOrEmpty("hello")).toBe(true);
+    });
+    it("returns true for a whitespace-only string", () => {
+        expect(isNotNullishOrEmpty(" ")).toBe(true);
+    });
+});
+describe("emptyToUndefined", () => {
+    it("returns undefined for an empty string", () => {
+        expect(emptyToUndefined("")).toBeUndefined();
+    });
+    it("returns the original value for a non-empty string", () => {
+        expect(emptyToUndefined("hello")).toBe("hello");
+    });
+    it("returns a whitespace string unchanged", () => {
+        expect(emptyToUndefined(" ")).toBe(" ");
+    });
+});
+describe("nullishOrEmptyToUndefined", () => {
+    it("returns undefined for null", () => {
+        expect(nullishOrEmptyToUndefined(null)).toBeUndefined();
+    });
+    it("returns undefined for undefined", () => {
+        expect(nullishOrEmptyToUndefined(undefined)).toBeUndefined();
+    });
+    it("returns undefined for an empty string", () => {
+        expect(nullishOrEmptyToUndefined("")).toBeUndefined();
+    });
+    it("returns the original value for a non-empty string", () => {
+        expect(nullishOrEmptyToUndefined("hello")).toBe("hello");
+    });
+});

package/src/utils/math.d.ts

@@ -1,29 +1 @@
-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;
-};
 export declare const clampValue: (min: number, max: number) => (value: number) => number;
-/**
- * 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);
-type ElasticParams = {
-    elasticLength?: number;
-    elasticStrength?: number;
-};
-/**
- * This function takes as input a number from 0 to Infinity and returns a number from 0 to elasticLength
- * With an exponential curve giving a feeling of elasticity
- * This kind of function can be used to:
- *  - recreate effect like scroll bounce on iOS
- *  - limit grab smoothly with touch interaction
- */
-export declare const limitElastic: ({ elasticLength, elasticStrength }: ElasticParams) => (value: number) => number;
-export {};

package/src/utils/math.js

@@ -1,55 +1 @@
-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;
-};
 export 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;
-    };
-};
-/**
- * This function takes as input a number from 0 to Infinity and returns a number from 0 to elasticLength
- * With an exponential curve giving a feeling of elasticity
- * This kind of function can be used to:
- *  - recreate effect like scroll bounce on iOS
- *  - limit grab smoothly with touch interaction
- */
-export const limitElastic = ({ elasticLength = 100, elasticStrength = 0.008 }) => (value) => elasticLength * (1 - Math.exp(-elasticStrength * value));