@uxf/core 11.11.3 → 11.19.0

package/README.md

@@ -328,6 +328,58 @@ queryParamToNumber(ctx.query.id);
 queryParamToString(ctx.query.name);
 ```
 
+## Utils
+
+### cx, cxa
+It is our fork of `clsx` library https://github.com/lukeed/clsx
+
+We will mainly use `cx`, which is fork of `clsx/lite` – it accepts **ONLY** string values! Any non-string arguments are ignored!
+```tsx
+import { cx } from "@uxf/core/utils/cx";
+
+// string
+cx("hello", true && "foo", false && "bar");
+// => "hello foo"
+
+// NOTE: Any non-string input(s) ignored
+cx({ foo: true });
+//=> ""
+```
+
+The `cxa` function is full fork of `clsx` and can take *any* number of arguments, each of which can be an Object, Array, Boolean, or String.
+
+**Important**: Any falsy values are discarded! Standalone Boolean values are discarded as well.
+```tsx
+import { cxa } from "@uxf/core/utils/cxa";
+
+cxa(true, false, "", null, undefined, 0, NaN);
+//=> ""
+
+// Strings (variadic)
+cxa("foo", true && "bar", "baz");
+//=> "foo bar baz"
+
+// Objects
+cxa({ foo:true, bar:false, baz:isTrue() });
+//=> "foo baz"
+
+// Objects (variadic)
+cxa({ foo:true }, { bar:false }, null, { "--foobar":"hello" });
+//=> "foo --foobar"
+
+// Arrays
+cxa(["foo", 0, false, "bar"]);
+//=> "foo bar"
+
+// Arrays (variadic)
+cxa(["foo"], ["", 0, false, "bar"], [["baz", [["hello"], "there"]]]);
+//=> "foo bar baz hello there"
+
+// Kitchen sink (with nesting)
+cxa("foo", [1 && "bar", { baz:false, bat:null }, ["hello", ["world"]]], "cya");
+//=> "foo bar hello world cya"
+```
+
 ## Validators
 ```tsx
 import { Validator } from "@uxf/core";

package/package.json

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

package/utils/cx.d.ts

@@ -1,3 +1,2 @@
-export type ClassArray = ClassValue[];
-export type ClassValue = ClassArray | Record<string, any> | string | number | null | boolean | undefined;
-export declare function cx(...classes: ClassValue[]): string;
+export type CxClassValue = string | null | boolean | undefined;
+export declare function cx(...classes: CxClassValue[]): string;

package/utils/cx.js

