@adobe/data 0.2.0 → 0.2.2

package/src/ecs/store/create-store.test.ts

@@ -1,562 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { describe, it, expect } from "vitest";
-import { createStore } from "./create-store.js";
-import { createCoreTestSuite, positionSchema, healthSchema, nameSchema } from "./core/create-core.test.js";
-import { Schema } from "../../schema/schema.js";
-import { F32Schema } from "../../schema/f32.js";
-
-describe("createStore", () => {
-    // Test that store passes all core functionality tests
-    createCoreTestSuite("Store core functionality", (componentSchemas) => 
-        createStore(componentSchemas, {})
-    );
-
-    // Select function tests
-    describe("Select functionality", () => {
-        const velocitySchema = {
-            type: "object",
-            properties: {
-                x: F32Schema,
-                y: F32Schema,
-                z: F32Schema,
-            }
-        } as const satisfies Schema;
-
-        it("should select entities from single archetype", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-            }, {});
-
-            // Create entities in a single archetype
-            const archetype = store.ensureArchetype(["id", "position", "health"]);
-            const entity1 = archetype.insert({ 
-                position: { x: 1, y: 2, z: 3 },
-                health: { current: 100, max: 100 }
-            });
-            const entity2 = archetype.insert({ 
-                position: { x: 4, y: 5, z: 6 },
-                health: { current: 50, max: 100 }
-            });
-
-            // Select entities with position and health
-            const entities = store.select(["position", "health"]);
-            expect(entities).toHaveLength(2);
-            expect(entities).toContain(entity1);
-            expect(entities).toContain(entity2);
-        });
-
-        it("should select entities spanning multiple archetypes", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-                velocity: velocitySchema,
-            }, {});
-
-            // Create entities in different archetypes
-            const positionOnlyArchetype = store.ensureArchetype(["id", "position"]);
-            const entity1 = positionOnlyArchetype.insert({ 
-                position: { x: 1, y: 2, z: 3 }
-            });
-            const entity2 = positionOnlyArchetype.insert({ 
-                position: { x: 4, y: 5, z: 6 }
-            });
-
-            const healthOnlyArchetype = store.ensureArchetype(["id", "health"]);
-            const entity3 = healthOnlyArchetype.insert({ 
-                health: { current: 100, max: 100 }
-            });
-
-            const positionHealthArchetype = store.ensureArchetype(["id", "position", "health"]);
-            const entity4 = positionHealthArchetype.insert({ 
-                position: { x: 0, y: 0, z: 0 },
-                health: { current: 50, max: 100 }
-            });
-
-            const velocityArchetype = store.ensureArchetype(["id", "velocity"]);
-            const entity5 = velocityArchetype.insert({ 
-                velocity: { x: 1, y: 0, z: 0 }
-            });
-
-            // Select all entities with position component (should span 2 archetypes)
-            const positionEntities = store.select(["position"]);
-            expect(positionEntities).toHaveLength(3);
-            expect(positionEntities).toContain(entity1);
-            expect(positionEntities).toContain(entity2);
-            expect(positionEntities).toContain(entity4);
-            expect(positionEntities).not.toContain(entity3);
-            expect(positionEntities).not.toContain(entity5);
-
-            // Select all entities with health component (should span 2 archetypes)
-            const healthEntities = store.select(["health"]);
-            expect(healthEntities).toHaveLength(2);
-            expect(healthEntities).toContain(entity3);
-            expect(healthEntities).toContain(entity4);
-            expect(healthEntities).not.toContain(entity1);
-            expect(healthEntities).not.toContain(entity2);
-            expect(healthEntities).not.toContain(entity5);
-
-            // Select entities with both position and health (should be only 1 archetype)
-            const bothEntities = store.select(["position", "health"]);
-            expect(bothEntities).toHaveLength(1);
-            expect(bothEntities).toContain(entity4);
-            expect(bothEntities).not.toContain(entity1);
-            expect(bothEntities).not.toContain(entity2);
-            expect(bothEntities).not.toContain(entity3);
-            expect(bothEntities).not.toContain(entity5);
-        });
-
-        it("should select entities with exclude option", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-            }, {});
-
-            // Create entities in different archetypes
-            const positionOnlyArchetype = store.ensureArchetype(["id", "position"]);
-            const entity1 = positionOnlyArchetype.insert({ 
-                position: { x: 1, y: 2, z: 3 }
-            });
-
-            const positionHealthArchetype = store.ensureArchetype(["id", "position", "health"]);
-            const entity2 = positionHealthArchetype.insert({ 
-                position: { x: 0, y: 0, z: 0 },
-                health: { current: 50, max: 100 }
-            });
-
-            // Select entities with position but exclude health
-            const positionOnlyEntities = store.select(["position"], { exclude: ["health"] });
-            expect(positionOnlyEntities).toHaveLength(1);
-            expect(positionOnlyEntities).toContain(entity1);
-            expect(positionOnlyEntities).not.toContain(entity2);
-        });
-
-        it("should return empty array when no entities match", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {});
-
-            // Create entity with only position
-            const archetype = store.ensureArchetype(["id", "position"]);
-            archetype.insert({ position: { x: 1, y: 2, z: 3 } });
-
-            // Select entities with health (should be empty)
-            const entities = store.select(["health"]);
-            expect(entities).toHaveLength(0);
-        });
-
-        it("should handle complex multi-archetype scenarios", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-                name: nameSchema,
-                velocity: velocitySchema,
-            }, {});
-
-            // Create entities across many different archetypes
-            const archetype1 = store.ensureArchetype(["id", "position"]);
-            const entity1 = archetype1.insert({ position: { x: 1, y: 2, z: 3 } });
-            const entity2 = archetype1.insert({ position: { x: 4, y: 5, z: 6 } });
-
-            const archetype2 = store.ensureArchetype(["id", "health"]);
-            const entity3 = archetype2.insert({ health: { current: 100, max: 100 } });
-
-            const archetype3 = store.ensureArchetype(["id", "position", "health"]);
-            const entity4 = archetype3.insert({ 
-                position: { x: 0, y: 0, z: 0 },
-                health: { current: 50, max: 100 }
-            });
-            const entity5 = archetype3.insert({ 
-                position: { x: 10, y: 20, z: 30 },
-                health: { current: 75, max: 100 }
-            });
-
-            const archetype4 = store.ensureArchetype(["id", "name"]);
-            const entity6 = archetype4.insert({ name: "Player1" });
-
-            const archetype5 = store.ensureArchetype(["id", "position", "name"]);
-            const entity7 = archetype5.insert({ 
-                position: { x: 100, y: 200, z: 300 },
-                name: "Player2"
-            });
-
-            const archetype6 = store.ensureArchetype(["id", "position", "health", "name"]);
-            const entity8 = archetype6.insert({ 
-                position: { x: 500, y: 600, z: 700 },
-                health: { current: 25, max: 100 },
-                name: "Player3"
-            });
-
-            // Test various selection scenarios
-            const positionEntities = store.select(["position"]);
-            expect(positionEntities).toHaveLength(6);
-            expect(positionEntities).toContain(entity1);
-            expect(positionEntities).toContain(entity2);
-            expect(positionEntities).toContain(entity4);
-            expect(positionEntities).toContain(entity5);
-            expect(positionEntities).toContain(entity7);
-            expect(positionEntities).toContain(entity8);
-
-            const nameEntities = store.select(["name"]);
-            expect(nameEntities).toHaveLength(3);
-            expect(nameEntities).toContain(entity6);
-            expect(nameEntities).toContain(entity7);
-            expect(nameEntities).toContain(entity8);
-
-            const positionNameEntities = store.select(["position", "name"]);
-            expect(positionNameEntities).toHaveLength(2);
-            expect(positionNameEntities).toContain(entity7);
-            expect(positionNameEntities).toContain(entity8);
-
-            const allThreeEntities = store.select(["position", "health", "name"]);
-            expect(allThreeEntities).toHaveLength(1);
-            expect(allThreeEntities).toContain(entity8);
-
-            // Test exclusion
-            const positionWithoutHealth = store.select(["position"], { exclude: ["health"] });
-            expect(positionWithoutHealth).toHaveLength(3);
-            expect(positionWithoutHealth).toContain(entity1);
-            expect(positionWithoutHealth).toContain(entity2);
-            expect(positionWithoutHealth).toContain(entity7);
-            expect(positionWithoutHealth).not.toContain(entity4);
-            expect(positionWithoutHealth).not.toContain(entity5);
-            expect(positionWithoutHealth).not.toContain(entity8);
-        });
-
-        it("should maintain entity order across archetypes", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {});
-
-            // Create entities in different archetypes
-            const archetype1 = store.ensureArchetype(["id", "position"]);
-            const entity1 = archetype1.insert({ position: { x: 1, y: 2, z: 3 } });
-            const entity2 = archetype1.insert({ position: { x: 4, y: 5, z: 6 } });
-
-            const archetype2 = store.ensureArchetype(["id", "health"]);
-            const entity3 = archetype2.insert({ health: { current: 100, max: 100 } });
-
-            const archetype3 = store.ensureArchetype(["id", "position", "health"]);
-            const entity4 = archetype3.insert({ 
-                position: { x: 0, y: 0, z: 0 },
-                health: { current: 50, max: 100 }
-            });
-
-            // Select all entities with position
-            const entities = store.select(["position"]);
-            expect(entities).toHaveLength(3);
-            
-            // Verify all expected entities are present (order may vary)
-            expect(entities).toContain(entity1);
-            expect(entities).toContain(entity2);
-            expect(entities).toContain(entity4);
-            expect(entities).not.toContain(entity3);
-        });
-
-        it("should handle empty store", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {});
-
-            const entities = store.select(["position"]);
-            expect(entities).toHaveLength(0);
-        });
-
-        it("should work with resources as components", () => {
-            const store = createStore({
-                position: positionSchema,
-                health: healthSchema,
-            }, {
-                time: { delta: 0.016, elapsed: 0 }
-            });
-
-            // Create some entities
-            const archetype = store.ensureArchetype(["id", "position"]);
-            const entity = archetype.insert({ position: { x: 1, y: 2, z: 3 } });
-
-            // Select entities with time component (should include the resource entity)
-            const timeEntities = store.select(["time" as any]);
-            expect(timeEntities).toHaveLength(1);
-            
-            // The resource entity should be included in time queries
-            const timeArchetypes = store.queryArchetypes(["time" as any]);
-            expect(timeArchetypes).toHaveLength(1);
-        });
-    });
-
-    // Store-specific resource tests
-    describe("Resource functionality", () => {
-        const timeSchema = {
-            type: "object",
-            properties: {
-                delta: F32Schema,
-                elapsed: F32Schema,
-            }
-        } as const satisfies Schema;
-
-        const configSchema = {
-            type: "object",
-            properties: {
-                debug: { type: "boolean" },
-                volume: F32Schema,
-            }
-        } as const satisfies Schema;
-
-        it("should create store with resources", () => {
-            const store = createStore(
-                { position: positionSchema },
-                { 
-                    time: { delta: 0.016, elapsed: 0 },
-                    config: { debug: false, volume: 1.0 }
-                }
-            );
-
-            expect(store).toBeDefined();
-            expect(store.resources).toBeDefined();
-            expect(store.resources.time).toBeDefined();
-            expect(store.resources.config).toBeDefined();
-        });
-
-        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: defaultTime,
-                    config: defaultConfig
-                }
-            );
-
-            expect(store.resources.time).toEqual(defaultTime);
-            expect(store.resources.config).toEqual(defaultConfig);
-        });
-
-        it("should allow reading resource values", () => {
-            const store = createStore(
-                { position: positionSchema },
-                { 
-                    time: { delta: 0.016, elapsed: 0 },
-                    config: { debug: false, volume: 1.0 }
-                }
-            );
-
-            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: { delta: 0.016, elapsed: 0 },
-                    config: { debug: false, volume: 1.0 }
-                }
-            );
-
-            // Update time
-            store.resources.time = { delta: 0.033, elapsed: 1.5 };
-            expect(store.resources.time.delta).toBe(0.033);
-            expect(store.resources.time.elapsed).toBe(1.5);
-
-            // Update config
-            store.resources.config = { debug: true, volume: 0.5 };
-            expect(store.resources.config.debug).toBe(true);
-            expect(store.resources.config.volume).toBe(0.5);
-        });
-
-        it("should maintain resource values across updates", () => {
-            const store = createStore(
-                { position: positionSchema },
-                { 
-                    time: { delta: 0.016, elapsed: 0 },
-                    config: { debug: false, volume: 1.0 }
-                }
-            );
-
-            // Update multiple times
-            store.resources.time = { delta: 0.033, elapsed: 1.5 };
-            store.resources.time = { delta: 0.025, elapsed: 2.0 };
-            store.resources.config = { debug: true, volume: 0.5 };
-
-            // Verify final values
-            expect(store.resources.time).toEqual({ delta: 0.025, elapsed: 2.0 });
-            expect(store.resources.config).toEqual({ debug: true, volume: 0.5 });
-        });
-
-        it("should handle nested resource updates", () => {
-            const store = createStore(
-                { position: positionSchema },
-                { 
-                    time: { delta: 0.016, elapsed: 0 }
-                }
-            );
-
-            // Update individual properties
-            const newTime = { delta: 0.033, elapsed: 1.5 };
-            store.resources.time = newTime;
-
-            expect(store.resources.time.delta).toBe(newTime.delta);
-            expect(store.resources.time.elapsed).toBe(newTime.elapsed);
-        });
-
-        it("should work with empty resource object", () => {
-            const store = createStore(
-                { position: positionSchema },
-                {}
-            );
-
-            expect(store.resources).toBeDefined();
-            expect(Object.keys(store.resources)).toHaveLength(0);
-        });
-
-        it("should handle multiple resources independently", () => {
-            const store = createStore(
-                { position: positionSchema },
-                { 
-                    time: { delta: 0.016, elapsed: 0 },
-                    config: { debug: false, volume: 1.0 },
-                    score: 0
-                }
-            );
-
-            // Update each resource independently
-            store.resources.time = { delta: 0.033, elapsed: 1.5 };
-            store.resources.config = { debug: true, volume: 0.5 };
-            store.resources.score = 100;
-
-            // Verify all resources maintain their values
-            expect(store.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
-            expect(store.resources.config).toEqual({ debug: true, volume: 0.5 });
-            expect(store.resources.score).toBe(100);
-        });
-
-        it("should allow querying resources as components", () => {
-            const store = createStore(
-                { 
-                    position: positionSchema,
-                    time: timeSchema
-                },
-                { 
-                    time: { delta: 0.016, elapsed: 0 }
-                }
-            );
-
-            // 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: { delta: 0.016, elapsed: 0 }
-                }
-            );
-
-            // Resources should be queryable as components
-            const timeArchetypes = store.queryArchetypes(["time"]);
-            expect(timeArchetypes).toHaveLength(1);
-            
-            // Resources should maintain their values
-            expect(store.resources.time).toEqual({ delta: 0.016, elapsed: 0 });
-            
-            // Update and verify
-            store.resources.time = { delta: 0.033, elapsed: 1.5 };
-            expect(store.resources.time).toEqual({ delta: 0.033, elapsed: 1.5 });
-        });
-
-        it("should handle primitive resource values", () => {
-            const store = createStore(
-                { position: positionSchema },
-                { 
-                    score: 0,
-                    name: "Player1",
-                    active: true
-                }
-            );
-
-            expect(store.resources.score).toBe(0);
-            expect(store.resources.name).toBe("Player1");
-            expect(store.resources.active).toBe(true);
-
-            // Update primitive values
-            store.resources.score = 100;
-            store.resources.name = "Player2";
-            store.resources.active = false;
-
-            expect(store.resources.score).toBe(100);
-            expect(store.resources.name).toBe("Player2");
-            expect(store.resources.active).toBe(false);
-        });
-
-        it("should handle complex resource objects", () => {
-            const complexResource = {
-                nested: {
-                    deep: {
-                        value: 42,
-                        array: [1, 2, 3],
-                        flag: true
-                    }
-                },
-                count: 0
-            };
-
-            const store = createStore(
-                { position: positionSchema },
-                { complex: complexResource }
-            );
-
-            expect(store.resources.complex).toEqual(complexResource);
-
-            // Update complex resource
-            const updatedComplex = {
-                nested: {
-                    deep: {
-                        value: 100,
-                        array: [4, 5, 6],
-                        flag: false
-                    }
-                },
-                count: 10
-            };
-
-            store.resources.complex = updatedComplex;
-            expect(store.resources.complex).toEqual(updatedComplex);
-        });
-    });
-}); 

