@adobe/data 0.8.4 → 0.8.6

package/dist/ecs/store/create-store.test.js

@@ -26,7 +26,7 @@ import { F32 } from "../../math/f32/index.js";
 import { Time } from "../../schema/index.js";
 describe("createStore", () => {
     // Test that store passes all core functionality tests
-    createCoreTestSuite("Store core functionality", (componentSchemas) => createStore(componentSchemas, {}));
+    createCoreTestSuite("Store core functionality", (componentSchemas) => createStore({ components: componentSchemas, resources: {}, archetypes: {} }));
     // Select function tests
     describe("Select functionality", () => {
         const velocitySchema = {
@@ -38,11 +38,11 @@ describe("createStore", () => {
             }
         };
         it("should select entities from single archetype", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                    name: nameSchema,
+                }, resources: {}, archetypes: {} });
             // Create entities in a single archetype
             const archetype = store.ensureArchetype(["id", "position", "health"]);
             const entity1 = archetype.insert({
@@ -60,12 +60,12 @@ describe("createStore", () => {
             expect(entities).toContain(entity2);
         });
         it("should select entities spanning multiple archetypes", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-                velocity: velocitySchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                    name: nameSchema,
+                    velocity: velocitySchema,
+                }, resources: {}, archetypes: {} });
             // Create entities in different archetypes
             const positionOnlyArchetype = store.ensureArchetype(["id", "position"]);
             const entity1 = positionOnlyArchetype.insert({
@@ -113,11 +113,11 @@ describe("createStore", () => {
             expect(bothEntities).not.toContain(entity5);
         });
         it("should select entities with exclude option", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                    name: nameSchema,
+                }, resources: {}, archetypes: {} });
             // Create entities in different archetypes
             const positionOnlyArchetype = store.ensureArchetype(["id", "position"]);
             const entity1 = positionOnlyArchetype.insert({
@@ -135,10 +135,10 @@ describe("createStore", () => {
             expect(positionOnlyEntities).not.toContain(entity2);
         });
         it("should return empty array when no entities match", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                }, resources: {}, archetypes: {} });
             // Create entity with only position
             const archetype = store.ensureArchetype(["id", "position"]);
             archetype.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -147,12 +147,12 @@ describe("createStore", () => {
             expect(entities).toHaveLength(0);
         });
         it("should handle complex multi-archetype scenarios", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-                velocity: velocitySchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                    name: nameSchema,
+                    velocity: velocitySchema,
+                }, resources: {}, archetypes: {} });
             // Create entities across many different archetypes
             const archetype1 = store.ensureArchetype(["id", "position"]);
             const entity1 = archetype1.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -213,10 +213,10 @@ describe("createStore", () => {
             expect(positionWithoutHealth).not.toContain(entity8);
         });
         it("should maintain entity order across archetypes", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                }, resources: {}, archetypes: {} });
             // Create entities in different archetypes
             const archetype1 = store.ensureArchetype(["id", "position"]);
             const entity1 = archetype1.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -238,20 +238,20 @@ describe("createStore", () => {
             expect(entities).not.toContain(entity3);
         });
         it("should handle empty store", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {});
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                }, resources: {}, archetypes: {} });
             const entities = store.select(["position"]);
             expect(entities).toHaveLength(0);
         });
         it("should work with resources as components", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Create some entities
             const archetype = store.ensureArchetype(["id", "position"]);
             const entity = archetype.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -273,10 +273,10 @@ describe("createStore", () => {
             }
         };
         it("should create store with resources", () => {
-            const store = createStore({ position: positionSchema }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } }
+                }, archetypes: {} });
             expect(store).toBeDefined();
             expect(store.resources).toBeDefined();
             expect(store.resources.time).toBeDefined();
@@ -285,28 +285,28 @@ describe("createStore", () => {
         it("should initialize resources with default values", () => {
             const defaultTime = { delta: 0.016, elapsed: 0 };
             const defaultConfig = { debug: false, volume: 1.0 };
-            const store = createStore({ position: positionSchema }, {
-                time: { default: defaultTime },
-                config: { default: defaultConfig }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: defaultTime },
+                    config: { default: defaultConfig }
+                }, archetypes: {} });
             expect(store.resources.time).toEqual(defaultTime);
             expect(store.resources.config).toEqual(defaultConfig);
         });
         it("should allow reading resource values", () => {
-            const store = createStore({ position: positionSchema }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } }
+                }, archetypes: {} });
             expect(store.resources.time.delta).toBe(0.016);
             expect(store.resources.time.elapsed).toBe(0);
             expect(store.resources.config.debug).toBe(false);
             expect(store.resources.config.volume).toBe(1.0);
         });
         it("should allow updating resource values", () => {
-            const store = createStore({ position: positionSchema }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } }
+                }, archetypes: {} });
             // Update time
             store.resources.time = { delta: 0.033, elapsed: 1.5 };
             expect(store.resources.time.delta).toBe(0.033);
