@uxf/core 11.45.0 → 11.46.0

package/cookie/cookie.test.d.ts

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

package/cookie/cookie.test.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+describe("Cookie Class", () => {
+    const cookieName = "testCookie";
+    const cookieValue = "testValue";
+    let cookie;
+    beforeEach(() => {
+        cookie = new index_1.Cookie({
+            res: {
+                setHeader: jest.fn(),
+                getHeader: jest.fn().mockReturnValue([]),
+            },
+            req: {
+                headers: {
+                    cookie: "",
+                },
+            },
+        });
+    });
+    it("should create a new Cookie instance without context", () => {
+        const cookieInstance = index_1.Cookie.create();
+        expect(cookieInstance).toBeInstanceOf(index_1.Cookie);
+        // eslint-disable-next-line dot-notation
+        expect(cookieInstance["ctx"]).toBeNull();
+    });
+    it("should create a new Cookie instance with context", () => {
+        const mockContext = { req: {}, res: {} };
+        const cookieInstance = index_1.Cookie.create(mockContext);
+        expect(cookieInstance).toBeInstanceOf(index_1.Cookie);
+        // eslint-disable-next-line dot-notation
+        expect(cookieInstance["ctx"]).toEqual(mockContext);
+    });
+    it("should set a cookie correctly", () => {
+        cookie.set(cookieName, cookieValue);
+        expect(document.cookie).toContain(`${cookieName}=${encodeURIComponent(cookieValue)}`);
+    });
+    it("should get a cookie value correctly", () => {
+        Object.defineProperty(document, "cookie", {
+            writable: true,
+            value: `${cookieName}=${encodeURIComponent(cookieValue)};`,
+        });
+        const result = cookie.get(cookieName);
+        expect(result).toBe(cookieValue);
+    });
+    it("should return an empty string if the cookie does not exist", () => {
+        const result = cookie.get("nonExistentCookie");
+        expect(result).toBe("");
+    });
+    it("should check if a cookie exists", () => {
+        Object.defineProperty(document, "cookie", {
+            writable: true,
+            value: `${cookieName}=${encodeURIComponent(cookieValue)};`,
+        });
+        const hasCookie = cookie.has(cookieName);
+        expect(hasCookie).toBe(true);
+    });
+    it("should return false if the cookie does not exist", () => {
+        const hasCookie = cookie.has("nonExistentCookie");
+        expect(hasCookie).toBe(false);
+    });
+    it("should delete a cookie", () => {
+        cookie.set(cookieName, cookieValue, 3600);
+        expect(cookie.has(cookieName)).toBe(true);
+        cookie.delete(cookieName);
+        expect(cookie.has(cookieName)).toBe(false);
+    });
+});

package/next/query-param.test.d.ts

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

