@ryupold/vode 1.8.4 → 1.8.5

package/test/tests-mergeProps.ts

@@ -0,0 +1,43 @@
+import { mergeProps, Props } from "../index";
+import { expect } from "./helper";
+
+export default {
+    "mergeProps(): no args returns undefined": () => {
+        expect(mergeProps()).toEqual(undefined);
+    },
+
+    "mergeProps(): single arg returned as-is": () => {
+        const p = { class: "foo" };
+        expect(mergeProps(p) === p).toEqual(true);
+    },
+
+    "mergeProps(): two plain objects merged": () => {
+        expect(mergeProps({ a: 1 }, { b: 2 })).toEqual({ a: 1, b: 2 });
+    },
+
+    "mergeProps(): right overwrites left for simple keys": () => {
+        expect(mergeProps({ a: 1, b: "x" }, { b: 2 })).toEqual({ a: 1, b: 2 });
+    },
+
+    "mergeProps(): class merged via mergeClass": () => {
+        expect(mergeProps({ class: "foo" }, { class: "bar" })).toEqual({ class: "foo bar" });
+    },
+
+    "mergeProps(): style merged via mergeStyle (strings)": () => {
+        const result = mergeProps({ style: "color: red" }, { style: "font-size: 14px" }) as Props;
+        expect((<string>result.style!).includes("color: red")).toEqual(true);
+        expect((<string>result.style!).includes("font-size: 14px")).toEqual(true);
+    },
+
+    "mergeProps(): null and undefined entries skipped": () => {
+        expect(mergeProps({ a: 1 }, null, { b: 2 }, undefined)).toEqual({ a: 1, b: 2 });
+    },
+
+    "mergeProps(): multiple args (3+)": () => {
+        expect(mergeProps({ a: 1 }, { b: 2 }, { c: 3 })).toEqual({ a: 1, b: 2, c: 3 });
+    },
+
+    "mergeProps(): first arg null returns defined from later args": () => {
+        expect(mergeProps(null, { a: 1 })).toEqual({ a: 1 });
+    }
+};

package/test/tests-mergeStyle.ts

@@ -0,0 +1,39 @@
+import { mergeStyle } from "../index";
+import { expect } from "./helper";
+
+export default {
+    "mergeStyle(): no args returns empty string": () => {
+        expect(mergeStyle()).toEqual("");
+    },
+
+    "mergeStyle(): object style sets properties, returns cssText": () => {
+        const result = mergeStyle({ color: "red", fontSize: "14px" });
+        expect(typeof result).toEqual("string");
+    },
+
+    "mergeStyle(): single string starts with semicolon": () => {
+        expect(mergeStyle("color: red")).toEqual(";color: red");
+    },
+
+    "mergeStyle(): two strings are concatenated": () => {
+        expect(mergeStyle("color: red", "font-size: 14px")).toEqual(";color: red;font-size: 14px");
+    },
+
+    "mergeStyle(): object then string": () => {
+        const result = mergeStyle({ color: "red" }, "font-size: 14px") as string;
+        expect(result.indexOf("font-size: 14px") > 0).toEqual(true);
+    },
+
+    "mergeStyle(): null and undefined entries are skipped": () => {
+        expect(mergeStyle(null, "color: red", undefined)).toEqual(";color: red");
+    },
+
+    "mergeStyle(): multiple objects and strings alternate": () => {
+        const result = mergeStyle(
+            { color: "red" },
+            "font-size: 14px",
+            { background: "blue" }
+        ) as string;
+        expect(result.includes("font-size: 14px")).toEqual(true);
+    }
+};

package/test/tests-props.ts

@@ -0,0 +1,34 @@
+import { props, DIV, SPAN } from "../index";
+import { expect } from "./helper";
+
+export default {
+    "props(): on vode with props returns props object": () => {
+        expect(props([DIV, { class: "foo" }, "hello"]))
+            .toEqual({ class: "foo" });
+    },
+
+    "props(): on just-tag vode returns undefined": () => {
+        expect(props([DIV])).toEqual(undefined);
+    },
+
+    "props(): on text vode returns undefined": () => {
+        expect(props("hello")).toEqual(undefined);
+    },
+
+    "props(): on vode where second element is an array (child) returns undefined": () => {
+        expect(props([DIV, [SPAN]] as any)).toEqual(undefined);
+    },
+
+    "props(): on vode where second element is null returns undefined": () => {
+        expect(props([DIV, null as any, "hi"])).toEqual(undefined);
+    },
+
+    "props(): on falsy input returns undefined": () => {
+        expect(props(null as any)).toEqual(undefined);
+        expect(props(undefined as any)).toEqual(undefined);
+    },
+
+    "props(): on vode with length 1 returns undefined": () => {
+        expect(props([DIV] as any)).toEqual(undefined);
+    }
+};

package/test/tests-state-context.ts

