chili3d 0.6.1

package/packages/chili-core/test/nodeList.test.ts

@@ -0,0 +1,247 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { FolderNode, type IDocument } from "../src";
+import { TestDocument } from "./testDocument";
+
+describe("test NodeLinkedList", () => {
+    const doc: IDocument = new TestDocument() as any;
+
+    test("test add and remove", () => {
+        const l1 = new FolderNode(doc, "l1");
+        const l2 = new FolderNode(doc, "l2");
+        const l3 = new FolderNode(doc, "l3");
+        const l4 = new FolderNode(doc, "l4");
+
+        l1.add(l2);
+        expect(l1.firstChild).toEqual(l2);
+        expect(l1.lastChild).toEqual(l2);
+        expect(l1.size()).toBe(1);
+
+        l1.remove(l2);
+        expect(l1.firstChild).toBeUndefined();
+        expect(l1.lastChild).toBeUndefined();
+        expect(l1.size()).toBe(0);
+
+        l1.add(l2);
+        l1.add(l3);
+        expect(l1.firstChild).toEqual(l2);
+        expect(l1.lastChild).toBe(l3);
+        expect(l2.nextSibling).toBe(l3);
+        expect(l3.previousSibling).toBe(l2);
+        expect(l1.size()).toBe(2);
+
+        l1.remove(l2);
+        expect(l1.firstChild).toBe(l3);
+        expect(l1.lastChild).toBe(l3);
+        expect(l1.size()).toBe(1);
+
+        l1.add(l2);
+        expect(l1.firstChild).toBe(l3);
+        expect(l1.lastChild).toBe(l2);
+        l1.add(l4);
+        expect(l1.size()).toBe(3);
+        expect(l1.lastChild).toBe(l4);
+        l1.remove(l2);
+        expect(l3.nextSibling).toBe(l4);
+        expect(l4.previousSibling).toBe(l3);
+        expect(l1.size()).toBe(2);
+    });
+
+    test("test insert before", () => {
+        const l1 = new FolderNode(doc, "l1");
+        const l2 = new FolderNode(doc, "l2");
+        const l3 = new FolderNode(doc, "l3");
+        const l4 = new FolderNode(doc, "l4");
+
+        l1.insertBefore(undefined, l2);
+        expect(l1.firstChild).toBe(l2);
+        expect(l1.lastChild).toBe(l2);
+        expect(l1.size()).toBe(1);
+
+        l1.insertBefore(l2, l3);
+        expect(l1.firstChild).toBe(l3);
+        expect(l3.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l3);
+        expect(l1.size()).toBe(2);
+
+        l1.insertBefore(l3, l4);
+        expect(l2.previousSibling).toBe(l3);
+        expect(l3.nextSibling).toBe(l2);
+        expect(l3.previousSibling).toBe(l4);
+        expect(l4.nextSibling).toBe(l3);
+        expect(l1.size()).toBe(3);
+    });
+
+    test("test insert after", () => {
+        const l1 = new FolderNode(doc, "l1");
+        const l2 = new FolderNode(doc, "l2");
+        const l3 = new FolderNode(doc, "l3");
+        const l4 = new FolderNode(doc, "l4");
+        const l5 = new FolderNode(doc, "l5");
+
+        l1.insertAfter(undefined, l2);
+        expect(l1.firstChild).toEqual(l2);
+        expect(l1.lastChild).toEqual(l2);
+        expect(l1.size()).toBe(1);
+
+        l1.insertAfter(l2, l3);
+        expect(l1.firstChild).toEqual(l2);
+        expect(l1.lastChild).toEqual(l3);
+        expect(l2.nextSibling).toBe(l3);
+        expect(l2.previousSibling).toBeUndefined();
+        expect(l3.previousSibling).toBe(l2);
+        expect(l1.size()).toBe(2);
+
+        l1.insertAfter(l2, l4);
+        expect(l4.previousSibling).toBe(l2);
+        expect(l2.nextSibling).toBe(l4);
+        expect(l4.nextSibling).toBe(l3);
+        expect(l3.previousSibling).toBe(l4);
+        expect(l1.size()).toBe(3);
+
+        l1.insertAfter(undefined, l5);
+        expect(l1.firstChild).toBe(l5);
+        expect(l5.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l5);
+    });
+
+    test("test moveTo", () => {
+        const l1 = new FolderNode(doc, "l1");
+        const l2 = new FolderNode(doc, "l2");
+        const l3 = new FolderNode(doc, "l3");
+        const l4 = new FolderNode(doc, "l4");
+        const l5 = new FolderNode(doc, "l5");
+        const l6 = new FolderNode(doc, "l6");
+
+        l1.add(l2, l4);
+        l2.add(l3);
+        l1.move(l2, l5);
+        expect(l1.count).toBe(1);
+        expect(l5.count).toBe(1);
+        expect(l1.firstChild?.name).toBe(l4.name);
+        expect(l2.firstChild?.name).toBe(l3.name);
+        expect(l5.firstChild?.name).toBe(l2.name);
+
+        l5.add(l6);
+        l1.move(l4, l5, l2);
+        expect(l1.count).toBe(0);
+        expect(l5.count).toBe(3);
+        expect(l2.nextSibling?.name).toBe(l4.name);
+        expect(l4.previousSibling?.name).toBe(l2.name);
+        expect(l4.nextSibling?.name).toBe(l6.name);
+        expect(l6.previousSibling?.name).toBe(l4.name);
+    });
+
+    test("test undo redo", () => {
+        const l1 = new FolderNode(doc, "l1");
+
+        // add undo redo
+        doc.modelManager.rootNode.add(l1);
+        expect(doc.modelManager.rootNode.firstChild).toBe(l1);
+        doc.history.undo();
+        expect(doc.modelManager.rootNode.firstChild).toBeUndefined();
+        doc.history.redo();
+        expect(doc.modelManager.rootNode.firstChild).toBe(l1);
+        doc.modelManager.rootNode.remove(l1);
+
+        // remove undo redo
+        doc.modelManager.rootNode.add(l1);
+        expect(doc.modelManager.rootNode.firstChild).toBe(l1);
+        doc.modelManager.rootNode.remove(l1);
+        expect(doc.modelManager.rootNode.firstChild).toBeUndefined();
+        doc.history.undo();
+        expect(doc.modelManager.rootNode.firstChild).toBe(l1);
+        doc.history.redo();
+        expect(doc.modelManager.rootNode.firstChild).toBeUndefined();
+        doc.modelManager.rootNode.remove(l1);
+
+        const l2 = new FolderNode(doc, "l2");
+        const l3 = new FolderNode(doc, "l3");
+        // insertAfter undo redo
+        doc.modelManager.rootNode.add(l1, l3);
+        doc.modelManager.rootNode.insertAfter(l1, l2);
+        expect(l1.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l1);
+        expect(l2.nextSibling).toBe(l3);
+        expect(l3.previousSibling).toBe(l2);
+        doc.history.undo();
+        expect(l1.nextSibling).toBe(l3);
+        expect(l3.previousSibling).toBe(l1);
+        expect(l2.previousSibling).toBeUndefined();
+        doc.history.redo();
+        expect(l1.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l1);
+        expect(l2.nextSibling).toBe(l3);
+        expect(l3.previousSibling).toBe(l2);
+        doc.modelManager.rootNode.remove(l1, l2, l3);
+
+        // insertBefore undo redo
+        doc.modelManager.rootNode.add(l3, l1);
+        doc.modelManager.rootNode.insertBefore(l1, l2);
+        expect(l3.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l3);
+        expect(l2.nextSibling).toBe(l1);
+        expect(l1.previousSibling).toBe(l2);
+        doc.history.undo();
+        expect(l3.nextSibling).toBe(l1);
+        expect(l2.nextSibling).toBeUndefined();
+        expect(l1.previousSibling).toBe(l3);
+        doc.history.redo();
+        expect(l3.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l3);
+        expect(l2.nextSibling).toBe(l1);
+        expect(l1.previousSibling).toBe(l2);
+        doc.modelManager.rootNode.remove(l1, l2, l3);
+
+        // move undo redo
+        doc.modelManager.rootNode.add(l1, l2);
+        doc.modelManager.rootNode.move(l1, doc.modelManager.rootNode, l2);
+        expect(l2.nextSibling).toBe(l1);
+        expect(l1.previousSibling).toBe(l2);
+        doc.history.undo();
+        expect(l1.nextSibling).toBe(l2);
+        expect(l2.previousSibling).toBe(l1);
+        doc.history.redo();
+        expect(l2.nextSibling).toBe(l1);
+        expect(l1.previousSibling).toBe(l2);
+        doc.modelManager.rootNode.remove(l1, l2);
+
+        const l4 = new FolderNode(doc, "l4");
+        const l5 = new FolderNode(doc, "l5");
+        const l6 = new FolderNode(doc, "l6");
+        doc.modelManager.rootNode.add(l1, l2);
+        l1.add(l3, l4);
+        l2.add(l5);
+        l5.add(l6);
+        l2.move(l5, l1, l3);
+        expect(l2.count).toBe(0);
+        expect(l1.count).toBe(3);
+        expect(l2.firstChild).toBeUndefined();
+        expect(l5.previousSibling).toBe(l3);
+        expect(l5.nextSibling).toBe(l4);
+        expect(l3.nextSibling).toBe(l5);
+        expect(l4.previousSibling?.name).toBe(l5.name);
+        expect(l5.firstChild).toBe(l6);
+
+        doc.history.undo();
+        expect(l2.count).toBe(1);
+        expect(l1.count).toBe(2);
+        expect(l2.firstChild).toBe(l5);
+        expect(l5.previousSibling).toBe(undefined);
+        expect(l5.nextSibling).toBe(undefined);
+        expect(l3.nextSibling).toBe(l4);
+        expect(l4.previousSibling).toBe(l3);
+        expect(l5.firstChild).toBe(l6);
+
+        doc.history.redo();
+        expect(l2.count).toBe(0);
+        expect(l1.count).toBe(3);
+        expect(l2.firstChild).toBeUndefined();
+        expect(l5.previousSibling).toBe(l3);
+        expect(l5.nextSibling).toBe(l4);
+        expect(l3.nextSibling).toBe(l5);
+        expect(l4.previousSibling).toBe(l5);
+        expect(l5.firstChild).toBe(l6);
+    });
+});

