@adobe/ecs 0.0.0-stage → 0.1.0

package/src/implementation/world/schedule.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { Component } from "../../interface/component/component.js";
+import type { Composite } from "../../interface/system/composite.js";
+import type { Declaration } from "../../interface/system/declaration.js";
+import type { Definition } from "../../interface/registry/index.js";
+import type { Leaf } from "../../interface/system/leaf.js";
+import { scheduleOf } from "../../interface/registry/schedule.js";
+
+const value = Symbol("scheduleTest/value");
+const other = Symbol("scheduleTest/other");
+
+declare module "@adobe/ecs" {
+    export interface Components {
+        [value]: { type: number };
+        [other]: { type: number };
+    }
+}
+
+Component.register(value, { type: { type: "number" } });
+Component.register(other, { type: { type: "number" } });
+
+/** Systems built as values, not registered, so each test's are its own. */
+const leaf = (declaration: Declaration & { readonly name: string }): Leaf => ({ kind: "system", name: declaration.name, declaration, body: () => {} });
+const composite = (declaration: Composite["declaration"] & { readonly name: string }): Composite => ({ kind: "composite", name: declaration.name, declaration });
+
+const names = (system: Definition): string[][] => scheduleOf(system).tiers.map(tier => tier.map(leaf => leaf.name));
+
+describe("scheduleOf", () => {
+    it("tiers by longest ordering path, keeping flatten order within a tier", () => {
+        const a = leaf({ name: "scheduleTest/a" });
+        const b = leaf({ name: "scheduleTest/b", after: [a] });
+        const c = leaf({ name: "scheduleTest/c", before: [b] });
+        const d = leaf({ name: "scheduleTest/d" });
+        const root = composite({ name: "scheduleTest/root", systems: [b, d, c, a] });
+        expect(names(root)).toEqual([["scheduleTest/d", "scheduleTest/c", "scheduleTest/a"], ["scheduleTest/b"]]);
+    });
+
+    it("applies a composite's constraints to every member, and resolves composites to their members", () => {
+        const a = leaf({ name: "scheduleTest/a" });
+        const b = leaf({ name: "scheduleTest/b" });
+        const d = leaf({ name: "scheduleTest/d" });
+        const group = composite({ name: "scheduleTest/group", systems: [a, b], after: [d] });
+        const c = leaf({ name: "scheduleTest/c", after: [group] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [c, group, d] })))
+            .toEqual([["scheduleTest/d"], ["scheduleTest/a", "scheduleTest/b"], ["scheduleTest/c"]]);
+    });
+
+    it("pulls during pairs into one tier unless an ordering path separates them", () => {
+        const a = leaf({ name: "scheduleTest/a" });
+        const b = leaf({ name: "scheduleTest/b", after: [a] });
+        const c = leaf({ name: "scheduleTest/c", during: [b] });
+        const d = leaf({ name: "scheduleTest/d", after: [c] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [a, b, c, d] })))
+            .toEqual([["scheduleTest/a"], ["scheduleTest/b", "scheduleTest/c"], ["scheduleTest/d"]]);
+    });
+
+    it("orders a system during another between what that system follows and what follows it", () => {
+        const update = leaf({ name: "scheduleTest/update" });
+        const render = leaf({ name: "scheduleTest/render", after: [update] });
+        const writer = leaf({ name: "scheduleTest/writer", components: { write: [value] }, during: [update] });
+        const reader = leaf({ name: "scheduleTest/reader", components: { read: [value] }, during: [render] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [reader, writer, update, render] })))
+            .toEqual([["scheduleTest/writer", "scheduleTest/update"], ["scheduleTest/reader", "scheduleTest/render"]]);
+    });
+
+    it("takes the order of a system during a system that is itself during another", () => {
+        const update = leaf({ name: "scheduleTest/update" });
+        const render = leaf({ name: "scheduleTest/render", after: [update] });
+        const physics = leaf({ name: "scheduleTest/physics", during: [update] });
+        const writer = leaf({ name: "scheduleTest/writer", components: { write: [value] }, during: [physics] });
+        const reader = leaf({ name: "scheduleTest/reader", components: { read: [value] }, during: [render] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [reader, writer, physics, update, render] })))
+            .toEqual([["scheduleTest/writer", "scheduleTest/physics", "scheduleTest/update"], ["scheduleTest/reader", "scheduleTest/render"]]);
+    });
+
+    it("orders a system during a composite around the composite, not between its members", () => {
+        const start = leaf({ name: "scheduleTest/start", components: { write: [other] } });
+        const a = leaf({ name: "scheduleTest/a" });
+        const b = leaf({ name: "scheduleTest/b", after: [a] });
+        const group = composite({ name: "scheduleTest/group", systems: [a, b], after: [start] });
+        const end = leaf({ name: "scheduleTest/end", components: { read: [value] }, after: [group] });
+        const c = leaf({ name: "scheduleTest/c", components: { read: [other], write: [value] }, during: [group] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [c, start, group, end] })))
+            .toEqual([["scheduleTest/start"], ["scheduleTest/c", "scheduleTest/a"], ["scheduleTest/b"], ["scheduleTest/end"]]);
+    });
+
+    it("still throws on conflicting systems during one system, and on a during that contradicts before or after", () => {
+        const update = leaf({ name: "scheduleTest/update" });
+        const render = leaf({ name: "scheduleTest/render", after: [update] });
+        const a = leaf({ name: "scheduleTest/a", components: { write: [value] }, during: [update] });
+        const b = leaf({ name: "scheduleTest/b", components: { write: [value] }, during: [update] });
+        expect(() => scheduleOf(composite({ name: "scheduleTest/root", systems: [update, render, a, b] }))).toThrow('"scheduleTest/a" and "scheduleTest/b"');
+        const late = leaf({ name: "scheduleTest/late", during: [update], after: [render] });
+        expect(() => scheduleOf(composite({ name: "scheduleTest/root", systems: [update, render, late] }))).toThrow("Ordering cycle");
+    });
+
+    it("ignores constraints naming systems outside the one being scheduled", () => {
+        const a = leaf({ name: "scheduleTest/a", after: [leaf({ name: "scheduleTest/d" })] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [a] }))).toEqual([["scheduleTest/a"]]);
+    });
+
+    it("throws on a cycle", () => {
+        const a = leaf({ name: "scheduleTest/a" });
+        const b = leaf({ name: "scheduleTest/b", after: [a], before: [a] });
+        expect(() => scheduleOf(composite({ name: "scheduleTest/root", systems: [a, b] }))).toThrow("Ordering cycle");
+    });
+
+    it("throws on an unordered write conflict, but not when ordered or disjoint", () => {
+        const a = leaf({ name: "scheduleTest/a", components: { write: [value] } });
+        const b = leaf({ name: "scheduleTest/b", components: { read: [value] } });
+        const c = leaf({ name: "scheduleTest/c", components: { write: [other] }, during: [a] });
+        expect(() => scheduleOf(composite({ name: "scheduleTest/root", systems: [a, b] }))).toThrow('"scheduleTest/a" and "scheduleTest/b"');
+        const ordered = leaf({ ...b.declaration, name: b.name, after: [a] });
+        expect(names(composite({ name: "scheduleTest/root", systems: [a, ordered, c] })))
+            .toEqual([["scheduleTest/a", "scheduleTest/c"], ["scheduleTest/b"]]);
+    });
+
+    it("schedules two systems of one name as two, and one listed twice as one", () => {
+        const a = leaf({ name: "scheduleTest/a", components: { write: [value] } });
+        const copy = leaf({ name: "scheduleTest/a", components: { write: [value] }, after: [a] });
+        expect(scheduleOf(composite({ name: "scheduleTest/root", systems: [copy, a, a] })).tiers).toEqual([[a], [copy]]);
+        expect(() => scheduleOf(composite({ name: "scheduleTest/root", systems: [a, leaf({ name: "scheduleTest/a", components: { write: [value] } })] }))).toThrow('Systems "scheduleTest/a" and "scheduleTest/a" both access');
+    });
+});