@@ -0,0 +1,106 @@
+import { expect } from "./helper";
+import { context } from "../src/state-context";
+import { createState } from "../src/vode";
+
+export default {
+    "StateContext.state: returns the state reference": () => {
+        const state = createState({ x: 10 });
+        const ctx = context(state);
+
+        expect((ctx).state === state)
+            .toEqual(true);
+    },
+
+    "StateContext.get() returns whole state": () => {
+        const state = createState({ a: 1, b: 2 });
+        const ctx = context(state);
+
+        expect(ctx.get())
+            .toEqual({ a: 1, b: 2 });
+    },
+
+
+    "StateContext.get(): deep nested": () => {
+        const state = createState({ a: { b: { c: 42 } } });
+        const ctx = context(state);
+
+        expect(ctx.a.b.c.get())
+            .toEqual(42);
+    },
+
+    "StateContext.get(): missing nested path returns undefined": () => {
+        const state = createState({ a: {} });
+        const ctx = context(state);
+
+        expect((ctx.a as any).b.get())
+            .toEqual(undefined);
+    },
+
+    "StateContext.put(): silently mutates state": () => {
+        const state = createState({ a: { b: 1 } });
+        const ctx = context(state);
+        ctx.a.b.put(2);
+
+        expect(state.a.b)
+            .toEqual(2);
+    },
+
+    "StateContext.put() on nested object replaces the sub-object": () => {
+        const state = createState({ a: { b: { x: 1, y: 2 } } });
+        const ctx = context(state);
+        ctx.a.b.put({ y: 99 });
+
+        expect(state.a.b)
+            .toEqual({ y: 99 });
+    },
+
+    "StateContext.put() at root level with empty keys": () => {
+        const state = createState({ a: 1, b: 2 });
+        const ctx = context(state);
+        ctx.put({ b: undefined });
+
+        expect(state)
+            .toEqual({ a: 1 });
+    },
+
+    "StateContext.patch(): calls state.patch with proper deep partial": () => {
+        const state = createState({ a: { b: 1 } });
+        const ctx = context(state);
+        ctx.a.b.patch(2);
+
+        const patches = (state as any).patch.initialPatches;
+
+        expect(patches.length)
+            .toEqual(1);
+        expect(patches[0])
+            .toEqual({ a: { b: 2 } });
+    },
+
+    "StateContext.patch(): async wraps in array": () => {
+        const state = createState({ a: { b: 1 } });
+        const ctx = context(state);
+        ctx.a.b.patch(2, true);
+
+        const patches = (state as any).patch.initialPatches;
+
+        expect(patches.length)
+            .toEqual(1);
+        expect(Array.isArray(patches[0]))
+            .toEqual(true);
+        expect(patches[0][0])
+            .toEqual({ a: { b: 2 } });
+    },
+
+    "StateContext.patch() on nested deep path three levels": () => {
+        const state = createState({ x: { y: { z: 0 } } });
+        const ctx = context(state);
+        ctx.x.y.z.patch(100);
+
+        const patches = (state as any).patch.initialPatches;
+
+        expect(patches.length)
+            .toEqual(1);
+        expect(patches[0])
+            .toEqual({ x: { y: { z: 100 } } });
+    },
+};

package/test/tests-tag.ts

@@ -0,0 +1,33 @@
+import { tag, DIV, SPAN } from "../index";
+import { expect } from "./helper";
+
+export default {
+    "tag(): on a vode returns the tag name": () => {
+        expect(tag([DIV]))
+            .toEqual("div");
+    },
+
+    "tag(): on a vode with props and children": () => {
+        expect(tag([DIV, { class: "foo" }, [SPAN, "hi"]]))
+            .toEqual("div");
+    },
+
+    "tag(): on a text vode (string) returns #text": () => {
+        expect(tag("hello"))
+            .toEqual("#text");
+    },
+
+    "tag(): on falsy values returns undefined": () => {
+        expect(tag(null)).toEqual(undefined);
+        expect(tag(undefined)).toEqual(undefined);
+    },
+
+    "tag(): on no-vode values returns undefined": () => {
+        expect(tag(0)).toEqual(undefined);
+        expect(tag(true)).toEqual(undefined);
+    },
+
+    "tag(): on empty array returns undefined": () => {
+        expect(tag([])).toEqual(undefined);
+    }
+};

package/test/tests-vode.ts

@@ -0,0 +1,27 @@
+import { vode, DIV, Vode, SPAN, STRONG } from "../index";
+import { expect } from "./helper";
+
+export default {
+    "vode(): passing an already constructed vode returns it": () => {
+        const testVode: Vode = [DIV, { class: 'test' }, "hello world"];
+
+        expect(vode(testVode)).toEqual(testVode);
+    },
+
+    "vode(): constructing a vode from parts": () => {
+        expect(
+            vode(DIV, { class: 'test' },
+                [SPAN, "hello"],
+                [STRONG, { style: 'color: green' }, "world"])
+        ).toEqual(
+            [DIV, { class: 'test' },
+                [SPAN, "hello"],
+                [STRONG, { style: 'color: green' }, "world"]]
+        );
+    },
+
+    "vode(): passing an invalid tag fails": () => {
+        const err = expect(() => vode(null as any)).toFail();
+        expect(err.message).toEqual("first argument to vode() must be a tag name or a vode");
+    }
+};

package/tsconfig.test.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "test/",
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "declarationDir": null,
+    "composite": false,
+    "noEmit": true
+    
+  },
+  "include": [
+    "index.ts",
+    "src/**/*",
+    "test/**/*"
+  ]
+}