package/packages/chili-core/test/observer.test.ts

@@ -0,0 +1,91 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { DeepObserver, type IPropertyChanged, Observable } from "../src";
+
+class TestClassA extends Observable {
+    get propA() {
+        return this.getPrivateValue("propA", 1);
+    }
+    set propA(value: number) {
+        this.setProperty("propA", value);
+    }
+}
+
+class TestClassB extends Observable {
+    get propBV() {
+        return this.getPrivateValue("propBV", 1);
+    }
+    set propBV(value: number) {
+        this.setProperty("propBV", value);
+    }
+
+    get propB() {
+        return this.getPrivateValue("propB", new TestClassA());
+    }
+    set propB(value: TestClassA | undefined) {
+        this.setProperty("propB", value);
+    }
+}
+
+class TestClassC extends Observable {
+    get propCV() {
+        return this.getPrivateValue("propCV", 1);
+    }
+    set propCV(value: number) {
+        this.setProperty("propCV", value);
+    }
+
+    get propC() {
+        return this.getPrivateValue("propC", new TestClassB());
+    }
+    set propC(value: TestClassB | undefined) {
+        this.setProperty("propC", value);
+    }
+}
+
+test("test observer", () => {
+    const t = new TestClassA();
+    t.onPropertyChanged((p, s, o) => {
+        expect(p).toBe("propA");
+        expect(s[p]).toBe(2);
+    });
+    t.propA = 2;
+});
+
+test("deep observer", () => {
+    const c = new TestClassC();
+    let targetProperty: string | undefined;
+    const onPropertyChanged = (p: string, s: IPropertyChanged, o: any) => {
+        targetProperty = p;
+    };
+    const a = new TestClassA();
+    DeepObserver.addDeepPropertyChangedHandler(c, onPropertyChanged);
+    c.propC!.propB = a;
+    expect(targetProperty).toBe("propC.propB");
+    a.propA = 2;
+    expect(targetProperty).toBe("propC.propB.propA");
+
+    c.propC = undefined;
+    expect(targetProperty).toBe("propC");
+    a.propA = 3;
+    expect(targetProperty).toBe("propC");
+
+    const b = new TestClassB();
+    c.propC = b;
+    expect(targetProperty).toBe("propC");
+    b.propB = a;
+    expect(targetProperty).toBe("propC.propB");
+    a.propA = 2;
+    expect(targetProperty).toBe("propC.propB.propA");
+
+    b.propB = undefined;
+    expect(targetProperty).toBe("propC.propB");
+    a.propA = 3;
+    expect(targetProperty).toBe("propC.propB");
+
+    b.propB = a;
+    expect(targetProperty).toBe("propC.propB");
+    a.propA = 2;
+    expect(targetProperty).toBe("propC.propB.propA");
+});

