@uxf/core 11.90.0 → 11.93.0

package/README.md

@@ -343,6 +343,26 @@ formatBytes(17.5 * 1024);
 //=> "17.5 kB"
 ```
 
+## inArray
+
+Type-safe helper for checking if a value exists in an array. Particularly useful with `as const` arrays where the value type is wider than the array element type.
+
+```tsx
+import { inArray } from "@uxf/core/utils/in-array";
+
+// Basic usage
+inArray("a", ["a", "b", "c"]); /* returns true */
+inArray("d", ["a", "b", "c"]); /* returns false */
+
+// Useful with const arrays and wider value types
+const statuses = ["pending", "active", "completed"] as const;
+const status: string = getStatusFromApi();
+
+if (inArray(status, statuses)) {
+    // status is now narrowed to the array values
+}
+```
+
 ## isEmpty
 
 ```tsx
@@ -509,6 +529,28 @@ numberOrNull(null);       /* returns null */
 numberOrNull(undefined);  /* returns null */
 ```
 
+## plural
+
+Simple pluralization function for a specific language and set of terms.
+
+```tsx
+import { createPlural } from "@uxf/core/utils/plural";
+
+const terms = {
+    items: {
+        one: "položka",
+        few: "položky",
+        other: "položek",
+    },
+};
+
+const t = createPlural(terms, "cs");
+
+t("items", 1); // returns "položka"
+t("items", 3); // returns "položky"
+t("items", 5); // returns "položek"
+```
+
 ## slugify
 
 ```tsx

package/package.json

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

package/utils/in-array.d.ts

@@ -0,0 +1 @@
+export declare function inArray<Value, Array extends Value>(value: Value, array: readonly Array[]): boolean;

package/utils/in-array.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inArray = inArray;
+function inArray(value, array) {
+    return array.includes(value);
+}

package/utils/in-array.test.d.ts

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

package/utils/in-array.test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const in_array_1 = require("./in-array");
+test("in-array", () => {
+    expect((0, in_array_1.inArray)("a", ["a", "b", "c"])).toBeTruthy();
+    expect((0, in_array_1.inArray)("b", ["a", "b", "c"])).toBeTruthy();
+    expect((0, in_array_1.inArray)("c", ["a", "b", "c"])).toBeTruthy();
+    expect((0, in_array_1.inArray)("d", ["a", "b", "c"])).toBeFalsy();
+    expect((0, in_array_1.inArray)(1, [1, 2, 3])).toBeTruthy();
+    expect((0, in_array_1.inArray)(4, [1, 2, 3])).toBeFalsy();
+    expect((0, in_array_1.inArray)("value", [])).toBeFalsy();
+});
+test("in-array with const array", () => {
+    const statuses = ["pending", "active", "completed"];
+    const status = "active";
+    expect((0, in_array_1.inArray)(status, statuses)).toBeTruthy();
+    const unknownStatus = "unknown";
+    expect((0, in_array_1.inArray)(unknownStatus, statuses)).toBeFalsy();
+});

package/utils/plural.d.ts

@@ -0,0 +1,10 @@
+export interface PluralOptions {
+    zero?: string;
+    one?: string;
+    two?: string;
+    few?: string;
+    many?: string;
+    other: string;
+}
+export type PluralTerms<T extends string> = Record<T, PluralOptions>;
+export declare function createPlural<T extends string>(terms: PluralTerms<T>, locale: string): (key: T, count: number) => string;

package/utils/plural.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPlural = createPlural;
+function plural(count, options, locale) {
+    var _a;
+    const rules = new Intl.PluralRules(locale);
+    const category = rules.select(count);
+    return (_a = options[category]) !== null && _a !== void 0 ? _a : options.other;
+}
+function createPlural(terms, locale) {
+    return (key, count) => {
+        const options = terms[key];
+        return plural(count, options, locale);
+    };
+}

package/utils/plural.test.d.ts

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

package/utils/plural.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plural_1 = require("./plural");
+describe("pluralization", () => {
+    describe("createPlural", () => {
+        test("creates a typed plural function", () => {
+            const terms = {
+                items: {
+                    one: "item",
+                    other: "items",
+                },
+                apples: {
+                    one: "apple",
+                    other: "apples",
+                },
+            };
+            const t = (0, plural_1.createPlural)(terms, "en");
+            expect(t("items", 1)).toBe("item");
+            expect(t("items", 5)).toBe("items");
+            expect(t("apples", 1)).toBe("apple");
+            expect(t("apples", 10)).toBe("apples");
+        });
+        test("works with czech terms", () => {
+            const terms = {
+                items: {
+                    one: "položka",
+                    few: "položky",
+                    other: "položek",
+                },
+            };
+            const t = (0, plural_1.createPlural)(terms, "cs");
+            expect(t("items", 1)).toBe("položka");
+            expect(t("items", 3)).toBe("položky");
+            expect(t("items", 5)).toBe("položek");
+        });
+    });
+});