@uxf/core 11.89.0 → 11.91.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
@@ -422,6 +442,27 @@ isNotNil([]);        /* returns true */
 isNotNil("string");  /* returns true */
 ```
 
+## isPlainObject
+
+Type guard that checks if a value is a plain object. Returns `false` for arrays, `null`, `Date`, `Map`, `Set`, `RegExp`, and other non-plain-object types.
+
+```tsx
+import { isPlainObject } from "@uxf/core/utils/is-plain-object";
+
+isPlainObject({});           /* returns true */
+isPlainObject({ a: 1 });     /* returns true */
+isPlainObject([]);           /* returns false */
+isPlainObject([1, 2, 3]);    /* returns false */
+isPlainObject(new Date());   /* returns false */
+isPlainObject(new Map());    /* returns false */
+isPlainObject(new Set());    /* returns false */
+isPlainObject(/regex/);      /* returns false */
+isPlainObject(null);         /* returns false */
+isPlainObject(undefined);    /* returns false */
+isPlainObject("string");     /* returns false */
+isPlainObject(123);          /* returns false */
+```
+
 ## last
 
 ```tsx

package/package.json

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

package/types/index.d.ts

@@ -1,6 +1,7 @@
 export type Nullish = null | undefined;
 export type Noop = () => void;
 export type AnyObject = Partial<Record<string, any>>;
+export type UnknownObject = Partial<Record<string, unknown>>;
 export type AnyJSON = any;
 export interface FileResponse {
     id: number;

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/is-plain-object.d.ts

@@ -0,0 +1,2 @@
+import { UnknownObject } from "../types";
+export declare function isPlainObject(value: unknown): value is UnknownObject;

package/utils/is-plain-object.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlainObject = isPlainObject;
+function isPlainObject(value) {
+    var _a;
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    if (Object.prototype.toString.call(value) !== "[object Object]") {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null) {
+        return true;
+    }
+    // Handle cross-realm objects by checking if proto's constructor is named "Object"
+    return ((_a = proto.constructor) === null || _a === void 0 ? void 0 : _a.name) === "Object";
+}

package/utils/is-plain-object.test.d.ts

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

package/utils/is-plain-object.test.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_plain_object_1 = require("./is-plain-object");
+test("is-plain-object", () => {
+    [{}, { a: 1 }, Object.create(null)].map((value) => expect((0, is_plain_object_1.isPlainObject)(value)).toBeTruthy());
+    const emptyFn = () => undefined;
+    [
+        null,
+        undefined,
+        "",
+        "string",
+        0,
+        1,
+        true,
+        false,
+        NaN,
+        Infinity,
+        Symbol("test"),
+        emptyFn,
+        [],
+        [1, 2, 3],
+        new Date(),
+        new Map(),
+        new Set(),
+        /regex/,
+    ].map((value) => expect((0, is_plain_object_1.isPlainObject)(value)).toBeFalsy());
+});