@uxf/core 11.89.0 → 11.90.0

package/README.md

@@ -422,6 +422,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.90.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/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());
+});