@@ -1,51 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cx = void 0;
-function toVal(mix) {
-    let k;
-    let y;
-    let str = "";
-    if (typeof mix === "string" || typeof mix === "number") {
-        str += mix;
-    }
-    else if (typeof mix === "object") {
-        if (Array.isArray(mix)) {
-            for (k = 0; k < mix.length; k++) {
-                if (mix[k]) {
-                    if ((y = toVal(mix[k]))) {
-                        if (str) {
-                            str += " ";
-                        }
-                        str += y;
-                    }
-                }
-            }
-        }
-        else {
-            for (k in mix) {
-                if (mix === null || mix === void 0 ? void 0 : mix[k]) {
-                    if (str) {
-                        str += " ";
-                    }
-                    str += k;
-                }
-            }
-        }
-    }
-    return str;
-}
 function cx(...classes) {
-    let i = 0;
-    let tmp;
-    let x;
-    let str = "";
-    while (i < classes.length) {
-        if ((tmp = classes[i++])) {
-            if ((x = toVal(tmp))) {
-                if (str) {
-                    str += " ";
-                }
-                str += x;
+    let i = 0, tmp, str = "";
+    for (; i < classes.length; i++) {
+        if ((tmp = classes[i])) {
+            if (typeof tmp === "string") {
+                str += (str && " ") + tmp;
             }
         }
     }

package/utils/cx.test.d.ts

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

package/utils/cx.test.js

@@ -0,0 +1,58 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unnecessary-condition,@typescript-eslint/ban-ts-comment */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cx_1 = require("./cx");
+test("strings", () => {
+    expect((0, cx_1.cx)("")).toBe("");
+    expect((0, cx_1.cx)("foo")).toBe("foo");
+    expect((0, cx_1.cx)(true && "foo")).toBe("foo");
+    expect((0, cx_1.cx)(false && "foo")).toBe("");
+});
+test("strings (variadic)", () => {
+    expect((0, cx_1.cx)("")).toBe("");
+    expect((0, cx_1.cx)("foo", "bar")).toBe("foo bar");
+    expect((0, cx_1.cx)(true && "foo", false && "bar", "baz")).toBe("foo baz");
+    expect((0, cx_1.cx)(false && "foo", "bar", "baz", "")).toBe("bar baz");
+});
+test("emptys", () => {
+    expect((0, cx_1.cx)("")).toBe("");
+    expect((0, cx_1.cx)(undefined)).toBe("");
+    expect((0, cx_1.cx)(null)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(0)).toBe("");
+});
+// lite ignores all non-strings
+test("non-strings", () => {
+    // number
+    // @ts-ignore
+    expect((0, cx_1.cx)(1)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(1, 2)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(Infinity)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(NaN)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(0)).toBe("");
+    // objects
+    // @ts-ignore
+    expect((0, cx_1.cx)({})).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(null)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)({ a: 1 })).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)({ a: 1 }, { b: 2 })).toBe("");
+    // arrays
+    // @ts-ignore
+    expect((0, cx_1.cx)([])).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(["foo"])).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(["foo", "bar"])).toBe("");
+    // @ts-ignore
+    // functions
+    expect((0, cx_1.cx)(cx_1.cx)).toBe("");
+    // @ts-ignore
+    expect((0, cx_1.cx)(cx_1.cx, cx_1.cx)).toBe("");
+});

package/utils/cxa.d.ts

@@ -0,0 +1,3 @@
+export type CxaClassArray = CxaClassValue[];
+export type CxaClassValue = CxaClassArray | Record<string, any> | string | number | null | boolean | undefined;
+export declare function cxa(...classes: CxaClassValue[]): string;

package/utils/cxa.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cxa = void 0;
+function toVal(mix) {
+    let k;
+    let y;
+    let str = "";
+    if (typeof mix === "string" || typeof mix === "number") {
+        str += mix;
+    }
+    else if (typeof mix === "object") {
+        if (Array.isArray(mix)) {
+            for (k = 0; k < mix.length; k++) {
+                if (mix[k]) {
+                    if ((y = toVal(mix[k]))) {
+                        if (str) {
+                            str += " ";
+                        }
+                        str += y;
+                    }
+                }
+            }
+        }
+        else {
+            for (k in mix) {
+                if (mix === null || mix === void 0 ? void 0 : mix[k]) {
+                    if (str) {
+                        str += " ";
+                    }
+                    str += k;
+                }
+            }
+        }
+    }
+    return str;
+}
+function cxa(...classes) {
+    let i = 0;
+    let tmp;
+    let x;
+    let str = "";
+    while (i < classes.length) {
+        if ((tmp = classes[i++])) {
+            if ((x = toVal(tmp))) {
+                if (str) {
+                    str += " ";
+                }
+                str += x;
+            }
+        }
+    }
+    return str;
+}
+exports.cxa = cxa;

package/utils/cxa.test.d.ts

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

package/utils/cxa.test.js