package/src/implementation/world/semantics.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { Component } from "../../interface/component/component.js";
+import { Entity } from "../../interface/entity/entity.js";
+import type { Schema } from "../../interface/schema/schema.js";
+import { System } from "../../interface/system/system.js";
+import { count, readEach, select } from "./reads.test-helper.js";
+import { createWorld } from "./create.js";
+import { workers } from "../../interface/resources/workers.js";
+import { runReported } from "./reports.test-helper.js";
+
+type Vec2 = readonly [number, number];
+const vec2 = { type: "array", items: { type: "number", precision: 1 }, minItems: 2, maxItems: 2 } as const satisfies Schema;
+const position = Symbol("semanticsTest/position");
+const target = Symbol("semanticsTest/target");
+const score = Symbol("semanticsTest/score");
+const tag = Symbol("semanticsTest/tag");
+declare module "@adobe/ecs" {
+    export interface Components {
+        [position]: { type: readonly [number, number] };
+        [target]: { type: Entity };
+        [score]: { type: number };
+        [tag]: { type: true };
+    }
+}
+Component.register(position, { type: vec2 });
+Component.register(target, { type: Entity.schema });
+Component.register(score, { type: { type: "number" } });
+Component.register(tag, { type: { const: true } });
+
+const seed = System.create({ name: "semanticsTest/seed" }, ({ commands }) => {
+    // @ts-expect-error untyped callers can store any number as an entity
+    commands.spawn([position, target, score])({ [position]: [5, 6], [target]: -1, [score]: 0 });
+    // @ts-expect-error untyped callers can store any number as an entity
+    commands.spawn([position, target, score])({ [position]: [7, 8], [target]: Number.NaN, [score]: 0 });
+});
+const chase = System.create({
+    name: "semanticsTest/chase",
+    kernel: "cpu",
+    components: { read: [target], write: [score] },
+    lookup: { targets: { read: [position] } },
+}, (row, { lookup: { targets } }) => {
+    const other = targets(row[target]);
+    if (other === null) {
+        row[score] = -1;
+        return;
+    }
+    const [x] = other[position];
+    row[score] = x;
+});
+
+const run = async (wasm: boolean) => {
+    const world = createWorld({ [workers]: 0 }, { wasm });
+    await world.run(seed);
+    await world.run(chase);
+    const result = await readEach(world, await select(world, { required: [score] }), score);
+    await world.dispose();
+    return result;
+};
+
+describe("semantics", () => {
+    it("a throwing sync point doesn't poison the next one or another world", async () => {
+        let poison = false;
+        const spawn = System.create({ name: "semanticsTest/seed/2" }, ({ commands }) => {
+            commands.spawn([score])({ [score]: 1 });
+            commands.spawn([score])({ [score]: poison ? Symbol("x") as unknown as number : 2 });
+        });
+        const a = createWorld({ [workers]: 0 });
+        const b = createWorld({ [workers]: 0 });
+        await b.run(spawn);
+        poison = true;
+        expect((await runReported(a, spawn)).failures).toHaveLength(1);
+        poison = false;
+        const errors: string[] = [];
+        await b.run(spawn).catch(e => errors.push("b:" + String(e)));
+        await a.run(spawn).catch(e => errors.push("a:" + String(e)));
+        expect(errors).toEqual([]);
+        // The value that can't be written throws when its spawn is issued, so only the spawn before it applies.
+        expect([await count(a, { required: [score] }), await count(b, { required: [score] })]).toEqual([3, 4]);
+    });
+    it("lookup of -1 / NaN entity agrees between JS and WASM", async () => {
+        const js = await run(false);
+        const wasm = await run(true);
+        expect(wasm).toEqual(js);
+    });
+
+    it("re-adding an existing tag keeps its added tick", async () => {
+        const seen: number[] = [];
+        let entity = Entity.none;
+        const spawn = System.create({ name: "semanticsTest/seed/3" }, ({ commands }) => { entity = commands.spawn([tag, score])({ [tag]: true, [score]: 0 }); });
+        const retag = System.create({ name: "semanticsTest/retag" }, ({ commands }) => { commands.add(entity, tag, true); });
+        const watch = System.create({ name: "semanticsTest/watch", components: { has: [score], added: [tag] } }, row => { seen.push(row.entity); });
+        const world = createWorld({ [workers]: 0 });
+        await world.run(spawn);
+        await world.run(watch);
+        await world.run(retag);
+        await world.run(watch);
+        await world.dispose();
+        expect(seen.length).toBe(1);
+    });
+});

package/src/implementation/world/share.test.ts

@@ -0,0 +1,17 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { workers } from "../../interface/resources/workers.js";
+import { createWorld, join } from "./create.js";
+
+afterEach(() => { vi.unstubAllGlobals(); });
+
+describe("world.share", () => {
+    it("throws for a world and a join without cross-origin isolation, where memory can't be shared", async () => {
+        vi.stubGlobal("crossOriginIsolated", false);
+        const world = createWorld({ [workers]: 0 });
+        const { port1, port2 } = new MessageChannel();
+        expect(() => world.share(port1)).toThrow("Without cross-origin isolation memory can't be shared, so no thread can join.");
+        expect(() => join(port2)).toThrow("Without cross-origin isolation memory can't be shared, so no thread can join.");
+        port1.close();
+        await world.dispose();
+    });
+});