@uxf/core 11.107.0 → 11.110.0

package/README.md

@@ -258,6 +258,20 @@ cxa("foo", [1 && "bar", { baz:false, bat:null }, ["hello", ["world"]]], "cya");
 //=> "foo bar hello world cya"
 ```
 
+### deepmerge
+
+Re-export of the [deepmerge](https://github.com/TehShrike/deepmerge) library. Recursively merges two or more objects and arrays.
+
+```ts
+import { deepmerge } from "@uxf/core/utils/deepmerge";
+
+const target = { a: 1, b: { x: 10 } };
+const source = { b: { y: 20 }, c: 3 };
+
+deepmerge(target, source);
+/* returns { a: 1, b: { x: 10, y: 20 }, c: 3 } */
+```
+
 ### deepEqualIgnoringKeyOrder
 
 deepEqualIgnoringKeyOrder compares two values for deep equality while ignoring the order of object keys. It serializes values in a stable way, ensuring that objects with the same data but different key orders are treated as equal. Arrays remain order-sensitive, circular references are handled safely, and primitives are compared by value.
@@ -401,6 +415,17 @@ if (inArray(status, statuses)) {
 }
 ```
 
+## isEqual
+
+Re-export of [lodash.isequal](https://lodash.com/docs/#isEqual). Performs a deep comparison between two values to determine if they are equivalent.
+
+```ts
+import isEqual from "@uxf/core/utils/is-equal";
+
+isEqual({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); /* returns true */
+isEqual({ a: 1 }, { a: 2 });                         /* returns false */
+```
+
 ## isEmpty
 
 ```tsx
@@ -480,6 +505,23 @@ isNotNil([]);        /* returns true */
 isNotNil("string");  /* returns true */
 ```
 
+## isNotNilNorEmpty
+
+Type guard that checks if a value is not `null`, not `undefined`, and not empty. Works with strings, arrays, and plain objects.
+
+```tsx
+import { isNotNilNorEmpty } from "@uxf/core/utils/is-not-nil-nor-empty";
+
+isNotNilNorEmpty("not-empty"); /* returns true */
+isNotNilNorEmpty({ not: "empty" }); /* returns true */
+isNotNilNorEmpty(["1"]); /* returns true */
+isNotNilNorEmpty(""); /* returns false */
+isNotNilNorEmpty([]); /* returns false */
+isNotNilNorEmpty({}); /* returns false */
+isNotNilNorEmpty(null); /* returns false */
+isNotNilNorEmpty(undefined); /* returns false */
+```
+
 ## 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.
@@ -589,6 +631,17 @@ t("items", 3); // returns "položky"
 t("items", 5); // returns "položek"
 ```
 
+## qs
+
+Re-export of [qs](https://github.com/ljharb/qs). A querystring parsing and stringifying library.
+
+```ts
+import { stringify, parse } from "@uxf/core/utils/qs";
+
+stringify({ a: "b", c: [1, 2] }); /* returns "a=b&c%5B0%5D=1&c%5B1%5D=2" */
+parse("a=b&c=1");                 /* returns { a: "b", c: "1" } */
+```
+
 ## slugify
 
 ```tsx

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uxf/core",
-    "version": "11.107.0",
+    "version": "11.110.0",
     "description": "UXF Core",
     "author": "Petr Vejvoda <vejvoda@uxf.cz>",
     "homepage": "https://gitlab.com/uxf-npm/core#readme",
@@ -20,6 +20,11 @@
         "typecheck": "tsc --noEmit --skipLibCheck"
     },
     "dependencies": {
+        "@types/lodash.isequal": "4.5.8",
+        "@types/qs": "6.15.0",
+        "deepmerge": "4.3.1",
+        "lodash.isequal": "4.5.0",
+        "qs": "6.15.0",
         "ts-pattern": "5.9.0"
     },
     "bugs": {

package/utils/deepmerge.d.ts

@@ -0,0 +1,2 @@
+export { default as deepmerge } from "deepmerge";
+export type { ArrayMergeOptions, Options } from "deepmerge";

package/utils/deepmerge.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepmerge = void 0;
+var deepmerge_1 = require("deepmerge");
+Object.defineProperty(exports, "deepmerge", { enumerable: true, get: function () { return __importDefault(deepmerge_1).default; } });

package/utils/is-equal.d.ts

@@ -0,0 +1 @@
+export {} from "lodash.isequal";

package/utils/is-equal.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,2 @@
+import { AnyObject, Nullish } from "../types";
+export declare function isNotNilNorEmpty<T extends unknown[] | AnyObject | string>(value: T | Nullish): value is T;

package/utils/is-not-nil-nor-empty.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotNilNorEmpty = isNotNilNorEmpty;
+const is_empty_1 = require("./is-empty");
+const is_nil_1 = require("./is-nil");
+function isNotNilNorEmpty(value) {
+    return !(0, is_nil_1.isNil)(value) && !(0, is_empty_1.isEmpty)(value);
+}

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

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

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

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

package/utils/qs.d.ts

@@ -0,0 +1,2 @@
+export { parse, stringify } from "qs";
+export type { IParseOptions, IStringifyOptions, ParsedQs } from "qs";

package/utils/qs.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringify = exports.parse = void 0;
+var qs_1 = require("qs");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return qs_1.parse; } });
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return qs_1.stringify; } });