@@ -317,10 +317,10 @@ describe("createStore", () => {
             expect(store.resources.config.volume).toBe(0.5);
         });
         it("should maintain resource values across updates", () => {
-            const store = createStore({ position: positionSchema }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } }
+                }, archetypes: {} });
             // Update multiple times
             store.resources.time = { delta: 0.033, elapsed: 1.5 };
             store.resources.time = { delta: 0.025, elapsed: 2.0 };
@@ -330,9 +330,9 @@ describe("createStore", () => {
             expect(store.resources.config).toEqual({ debug: true, volume: 0.5 });
         });
         it("should handle nested resource updates", () => {
-            const store = createStore({ position: positionSchema }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Update individual properties
             const newTime = { delta: 0.033, elapsed: 1.5 };
             store.resources.time = newTime;
@@ -340,16 +340,16 @@ describe("createStore", () => {
             expect(store.resources.time.elapsed).toBe(newTime.elapsed);
         });
         it("should work with empty resource object", () => {
-            const store = createStore({ position: positionSchema }, {});
+            const store = createStore({ components: { position: positionSchema }, resources: {}, archetypes: {} });
             expect(store.resources).toBeDefined();
             expect(Object.keys(store.resources)).toHaveLength(0);
         });
         it("should handle multiple resources independently", () => {
-            const store = createStore({ position: positionSchema }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } },
-                score: { default: 0 }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } },
+                    score: { default: 0 }
+                }, archetypes: {} });
             // Update each resource independently
             store.resources.time = { delta: 0.033, elapsed: 1.5 };
             store.resources.config = { debug: true, volume: 0.5 };