package/packages/chili-core/test/plane.test.ts

@@ -0,0 +1,31 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Line, Plane, Ray, XYZ } from "../src";
+
+describe("test plane", () => {
+    test("test constructor", () => {
+        expect(() => new Plane(XYZ.zero, XYZ.unitX, XYZ.unitX)).toThrow();
+        expect(() => new Plane(XYZ.zero, XYZ.zero, XYZ.unitY)).toThrow();
+        expect(() => new Plane(XYZ.zero, XYZ.unitX, XYZ.zero)).toThrow();
+    });
+
+    test("test intersect", () => {
+        const plane = new Plane(XYZ.zero, XYZ.unitZ, XYZ.unitX);
+        expect(plane.intersectLine(new Line(XYZ.unitZ, XYZ.unitX))).toBeUndefined();
+        expect(plane.intersectLine(new Line(XYZ.unitZ, XYZ.unitZ.reverse()))).toStrictEqual(XYZ.zero);
+        expect(plane.intersectLine(new Line(XYZ.unitX, XYZ.unitZ.add(XYZ.unitX)))).toStrictEqual(XYZ.unitX);
+        expect(plane.intersectLine(new Line(new XYZ(1, 1, 1), new XYZ(-1, 0, -1)))).toStrictEqual(
+            new XYZ(0, 1, 0),
+        );
+        expect(plane.intersectLine(new Line(new XYZ(1, 1, 1), new XYZ(1, 0, 1)))).toStrictEqual(
+            new XYZ(0, 1, 0),
+        );
+        expect(plane.intersectRay(new Ray(new XYZ(1, 1, 1), new XYZ(1, 0, 1)))).toBeUndefined();
+    });
+
+    test("test project", () => {
+        expect(Plane.XY.project(new XYZ(0, 0, 0))).toStrictEqual(new XYZ(0, 0, 0));
+        expect(Plane.XY.project(new XYZ(100, 100, 100))).toStrictEqual(new XYZ(100, 100, 0));
+    });
+});