package/src/ecs/store/create-store.ts

@@ -1,97 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-import { ResourceComponents } from "./resource-components.js";
-import { ComponentSchemas } from "../component-schemas.js";
-import { StringKeyof } from "../../types/types.js";
-import { CoreComponents } from "../core-components.js";
-import { Simplify } from "../../types/index.js";
-import { Store } from "./store.js";
-import { FromSchema, Schema } from "../../schema/schema.js";
-import { createCore } from "./core/create-core.js";
-import { Entity } from "../entity.js";
-import { Core, QueryOptions } from "./core/core.js";
-
-export function createStore<NC extends ComponentSchemas, R extends ResourceComponents>(
-    newComponentSchemas: NC,
-    resourceDefaults: R,
-): Store<Simplify<CoreComponents & { [K in StringKeyof<NC>]: FromSchema<NC[K]> }>, { -readonly [K in StringKeyof<R>]: R[K] }> {
-    type C = CoreComponents & { [K in StringKeyof<NC>]: FromSchema<NC[K]> };
-    const resources = {} as R;
-    type S = StringKeyof<C>;
-
-    const resourceSchema = {} as const satisfies Schema;
-    const componentAndResourceSchemas: { [K in StringKeyof<C | R>]: Schema } = { ...newComponentSchemas };
-    // Resources are stored in the core as components, so we need to add them to the componentSchemas
-    for (const name of Object.keys(resourceDefaults)) {
-        const resourceId = name as StringKeyof<C | R>;
-        componentAndResourceSchemas[resourceId] = resourceSchema;
-    }
-
-    const core = createCore(componentAndResourceSchemas) as unknown as Core<C>;
-
-    // Each resource will be stored as the only entity in an archetype of [id, <resourceName>]
-    // The resource component we added above will contain the resource value
-    for (const [name, resource] of Object.entries(resourceDefaults)) {
-        const resourceId = name as StringKeyof<C>;
-        const archetype = core.ensureArchetype(["id", resourceId]);
-        archetype.insert({ [resourceId]: resource } as any);
-        const row = 0;
-        Object.defineProperty(resources, name, {
-            get: () => archetype.columns[resourceId]!.get(row),
-            set: (value) => {
-                archetype.columns[resourceId]!.set(row, value);
-            },
-            enumerable: true,
-        });
-    }
-
-    const select = <
-        Include extends StringKeyof<C>,
-        Exclude extends StringKeyof<C> = never
-    >(
-        include: Include[],
-        options?: QueryOptions<Include, Exclude>
-    ): readonly Entity[] => {
-        const archetypes = core.queryArchetypes(include, options);
-        let length = 0;
-        for (const archetype of archetypes) {
-            length += archetype.rows;
-        }
-        const entities = new Array<Entity>(length);
-        let index = 0;
-        for (const archetype of archetypes) {
-            const typedArray = archetype.columns.id.getTypedArray();
-            for (let i = 0; i < archetype.rows; i++) {
-                entities[index++] = typedArray[i];
-            }
-        }
-        return entities;
-    }
-
-    const store: Store<C, R> = {
-        ...core,
-        resources,
-        select,
-    };
-    
-    return store as any;
-}

package/src/ecs/store/index.ts

@@ -1,23 +0,0 @@
-/*MIT License
-
-© Copyright 2025 Adobe. All rights reserved.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.*/
-export * from "./store.js";
-export * from "./create-store.js";