@@ -360,24 +360,24 @@ describe("createStore", () => {
             expect(store.resources.score).toBe(100);
         });
         it("should allow querying resources as components", () => {
-            const store = createStore({
-                position: positionSchema,
-                time: timeSchema
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    time: timeSchema
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Resources should be queryable as components
             const timeArchetypes = store.queryArchetypes(["time"]);
             expect(timeArchetypes).toHaveLength(1);
             expect(timeArchetypes[0].components.has("time")).toBe(true);
         });
         it("should maintain resource singleton behavior", () => {
-            const store = createStore({
-                position: positionSchema,
-                time: timeSchema
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    time: timeSchema
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Resources should be queryable as components
             const timeArchetypes = store.queryArchetypes(["time"]);
             expect(timeArchetypes).toHaveLength(1);
@@ -388,11 +388,11 @@ describe("createStore", () => {
             expect(store.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
         });
         it("should handle primitive resource values", () => {
-            const store = createStore({ position: positionSchema }, {
-                score: { default: 0 },
-                name: { default: "Player1" },
-                active: { default: true }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    score: { default: 0 },
+                    name: { default: "Player1" },
+                    active: { default: true }
+                }, archetypes: {} });
             expect(store.resources.score).toBe(0);
             expect(store.resources.name).toBe("Player1");
             expect(store.resources.active).toBe(true);
@@ -415,7 +415,7 @@ describe("createStore", () => {
                 },
                 count: 0
             };
-            const store = createStore({ position: positionSchema }, { complex: { default: complexResource } });
+            const store = createStore({ components: { position: positionSchema }, resources: { complex: { default: complexResource } }, archetypes: {} });
             expect(store.resources.complex).toEqual(complexResource);
             // Update complex resource
             const updatedComplex = {
@@ -432,13 +432,13 @@ describe("createStore", () => {
             expect(store.resources.complex).toEqual(updatedComplex);
         });
         it("should handle array resource schemas", () => {
-            const store = createStore({ position: positionSchema }, {
-                tags: {
-                    type: "array",
-                    items: { type: "string" },
-                    default: ["player", "active"]
-                }
-            });
+            const store = createStore({ components: { position: positionSchema }, resources: {
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        default: ["player", "active"]
+                    }
+                }, archetypes: {} });
             expect(store.resources.tags).toEqual(["player", "active"]);
             // Update array resource
             store.resources.tags = ["enemy", "boss", "elite"];
@@ -447,13 +447,13 @@ describe("createStore", () => {
     });
     describe("Archetype functionality", () => {
         it("should create store with archetypes", () => {
-            const store = createStore({
-                name: { type: "string" },
-                health: { type: "number" },
-                enabled: { type: "boolean" },
-            }, {}, {
-                Player: ["name", "health"],
-            });
+            const store = createStore({ components: {
+                    name: { type: "string" },
+                    health: { type: "number" },
+                    enabled: { type: "boolean" },
+                }, resources: {}, archetypes: {
+                    Player: ["name", "health"],
+                } });
             const entity = store.archetypes.Player.insert({
                 name: "test",
                 health: 100,
@@ -465,9 +465,9 @@ describe("createStore", () => {
     // TimeSchema round-trip test
     describe("TimeSchema functionality", () => {
         it("should store and retrieve Date.now() value correctly", () => {
-            const store = createStore({
-                timestamp: Time.schema,
-            }, {});
+            const store = createStore({ components: {
+                    timestamp: Time.schema,
+                }, resources: {}, archetypes: {} });
             // Create entity with current timestamp
             const now = Date.now();
             const archetype = store.ensureArchetype(["id", "timestamp"]);
@@ -485,13 +485,13 @@ describe("createStore", () => {
     // Serialization/Deserialization tests
     describe("toData/fromData functionality", () => {
         it("should serialize and deserialize store with resources correctly", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } }
+                }, archetypes: {} });
             // Add some entities
             const archetype = store.ensureArchetype(["id", "position", "health"]);
             const entity1 = archetype.insert({
@@ -508,13 +508,13 @@ describe("createStore", () => {
             // Serialize the store
             const serializedData = store.toData();
             // Create a new store with the same schemas and restore
-            const newStore = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } }
-            });
+            const newStore = createStore({ components: {
+                    position: positionSchema,
+                    health: healthSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } }
+                }, archetypes: {} });
             newStore.fromData(serializedData);
             // Verify entities are restored
             const restoredEntities = newStore.select(["position", "health"]);
@@ -538,11 +538,11 @@ describe("createStore", () => {
         });
         it("should create new resources when restoring to store with additional resources", () => {
             // Create original store with only one resource
-            const originalStore = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const originalStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Add some entities and update resource
             const archetype = originalStore.ensureArchetype(["id", "position"]);
             archetype.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -553,13 +553,13 @@ describe("createStore", () => {
             // Note: This is a limitation - when restoring to a store with different archetype structure,
             // entity locations may not be preserved correctly due to archetype ID shifts.
             // In practice, stores should be restored to compatible configurations.
-            const newStore = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } },
-                score: { default: 0 }
-            });
+            const newStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } },
+                    score: { default: 0 }
+                }, archetypes: {} });
             // Restore from serialized data
             newStore.fromData(serializedData);
             // Verify original resource is restored
@@ -579,13 +579,13 @@ describe("createStore", () => {
         });
         it("should handle restoring to store with fewer resources", () => {
             // Create original store with multiple resources
-            const originalStore = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } },
-                config: { default: { debug: false, volume: 1.0 } },
-                score: { default: 0 }
-            });
+            const originalStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } },
+                    config: { default: { debug: false, volume: 1.0 } },
+                    score: { default: 0 }
+                }, archetypes: {} });
             // Add entities and update resources
             const archetype = originalStore.ensureArchetype(["id", "position"]);
             const entity = archetype.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -595,11 +595,11 @@ describe("createStore", () => {
             // Serialize the store
             const serializedData = originalStore.toData();
             // Create new store with only one resource
-            const newStore = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const newStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Restore from serialized data
             newStore.fromData(serializedData);
             // Verify the remaining resource is restored
@@ -618,20 +618,20 @@ describe("createStore", () => {
             });
         });
         it("should preserve resource getter/setter functionality after restoration", () => {
-            const store = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Update resource
             store.resources.time = { delta: 0.033, elapsed: 1.5 };
             // Serialize and deserialize
             const serializedData = store.toData();
-            const newStore = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const newStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             newStore.fromData(serializedData);
             // Verify resource is restored
             expect(newStore.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
@@ -655,11 +655,11 @@ describe("createStore", () => {
                 },
                 count: 0
             };
-            const store = createStore({
-                position: positionSchema,
-            }, {
-                complex: { default: complexResource }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    complex: { default: complexResource }
+                }, archetypes: {} });
             // Update complex resource
             const updatedComplex = {
                 nested: {
@@ -677,11 +677,11 @@ describe("createStore", () => {
             archetype.insert({ position: { x: 1, y: 2, z: 3 } });
             // Serialize and deserialize
             const serializedData = store.toData();
-            const newStore = createStore({
-                position: positionSchema,
-            }, {
-                complex: { default: complexResource }
-            });
+            const newStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    complex: { default: complexResource }
+                }, archetypes: {} });
             newStore.fromData(serializedData);
             // Verify complex resource is restored correctly
             expect(newStore.resources.complex).toEqual(updatedComplex);
@@ -692,11 +692,11 @@ describe("createStore", () => {
         });
         it("should handle empty resource schemas during restoration", () => {
             // Create store with resources
-            const store = createStore({
-                position: positionSchema,
-            }, {
-                time: { default: { delta: 0.016, elapsed: 0 } }
-            });
+            const store = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {
+                    time: { default: { delta: 0.016, elapsed: 0 } }
+                }, archetypes: {} });
             // Add entities and update resource
             const archetype = store.ensureArchetype(["id", "position"]);
             archetype.insert({ position: { x: 1, y: 2, z: 3 } });
@@ -704,9 +704,9 @@ describe("createStore", () => {
             // Serialize
             const serializedData = store.toData();
             // Create new store with no resources
-            const newStore = createStore({
-                position: positionSchema,
-            }, {});
+            const newStore = createStore({ components: {
+                    position: positionSchema,
+                }, resources: {}, archetypes: {} });
             // Restore - should not crash and should preserve entities
             newStore.fromData(serializedData);
             // Verify entities are preserved