package/packages/chili-core/test/quaternion.test.ts

@@ -0,0 +1,14 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Quaternion, XYZ } from "../src";
+
+describe("test Quaternion", () => {
+    test("test rotateVector", () => {
+        const quat = new Quaternion(0.822363, 0.0222599, 0.43968, 0.360423);
+        const vector = new XYZ(0, 1, 0);
+        const gtRotVector = new XYZ(-0.573223, 0.739199, 0.353553);
+        const afterRotVec = quat.rotateVector(vector);
+        expect(afterRotVec.isEqualTo(gtRotVector)).toBeTruthy();
+    });
+});

package/packages/chili-core/test/result.test.ts

@@ -0,0 +1,24 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Result } from "../src";
+
+test("test result", () => {
+    const r1 = Result.ok("11");
+    expect(r1.isOk).toBeTruthy;
+    expect(r1.value).toBe("11");
+    expect(r1.isOk).toBeTruthy();
+
+    const r2 = Result.err("err");
+    expect(r2.isOk).toBeFalsy();
+    expect(!r2.isOk).toBeTruthy();
+    expect((r2 as Result<any>).error).toBe("err");
+
+    const r3 = Result.ok(true);
+    expect(r3.isOk).toBeTruthy();
+    expect((r3 as Result<boolean>).value).toBeTruthy();
+
+    const r4 = Result.ok(undefined);
+    expect(r4.isOk).toBeTruthy();
+    expect((r4 as Result<undefined>).value).toBeUndefined();
+});

package/packages/chili-core/test/serializer.test.ts