package/next/query-param.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+describe("queryParamToString", () => {
+    it("should return the string when a string is passed", () => {
+        const result = (0, index_1.queryParamToString)("test");
+        expect(result).toBe("test");
+    });
+    it("should return an empty string when undefined is passed", () => {
+        const result = (0, index_1.queryParamToString)(undefined);
+        expect(result).toBe("");
+    });
+    it("should return an empty string when an array is passed", () => {
+        const result = (0, index_1.queryParamToString)(["test", "jest"]);
+        expect(result).toBe("");
+    });
+});
+describe("queryParamToNumber", () => {
+    it("should return the number when a valid string is passed", () => {
+        const result = (0, index_1.queryParamToNumber)("42");
+        expect(result).toBe(42);
+    });
+    it("should return 0 when undefined is passed", () => {
+        const result = (0, index_1.queryParamToNumber)(undefined);
+        expect(result).toBe(0);
+    });
+    it("should return 0 when an array is passed", () => {
+        const result = (0, index_1.queryParamToNumber)(["42", "8"]);
+        expect(result).toBe(0);
+    });
+    it("should return NaN when an invalid number string is passed", () => {
+        const result = (0, index_1.queryParamToNumber)("not a number");
+        expect(result).toBe(NaN);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/core",
-    "version": "11.45.0",
+    "version": "11.46.0",
     "description": "UXF Core",
     "author": "Petr Vejvoda <vejvoda@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/core#readme",

package/utils/assert-not-nil.test.d.ts

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

package/utils/assert-not-nil.test.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_not_nil_1 = require("./assert-not-nil");
+test("assert-not-nil", () => {
+    expect(() => (0, assert_not_nil_1.assertNotNil)(null)).toThrow("Value is nil.");
+    expect(() => (0, assert_not_nil_1.assertNotNil)(undefined, "Test")).toThrow("Test");
+    ["", true, false, NaN, 0, [], {}].map((value) => expect(() => (0, assert_not_nil_1.assertNotNil)(value)).not.toThrow("Value is nil."));
+});

package/utils/copy-to-clipboard.test.d.ts

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

package/utils/copy-to-clipboard.test.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const copy_to_clipboard_1 = require("./copy-to-clipboard");
+describe("Clipboard Functions", () => {
+    beforeEach(() => {
+        document.execCommand = jest.fn();
+        Object.defineProperty(navigator, "clipboard", {
+            value: {
+                writeText: jest.fn(),
+            },
+            writable: true,
+        });
+    });
+    it("should copy text using navigator.clipboard when supported", async () => {
+        const text = "Hello, World!";
+        const result = await (0, copy_to_clipboard_1.copyToClipboard)(text);
+        expect(navigator.clipboard.writeText).toHaveBeenCalledWith(text);
+        expect(result).toBe(true);
+    });
+    it("should return false when clipboard.writeText throws an error during fallback", async () => {
+        navigator.clipboard.writeText = jest.fn().mockRejectedValue(new Error("Clipboard API not supported"));
+        document.execCommand = jest.fn().mockImplementation(() => {
+            throw new Error("Copy failed");
+        });
+        const consoleErrorMock = jest.spyOn(console, "error").mockImplementation(() => ({}));
+        const result = await (0, copy_to_clipboard_1.copyToClipboard)("Hello, World!");
+        expect(result).toBe(false);
+        consoleErrorMock.mockRestore();
+    });
+});

package/utils/file.test.d.ts

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

package/utils/file.test.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_1 = require("./file");
+test("file", () => {
+    expect((0, file_1.getFileUrl)({
+        uuid: "",
+        namespace: undefined,
+        extension: "",
+    })).toBe("/upload///.");
+    expect((0, file_1.getFileUrl)({
+        uuid: "",
+        namespace: undefined,
+        extension: "extension",
+    })).toBe("/upload///.extension");
+    expect((0, file_1.getFileUrl)({
+        uuid: "",
+        namespace: "namespace",
+        extension: "extension",
+    })).toBe("/upload/namespace///.extension");
+    expect((0, file_1.getFileUrl)({
+        uuid: "uuid",
+        namespace: null,
+        extension: "extension",
+    })).toBe("/upload/u/u/uuid.extension");
+    expect((0, file_1.getFileUrl)({
+        uuid: "u",
+        namespace: undefined,
+        extension: "",
+    })).toBe("/upload/u//u.");
+    expect((0, file_1.getFileUrl)({
+        uuid: "uuid",
+        namespace: "namespace",
+        extension: "extension",
+    })).toBe("/upload/namespace/u/u/uuid.extension");
+});

package/utils/filter-nullish.test.d.ts

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

package/utils/filter-nullish.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_nullish_1 = require("./filter-nullish");
+test("filter-nullish", () => {
+    expect((0, filter_nullish_1.filterNullish)([undefined, null, 0, NaN, "", true, false, [], {}])).toStrictEqual([
+        0,
+        NaN,
+        "",
+        true,
+        false,
+        [],
+        {},
+    ]);
+    expect((0, filter_nullish_1.filterNullish)([])).toStrictEqual([]);
+});

package/utils/is-empty.d.ts

@@ -1 +1,3 @@
-export declare function isEmpty(value: any[] | string): boolean;
+export declare function isEmpty(value: any[] | {
+    [key: string]: any;
+} | string): boolean;

package/utils/is-empty.js

@@ -5,5 +5,8 @@ function isEmpty(value) {
     if (Array.isArray(value)) {
         return value.length === 0;
     }
+    else if (value && typeof value === "object") {
+        return Object.keys(value).length === 0;
+    }
     return value === "";
 }

package/utils/is-empty.test.js

@@ -1,9 +1,10 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unnecessary-condition,@typescript-eslint/ban-ts-comment */
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_empty_1 = require("./is-empty");
 test("is-empty", () => {
-    expect((0, is_empty_1.isEmpty)(["1"])).toBeFalsy();
-    expect((0, is_empty_1.isEmpty)([])).toBeTruthy();
-    expect((0, is_empty_1.isEmpty)("not-empty")).toBeFalsy();
-    expect((0, is_empty_1.isEmpty)("")).toBeTruthy();
+    [["1"], { not: "empty" }, "not-empty"].map((value) => expect((0, is_empty_1.isEmpty)(value)).toBeFalsy());
+    [[], {}, ""].map((value) => expect((0, is_empty_1.isEmpty)(value)).toBeTruthy());
+    // @ts-expect-error
+    [0, null, undefined, true, false].map((value) => expect((0, is_empty_1.isEmpty)(value)).toBeFalsy());
 });

package/utils/is-nil.test.d.ts

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

package/utils/is-nil.test.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_nil_1 = require("./is-nil");
+test("is-nil", () => {
+    [null, undefined].map((value) => expect((0, is_nil_1.isNil)(value)).toBeTruthy());
+    ["", true, false, NaN, 0, [], {}].map((value) => expect((0, is_nil_1.isNil)(value)).toBeFalsy());
+});

package/utils/is-not-empty.d.ts

@@ -1 +1,3 @@
-export declare function isNotEmpty(value: any[] | string): boolean;
+export declare function isNotEmpty(value: any[] | {
+    [key: string]: any;
+} | string): boolean;

package/utils/is-not-empty.test.js

@@ -1,9 +1,10 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unnecessary-condition,@typescript-eslint/ban-ts-comment */
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_not_empty_1 = require("./is-not-empty");
 test("is-not-empty", () => {
-    expect((0, is_not_empty_1.isNotEmpty)(["1"])).toBeTruthy();
-    expect((0, is_not_empty_1.isNotEmpty)([])).toBeFalsy();
-    expect((0, is_not_empty_1.isNotEmpty)("not-empty")).toBeTruthy();
-    expect((0, is_not_empty_1.isNotEmpty)("")).toBeFalsy();
+    [["1"], { not: "empty" }, "not-empty"].map((value) => expect((0, is_not_empty_1.isNotEmpty)(value)).toBeTruthy());
+    [[], {}, ""].map((value) => expect((0, is_not_empty_1.isNotEmpty)(value)).toBeFalsy());
+    // @ts-expect-error
+    [0, null, undefined, true, false].map((value) => expect((0, is_not_empty_1.isNotEmpty)(value)).toBeTruthy());
 });

package/utils/is-not-nil.test.d.ts

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

package/utils/is-not-nil.test.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_not_nil_1 = require("./is-not-nil");
+test("is-not-nil", () => {
+    ["", true, false, NaN, 0, [], {}].map((value) => expect((0, is_not_nil_1.isNotNil)(value)).toBeTruthy());
+    [null, undefined].map((value) => expect((0, is_not_nil_1.isNotNil)(value)).toBeFalsy());
+});

package/utils/isBrowser.test.d.ts

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

package/utils/isBrowser.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isBrowser_1 = require("./isBrowser");
+test("isBrowser", () => {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (window === undefined) {
+        expect(isBrowser_1.isBrowser).toBeFalsy();
+    }
+    else {
+        expect(isBrowser_1.isBrowser).toBeTruthy();
+    }
+});

package/utils/isServer.test.d.ts

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

package/utils/isServer.test.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isBrowser_1 = require("./isBrowser");
+const isServer_1 = require("./isServer");
+test("isServer", () => {
+    if (isBrowser_1.isBrowser) {
+        expect(isServer_1.isServer).toBeFalsy();
+    }
+    else {
+        expect(isServer_1.isServer).toBeTruthy();
+    }
+});

package/utils/noop.test.d.ts

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

package/utils/noop.test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const noop_1 = require("./noop");
+describe("noop function", () => {
+    it("should return undefined when called", () => {
+        const result = (0, noop_1.noop)();
+        expect(result).toBeUndefined();
+    });
+    it("should not call any other function", () => {
+        const spy = jest.fn();
+        spy();
+        expect(spy).toHaveBeenCalled();
+        expect((0, noop_1.noop)()).toBeUndefined();
+    });
+});

package/utils/resizer.d.ts

@@ -12,14 +12,14 @@ export type StaticImageData = {
     blurDataURL?: string;
 };
 export type ImageSource = ImageResponse | StaticImageData | string;
-declare const fitMapper: {
+export declare const fitMapper: {
     cover: string;
     fill: string;
     contain: string;
     inside: string;
     outside: string;
 };
-declare const positionMapper: {
+export declare const positionMapper: {
     attention: string;
     bottom: string;
     centre: string;

package/utils/resizer.js

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resizerImageUrl = void 0;
+exports.resizerImageUrl = exports.positionMapper = exports.fitMapper = void 0;
 exports.resizerGetDefaultConfig = resizerGetDefaultConfig;
-const fitMapper = {
+exports.fitMapper = {
     cover: "cv",
     fill: "f",
     contain: "cn",
     inside: "in",
     outside: "out",
 };
-const positionMapper = {
+exports.positionMapper = {
     attention: "a",
     bottom: "b",
     centre: "c",
@@ -39,8 +39,8 @@ const resizerStaticImageUrl = (src, width = "auto", height = "auto", props = {},
     const directory = [
         width === "auto" ? "x" : width,
         height === "auto" ? "x" : height,
-        fitMapper[fit],
-        positionMapper[position],
+        exports.fitMapper[fit],
+        exports.positionMapper[position],
         background === "transparent" ? backgroundMapper[background] : background,
         trim === "not-trim" ? trimMapper[trim] : trim,
         (_a = props.quality) !== null && _a !== void 0 ? _a : "x",
@@ -60,8 +60,8 @@ const resizerImageUrl = (source, width = "auto", height = "auto", props = {}, ve
         source.uuid,
         width === "auto" ? "x" : width,
         height === "auto" ? "x" : height,
-        fitMapper[fit],
-        positionMapper[position],
+        exports.fitMapper[fit],
+        exports.positionMapper[position],
         background === "transparent" ? backgroundMapper[background] : background,
         trim === "not-trim" ? trimMapper[trim] : trim,
         (_b = props.quality) !== null && _b !== void 0 ? _b : "x",

package/utils/resizer.test.d.ts

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

package/utils/resizer.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resizer_1 = require("./resizer");
+describe("resizerGetDefaultConfig", () => {
+    it("should return a valid URL for a StaticImageData source", () => {
+        const staticImage = {
+            src: "http://example.com/image.jpg",
+            height: 800,
+            width: 600,
+        };
+        const url = (0, resizer_1.resizerImageUrl)(staticImage, undefined, undefined, {
+            fit: "cover",
+            position: "bottom",
+            background: "transparent",
+            trim: "not-trim",
+            toFormat: "avif",
+            quality: 1,
+        });
+        expect(url).toBe("/generated/static/x_x_cv_b_t_nt_1/1http://example.com/image.jpg.avif");
+    });
+    it("should return a valid URL for an ImageResponse source", () => {
+        const imageResponse = {
+            uuid: "12345678",
+            namespace: "images",
+            extension: "jpg",
+        };
+        const url = (0, resizer_1.resizerImageUrl)(imageResponse, 400, 300, { fit: "contain", quality: 80 });
+        expect(url).toBe("/generated/images/1/2/12345678_400_300_cn_c_FFF_nt_80_jpg.jpg");
+    });
+    it("should return a valid URL for a string source", () => {
+        const url = (0, resizer_1.resizerImageUrl)("http://example.com/image.png", 250, 250, { toFormat: "webp" });
+        expect(url).toBe("/generated/static/250_250_cv_c_FFF_nt_x/1http://example.com/image.png.webp");
+    });
+    it("should return undefined for null or undefined source", () => {
+        expect((0, resizer_1.resizerImageUrl)(null)).toBeUndefined();
+        expect((0, resizer_1.resizerImageUrl)(undefined)).toBeUndefined();
+        expect((0, resizer_1.resizerImageUrl)("")).toBeUndefined();
+    });
+    it("should use default values for missing props", () => {
+        const imageResponse = {
+            uuid: "abcdef12",
+            extension: "png",
+        };
+        const url = (0, resizer_1.resizerImageUrl)(imageResponse);
+        expect(url).toBe("/generated/undefined/a/b/abcdef12_x_x_cv_c_FFF_nt_x_png.png");
+    });
+    it("should map fit values correctly", () => {
+        const imageResponse = {
+            uuid: "fit-test",
+            namespace: "images",
+            extension: "jpg",
+        };
+        Object.entries(resizer_1.fitMapper).forEach(([key, value]) => {
+            const url = (0, resizer_1.resizerImageUrl)(imageResponse, 300, 200, { fit: key });
+            expect(url).toContain(`_${value}`);
+        });
+    });
+    it("should map position values correctly", () => {
+        const imageResponse = {
+            uuid: "position-test",
+            namespace: "images",
+            extension: "jpg",
+        };
+        Object.entries(resizer_1.positionMapper).forEach(([key, value]) => {
+            const url = (0, resizer_1.resizerImageUrl)(imageResponse, 300, 200, { position: key });
+            expect(url).toContain(`_${value}`);
+        });
+    });
+    it("should return the default configuration based on generatedFilesUrl and staticFilesUrl", () => {
+        const generatedFilesUrl = "http://example.com/generated";
+        const staticFilesUrl = "http://example.com/static";
+        const expectedConfig = [
+            {
+                route: "/generated/static/:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)/:version/:filename(*).:extension.:toFormat",
+                source: `${staticFilesUrl}/:filename+.:extension`,
+            },
+            {
+                route: "/generated/:namespace/:p1/:p2/:filename([a-f0-9\\-]+)_:width(\\d+|x)_:height(\\d+|x)_:fit([a-z]+)_:position([a-z]+)_:background([a-z]+)_:trim([a-z]+)_:quality(\\d+|x)_:extension.:toFormat",
+                source: `${generatedFilesUrl}/upload/:namespace/:p1/:p2/:filename.:extension`,
+            },
+        ];
+        const result = (0, resizer_1.resizerGetDefaultConfig)(generatedFilesUrl, staticFilesUrl);
+        expect(result).toEqual(expectedConfig);
+    });
+});

package/utils/slugify.test.js

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const slugify_1 = require("./slugify");
 test("slugify", () => {
-    expect((0, slugify_1.slugify)("Nějaký název")).toBe("nejaky-nazev");
-    expect((0, slugify_1.slugify)("8 hrozných")).toBe("8-hroznych");
-    expect((0, slugify_1.slugify)("Osm hrozných")).toBe("osm-hroznych");
+    expect((0, slugify_1.slugify)("   Osm   hrozných   ")).toBe("osm-hroznych");
+    expect((0, slugify_1.slugify)("Osm & hrozných")).toBe("osm-and-hroznych");
+    expect((0, slugify_1.slugify)("osm---hroznych")).toBe("osm-hroznych");
+    expect((0, slugify_1.slugify)("Osm hrozných.")).toBe("osm-hroznych");
+    expect((0, slugify_1.slugify)("àáäâãåăæąçćčđďèéěėëêęǵḧìíïîįłḿǹńňñòóöôœøṕŕřßśšșťțùúüûǘůűūųẃẍÿýźžż·/_,:;")).toBe("aaaaaaaaacccddeeeeeeeghiiiiilmnnnnooooooprrssssttuuuuuuuuuwxyyzzz");
 });

package/utils/sort-object-keys.test.d.ts

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

package/utils/sort-object-keys.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sort_object_keys_1 = require("./sort-object-keys");
+describe("sortObjectKeys", () => {
+    it("should sort object keys in alphabetical order", () => {
+        const input = {
+            b: "banana",
+            a: "apple",
+            d: "date",
+            c: "cherry",
+        };
+        const expectedOutput = {
+            a: "apple",
+            b: "banana",
+            c: "cherry",
+            d: "date",
+        };
+        expect((0, sort_object_keys_1.sortObjectKeys)(input)).toEqual(expectedOutput);
+    });
+    it("should sort nested object keys", () => {
+        const input = {
+            b: {
+                d: "date",
+                c: "cherry",
+            },
+            a: "apple",
+            c: "cat",
+        };
+        const expectedOutput = {
+            a: "apple",
+            b: {
+                c: "cherry",
+                d: "date",
+            },
+            c: "cat",
+        };
+        expect((0, sort_object_keys_1.sortObjectKeys)(input)).toEqual(expectedOutput);
+    });
+    it("should handle empty objects", () => {
+        const input = {};
+        const expectedOutput = {};
+        expect((0, sort_object_keys_1.sortObjectKeys)(input)).toEqual(expectedOutput);
+    });
+    it("should handle null values and functions gracefully", () => {
+        const input = { s: 1, b: [], d: {}, c: "string", g: () => "function" };
+        const expectedOutput = {
+            b: {},
+            c: "string",
+            d: {},
+            g: {},
+            s: {},
+        };
+        expect((0, sort_object_keys_1.sortObjectKeys)(input)).toEqual(expect.objectContaining(expectedOutput));
+    });
+    it("should throw an error for object with null and undefined", () => {
+        const input = { a: [null], b: null, c: undefined };
+        expect(() => (0, sort_object_keys_1.sortObjectKeys)(input)).toThrow();
+    });
+    it("should throw an error for non-object types", () => {
+        const inputs = [null, undefined];
+        inputs.forEach((input) => {
+            expect(() => (0, sort_object_keys_1.sortObjectKeys)(input)).toThrow();
+        });
+    });
+});

package/utils/throw-error.test.d.ts

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

package/utils/throw-error.test.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const throw_error_1 = require("./throw-error");
+describe("throwError", () => {
+    it("should throw an error with the provided message", () => {
+        const message = "This is an error message";
+        expect(() => (0, throw_error_1.throwError)(message)).toThrow(Error);
+        expect(() => (0, throw_error_1.throwError)(message)).toThrow(message);
+    });
+    it("should throw an error without a message", () => {
+        expect(() => (0, throw_error_1.throwError)()).toThrow(Error);
+        expect(() => (0, throw_error_1.throwError)()).toThrow();
+    });
+});

package/utils/trim-trailing-zeros.test.d.ts

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

package/utils/trim-trailing-zeros.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const trimTrailingZeros_1 = require("./trimTrailingZeros");
+test("trimTrailingZeros", () => {
+    expect((0, trimTrailingZeros_1.trimTrailingZeros)("1.0000")).toBe("1");
+    expect((0, trimTrailingZeros_1.trimTrailingZeros)("1.")).toBe("1.");
+    expect((0, trimTrailingZeros_1.trimTrailingZeros)("0")).toBe("0");
+    expect((0, trimTrailingZeros_1.trimTrailingZeros)("100")).toBe("100");
+    expect((0, trimTrailingZeros_1.trimTrailingZeros)("test .0")).toBe("test ");
+});

package/utils/trimTrailingZeros.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trimTrailingZeros = trimTrailingZeros;
 function trimTrailingZeros(value) {
-    return value.replace(/\.?0+$/, "");
+    return value.includes(".") ? value.replace(/\.?0+$/, "") : value;
 }