@@ -0,0 +1,71 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unnecessary-condition,no-empty-function */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cxa_1 = require("./cxa");
+test("strings", () => {
+    expect((0, cxa_1.cxa)("")).toBe("");
+    expect((0, cxa_1.cxa)("foo")).toBe("foo");
+    expect((0, cxa_1.cxa)(true && "foo")).toBe("foo");
+    expect((0, cxa_1.cxa)(false && "foo")).toBe("");
+});
+test("strings (variadic)", () => {
+    expect((0, cxa_1.cxa)("")).toBe("");
+    expect((0, cxa_1.cxa)("foo", "bar")).toBe("foo bar");
+    expect((0, cxa_1.cxa)(true && "foo", false && "bar", "baz")).toBe("foo baz");
+    expect((0, cxa_1.cxa)(false && "foo", "bar", "baz", "")).toBe("bar baz");
+});
+test("numbers", () => {
+    expect((0, cxa_1.cxa)(1)).toBe("1");
+    expect((0, cxa_1.cxa)(12)).toBe("12");
+    expect((0, cxa_1.cxa)(0.1)).toBe("0.1");
+    expect((0, cxa_1.cxa)(0)).toBe("");
+    expect((0, cxa_1.cxa)(Infinity)).toBe("Infinity");
+    expect((0, cxa_1.cxa)(NaN)).toBe("");
+});
+test("numbers (variadic)", () => {
+    expect((0, cxa_1.cxa)(0, 1)).toBe("1");
+    expect((0, cxa_1.cxa)(1, 2)).toBe("1 2");
+});
+test("objects", () => {
+    expect((0, cxa_1.cxa)({})).toBe("");
+    expect((0, cxa_1.cxa)({ foo: true })).toBe("foo");
+    expect((0, cxa_1.cxa)({ foo: true, bar: false })).toBe("foo");
+    expect((0, cxa_1.cxa)({ foo: "hiya", bar: 1 })).toBe("foo bar");
+    expect((0, cxa_1.cxa)({ foo: 1, bar: 0, baz: 1 })).toBe("foo baz");
+    expect((0, cxa_1.cxa)({ "-foo": 1, "--bar": 1 })).toBe("-foo --bar");
+});
+test("objects (variadic)", () => {
+    expect((0, cxa_1.cxa)({}, {})).toBe("");
+    expect((0, cxa_1.cxa)({ foo: 1 }, { bar: 2 })).toBe("foo bar");
+    expect((0, cxa_1.cxa)({ foo: 1 }, null, { baz: 1, bat: 0 })).toBe("foo baz");
+    expect((0, cxa_1.cxa)({ foo: 1 }, {}, {}, { bar: "a" }, { baz: null, bat: Infinity })).toBe("foo bar bat");
+});
+test("arrays", () => {
+    expect((0, cxa_1.cxa)([])).toBe("");
+    expect((0, cxa_1.cxa)(["foo"])).toBe("foo");
+    expect((0, cxa_1.cxa)(["foo", "bar"])).toBe("foo bar");
+    expect((0, cxa_1.cxa)(["foo", 0 && "bar", 1 && "baz"])).toBe("foo baz");
+});
+test("arrays (nested)", () => {
+    expect((0, cxa_1.cxa)([[[]]])).toBe("");
+    expect((0, cxa_1.cxa)([[["foo"]]])).toBe("foo");
+    expect((0, cxa_1.cxa)([true, [["foo"]]])).toBe("foo");
+    expect((0, cxa_1.cxa)(["foo", ["bar", ["", [["baz"]]]]])).toBe("foo bar baz");
+});
+test("arrays (variadic)", () => {
+    expect((0, cxa_1.cxa)([], [])).toBe("");
+    expect((0, cxa_1.cxa)(["foo"], ["bar"])).toBe("foo bar");
+    expect((0, cxa_1.cxa)(["foo"], null, ["baz", ""], true, "", [])).toBe("foo baz");
+});
+test("arrays (no `push` escape)", () => {
+    expect((0, cxa_1.cxa)({ push: 1 })).toBe("push");
+    expect((0, cxa_1.cxa)({ pop: true })).toBe("pop");
+    expect((0, cxa_1.cxa)({ push: true })).toBe("push");
+    expect((0, cxa_1.cxa)("hello", { world: 1, push: true })).toBe("hello world push");
+});
+test("functions", () => {
+    const foo = () => { };
+    expect((0, cxa_1.cxa)(foo, "hello")).toBe("hello");
+    expect((0, cxa_1.cxa)(foo, "hello", cxa_1.cxa)).toBe("hello");
+    expect((0, cxa_1.cxa)(foo, "hello", [[cxa_1.cxa], "world"])).toBe("hello world");
+});

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

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

package/utils/is-not-empty.js

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

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

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

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

@@ -0,0 +1,9 @@
+"use strict";
+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();
+});