@@ -0,0 +1,58 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { FolderNode, type IDocument, NodeSerializer, type Serialized, Serializer } from "../src";
+import { TestDocument } from "./testDocument";
+
+@Serializer.register(["k1" as any])
+class TestObject {
+    protected k2: string = "k2";
+    public k3: string = "k3";
+
+    @Serializer.serialze()
+    private k1: string;
+    @Serializer.serialze()
+    private k4: string = "k4";
+    @Serializer.serialze()
+    protected k5: string = "k5";
+    @Serializer.serialze()
+    public k6: string = "k6";
+
+    constructor(k1: string) {
+        this.k1 = k1;
+    }
+
+    serialize(): Serialized {
+        return Serializer.serializeObject(this);
+    }
+}
+
+test("test Serializer", () => {
+    const obj = new TestObject("111");
+    const s = obj.serialize();
+    expect("k1" in s.properties).toBeTruthy();
+    expect("k4" in s.properties).toBeTruthy();
+    expect("k5" in s.properties).toBeTruthy();
+    expect("k6" in s.properties).toBeTruthy();
+    s.properties["k1"] = "222";
+    const obj2 = Serializer.deserializeObject({} as any, s);
+    expect(obj2.k1).toBe("222");
+});
+
+test("test Node Serializer", () => {
+    const doc: IDocument = new TestDocument() as any;
+
+    const n1 = new FolderNode(doc, "n1");
+    const n2 = new FolderNode(doc, "n2");
+    const n3 = new FolderNode(doc, "n3");
+    const n4 = new FolderNode(doc, "n4");
+    n1.add(n2, n3);
+    n2.add(n4);
+    const s = NodeSerializer.serialize(n1);
+
+    NodeSerializer.deserialize(doc, s).then((n11: any) => {
+        expect(n11.firstChild.name).toBe("n2");
+        expect(n11.firstChild.nextSibling.name).toBe("n3");
+        expect(n11.firstChild.firstChild.name).toBe("n4");
+    });
+});

package/packages/chili-core/test/snapType.test.ts

@@ -0,0 +1,10 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { ObjectSnapType } from "../src";
+
+test("test SnapType", () => {
+    const ts = ObjectSnapType.endPoint | ObjectSnapType.midPoint;
+    expect(ObjectSnapType.has(ts, ObjectSnapType.center)).toBeFalsy();
+    expect(ObjectSnapType.has(ts, ObjectSnapType.midPoint)).toBeTruthy();
+});

package/packages/chili-core/test/task.test.ts

@@ -0,0 +1,41 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { AsyncController } from "../src";
+
+test("test cancel", async () => {
+    const controller = new AsyncController();
+    expect(controller.result?.status === "cancel").toBeFalsy();
+    await new Promise((r, s) => {
+        setTimeout(() => {
+            controller.cancel();
+            r("resolved");
+        }, 30);
+    });
+    expect(controller.result?.status === "cancel").toBeTruthy();
+});
+
+test("test fail", async () => {
+    const controller = new AsyncController();
+    expect(controller.result?.status === "fail").toBeFalsy();
+    await new Promise((r, s) => {
+        setTimeout(() => {
+            controller.fail("fail msg");
+            r("resolved");
+        }, 30);
+    });
+    expect(controller.result?.status === "fail").toBeTruthy();
+    expect(controller.result?.message).toBe("fail msg");
+});
+
+test("test complete", async () => {
+    const controller = new AsyncController();
+    expect(controller.result?.status === "success").toBeFalsy();
+    await new Promise((r, s) => {
+        setTimeout(() => {
+            controller.success();
+            r("resolved");
+        }, 30);
+    });
+    expect(controller.result?.status === "success").toBeTruthy();
+});

package/packages/chili-core/test/testDocument.ts

@@ -0,0 +1,70 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    type Act,
+    History,
+    type IApplication,
+    type IDocument,
+    type ISelection,
+    type ISerialize,
+    type IView,
+    type IVisual,
+    type Material,
+    ModelManager,
+    ObservableCollection,
+    type PropertyChangedHandler,
+    type Serialized,
+} from "chili-core";
+
+export class TestDocument implements IDocument, ISerialize {
+    application: IApplication;
+    name: string;
+    id: string;
+    history: History;
+    selection: ISelection;
+    visual: IVisual;
+    activeView: IView | undefined;
+    modelManager: ModelManager = new ModelManager(this);
+    materials: ObservableCollection<Material> = new ObservableCollection<Material>();
+    acts: ObservableCollection<Act> = new ObservableCollection<Act>();
+    onPropertyChanged<K extends keyof this>(handler: PropertyChangedHandler<this, K>): void {
+        throw new Error("Method not implemented.");
+    }
+    removePropertyChanged<K extends keyof this>(handler: PropertyChangedHandler<this, K>): void {
+        throw new Error("Method not implemented.");
+    }
+    dispose() {
+        throw new Error("Method not implemented.");
+    }
+
+    importFiles(files: File[] | FileList): Promise<void> {
+        return Promise.resolve();
+    }
+
+    close(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    serialize(): Serialized {
+        return {
+            classKey: "TestDocument",
+            properties: {},
+        };
+    }
+
+    constructor() {
+        this.name = "test";
+        this.id = "test";
+        this.visual = {} as any;
+        this.history = new History();
+        this.selection = {} as any;
+        this.application = { views: [] } as any;
+    }
+    clearPropertyChanged(): void {
+        throw new Error("Method not implemented.");
+    }
+    save(): Promise<void> {
+        return Promise.resolve();
+    }
+}

package/packages/chili-core/test/transaction.test.ts

@@ -0,0 +1,42 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { History, type IDocument, type PropertyHistoryRecord, Transaction } from "../src";
+
+describe("test Transaction", () => {
+    test("test static methods", () => {
+        const doc: IDocument = { history: new History() } as any;
+        const history: PropertyHistoryRecord = {} as any;
+        Transaction.add(doc, history);
+        expect(doc.history.undoCount()).toBe(1);
+        Transaction.execute(doc, "Test", () => {
+            Transaction.add(doc, history);
+            Transaction.add(doc, history);
+        });
+        expect(doc.history.undoCount()).toBe(2);
+
+        expect(() =>
+            Transaction.execute(doc, "throw", () => {
+                throw new Error("err");
+            }),
+        ).toThrow("err");
+        expect(doc.history.undoCount()).toBe(2);
+    });
+
+    test("test methods", () => {
+        const doc: IDocument = { history: new History() } as any;
+        const trans = new Transaction(doc, "test");
+        expect(() => trans.commit()).toThrow("Transaction has not started");
+        trans.start();
+        expect(() => trans.start()).toThrow("The document has started a transaction");
+        trans.rollback();
+        expect(() => trans.commit()).toThrow("Transaction has not started");
+
+        trans.start();
+        expect(doc.history.undoCount()).toBe(0);
+        const history: PropertyHistoryRecord = {} as any;
+        Transaction.add(doc, history);
+        trans.commit();
+        expect(doc.history.undoCount()).toBe(1);
+    });
+});

package/packages/chili-core/test/visual.test.ts

@@ -0,0 +1,42 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { VisualState } from "../src";
+
+describe("visual test", () => {
+    test("test VisualState", () => {
+        let state = VisualState.normal;
+        expect(state).toBe(0);
+
+        state = VisualState.addState(state, VisualState.edgeHighlight);
+        expect(state).toBe(1);
+        expect(VisualState.hasState(state, VisualState.edgeHighlight)).toBeTruthy();
+        expect(VisualState.hasState(state, VisualState.edgeSelected)).toBeFalsy();
+
+        state = VisualState.addState(state, VisualState.edgeSelected);
+        expect(state).toBe(3);
+        expect(VisualState.hasState(state, VisualState.edgeHighlight)).toBeTruthy();
+        expect(VisualState.hasState(state, VisualState.edgeSelected)).toBeTruthy();
+
+        state = VisualState.removeState(state, VisualState.edgeHighlight);
+        expect(state).toBe(2);
+        expect(VisualState.hasState(state, VisualState.edgeHighlight)).toBeFalsy();
+        expect(VisualState.hasState(state, VisualState.edgeSelected)).toBeTruthy();
+
+        state = VisualState.removeState(state, VisualState.edgeSelected);
+        expect(state).toBe(0);
+        expect(VisualState.hasState(state, VisualState.edgeHighlight)).toBeFalsy();
+        expect(VisualState.hasState(state, VisualState.edgeSelected)).toBeFalsy();
+
+        state = VisualState.edgeHighlight;
+        state = VisualState.addState(state, VisualState.edgeSelected);
+        expect(state).toBe(3);
+        expect(VisualState.hasState(state, VisualState.edgeHighlight)).toBeTruthy();
+        expect(VisualState.hasState(state, VisualState.edgeSelected)).toBeTruthy();
+
+        state = VisualState.removeState(state, VisualState.edgeHighlight);
+        expect(state).toBe(2);
+        expect(VisualState.hasState(state, VisualState.edgeHighlight)).toBeFalsy();
+        expect(VisualState.hasState(state, VisualState.edgeSelected)).toBeTruthy();
+    });
+});