@adobe/data 0.2.0 → 0.2.2

package/src/old-ecs/core-ecs/core-ecs-serialization.test.ts

@@ -1,244 +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, expect, test } from "vitest";
-import { ECSJSON } from "./core-ecs-types.js";
-import { createCoreECS } from "./core-ecs.js";
-import { U32Schema } from "../../schema/u32.js";
-
-const createEcsWithMassAndSize = (data?: ECSJSON, precision: 1 | 2 = 2) => {
-  return createCoreECS({ data })
-    .withComponents({
-      mass: { type: "number", minimum: 0, precision },
-      size: { enum: ["small", "medium", "large"] },
-    } as const)
-    .withResources({
-      gravity: 9.8,
-    });
-};
-
-const createEcsWithMassAndSizeAndShape = (data?: ECSJSON) => {
-  return createCoreECS({ data })
-    .withComponents({
-      mass: { type: "number", minimum: 0, precision: 2 },
-      shape: { enum: ["circle", "square", "triangle"] },
-      size: { enum: ["small", "medium", "large"] },
-    } as const)
-    .withResources({
-      gravity: 9.8,
-    });
-};
-
-describe("ecs-functions", () => {
-  test("toJSON with base64 encoded binary data, mass is float64array", () => {
-    const ecs = createEcsWithMassAndSize();
-    const physical = ecs.getArchetype("id", "mass", "size");
-    for (let i = 1; i < 10; i++) {
-      ecs.createEntity(physical, {
-        mass: 3123123123121.232 / i,
-        size: "medium",
-      });
-    }
-    const data = ecs.toJSON();
-    expect(data).toEqual({
-      ecs: true,
-      version: 4,
-      components: {
-        id: U32Schema,
-        mass: { type: "number", minimum: +0, precision: 2 },
-        size: { enum: ["small", "medium", "large"] },
-        gravity: {},
-      },
-      entities: [1, +0, 2, +0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 7, 2, 8],
-      tables: [
-        { rows: +0, columns: { id: [] } },
-        { rows: 1, columns: { gravity: [9.8], id: [+0] } },
-        {
-          rows: 9,
-          columns: {
-            //  id is not base 64 encoded because the json is shorter.
-            id: [1, 2, 3, 4, 5, 6, 7, 8, 9],
-            //  mass is base 64 encoded because the encoded form is shorter.
-            //  This one is longer than the 
-            mass: "24mdJ0W5hkLbiZ0nRbl2QiQN0jRcTG5C24mdJ0W5ZkLiB37s0C1iQiQN0jRcTF5CQwu0CE/4WULbiZ0nRblWQm2zNiPoMlRC",
-            //  size could be compressed efficiently by any general compression algorithm.
-            //  we don't expect large data sets to use strings for components so we don't compress it.
-            size: [
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-            ],
-          },
-        },
-      ],
-    });
-  });
-  test("toJSON with base64 encoded binary data, mass is float32array", () => {
-    const precision = 1;
-    const ecs = createEcsWithMassAndSize(undefined, precision);
-    const physical = ecs.getArchetype("id", "mass", "size");
-    for (let i = 1; i < 10; i++) {
-      ecs.createEntity(physical, {
-        mass: 3123123123121.232 / i,
-        size: "medium",
-      });
-    }
-    const data = ecs.toJSON();
-    expect(data).toEqual({
-      ecs: true,
-      version: 4,
-      components: {
-        id: U32Schema,
-        mass: { type: "number", minimum: +0, precision: 1 },
-        size: { enum: ["small", "medium", "large"] },
-        gravity: {},
-      },
-      entities: [1, +0, 2, +0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5, 2, 6, 2, 7, 2, 8],
-      tables: [
-        { rows: +0, columns: { id: [] } },
-        { rows: 1, columns: { gravity: [9.8], id: [+0] } },
-        {
-          rows: 9,
-          columns: {
-            //  id is not base 64 encoded because the json is shorter.
-            id: [1, 2, 3, 4, 5, 6, 7, 8, 9],
-            //  mass is base 64 encoded because the encoded form is shorter.
-            mass: "Kco1VCnKtVPiYnJTKco1U4duEVPiYvJSeMLPUinKtVJBl6FS",
-            //  size could be compressed efficiently by any general compression algorithm.
-            //  we don't expect large data sets to use strings for components so we don't compress it.
-            size: [
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-              "medium",
-            ],
-          },
-        },
-      ],
-    });
-  });
-  test("toJSON and fromJSON round trip", () => {
-    const ecs = createEcsWithMassAndSize();
-    const physical = ecs.getArchetype("id", "mass", "size");
-    for (let i = 1; i < 10; i++) {
-      ecs.createEntity(physical, {
-        mass: 3123123123121.232 / i,
-        size: "medium",
-      });
-    }
-    const data = ecs.toJSON();
-    const ecs2 = createEcsWithMassAndSize(data);
-    const data2 = ecs2.toJSON();
-    expect(data2).toEqual(data);
-  });
-  test("toJSON and fromJSON round trip with new components", () => {
-    const ecs = createEcsWithMassAndSize();
-    const physical = ecs.getArchetype("id", "mass", "size");
-    for (let i = 1; i < 10; i++) {
-      ecs.createEntity(physical, {
-        mass: 3123123123121.232 / i,
-        size: "medium",
-      });
-    }
-    const data = ecs.toJSON();
-    const ecs2 = createEcsWithMassAndSizeAndShape(data);
-    const physicalAndShaped = ecs2.getArchetype("id", "mass", "size", "shape");
-    ecs2.createEntity(physicalAndShaped, {
-      mass: 98,
-      size: "medium",
-      shape: "circle",
-    });
-
-    const data2 = ecs2.toJSON();
-    const ecs3 = createEcsWithMassAndSizeAndShape(data2);
-
-    const data3 = ecs3.toJSON();
-    expect(data3).toEqual(data2);
-  });
-  test("verify entity data consistency when changing archetypes", () => {
-    const ecs = createEcsWithMassAndSizeAndShape();
-    const initialArchetype = ecs.getArchetype("id", "mass");
-    const targetArchetype = ecs.getArchetype("id", "mass", "shape");
-
-    // Create 100 entities with just mass
-    const entities = [];
-    for (let i = 0; i < 100; i++) {
-      const entity = ecs.createEntity(initialArchetype, {
-        mass: i + 1.5
-      });
-      entities.push(entity);
-    }
-
-    // Update each entity one by one, adding the shape component
-    for (let i = 0; i < entities.length; i++) {
-      const entity = entities[i];
-      const expectedMass = i + 1.5;
-
-      // Update entity to add shape component
-      ecs.updateEntity(entity, {
-        mass: expectedMass,
-        shape: "circle"
-      });
-
-      // Verify the entity data immediately after update
-      const entityData = ecs.getEntityValues(entity);
-      if (!entityData) {
-        throw new Error(`Entity ${entity} not found after update`);
-      }
-
-      if (entityData.mass !== expectedMass) {
-        throw new Error(`Entity ${entity} has incorrect mass. Expected ${expectedMass}, got ${entityData.mass}`);
-      }
-      if (entityData.shape !== "circle") {
-        throw new Error(`Entity ${entity} has incorrect shape. Expected "circle", got ${entityData.shape}`);
-      }
-
-      // Also verify all previously updated entities still have correct data
-      for (let j = 0; j <= i; j++) {
-        const prevEntity = entities[j];
-        const prevData = ecs.getEntityValues(prevEntity);
-        if (!prevData) {
-          throw new Error(`Previously updated entity ${prevEntity} not found`);
-        }
-        const prevExpectedMass = j + 1.5;
-
-        if (prevData.mass !== prevExpectedMass) {
-          throw new Error(`Previously updated entity ${prevEntity} has incorrect mass. Expected ${prevExpectedMass}, got ${prevData.mass}`);
-        }
-        if (prevData.shape !== "circle") {
-          throw new Error(`Previously updated entity ${prevEntity} has incorrect shape. Expected "circle", got ${prevData.shape}`);
-        }
-      }
-    }
-  });
-});

package/src/old-ecs/core-ecs/core-ecs-types.ts

@@ -1,183 +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 { Data } from "../../index.js";
-import { FromSchema, Schema } from "../../schema/index.js";
-import { DeepReadonly, Simplify } from "../../types/types.js";
-import { NativeArray } from "../../cache/managed-array.js";
-
-/**
- * An Entity represents a single object within the ECS.
- * It is a unique positive integer identifier that can be used to access the components of the entity.
- */
-export type Entity = number;
-/**
- * Represents all of an entities values for the given ECS components.
- * This will always contain an id property which is the entity id.
- * All other components are optional.
- */
-export type EntityValues<C> = { id: number } & {
-  [K in keyof C]?: C[K] | undefined;
-};
-/**
- * Represents the values you can use when creating an entity.
- * You cannot provide an id as this is always generated by the ECS.
- */
-export type EntityCreateValues<A> = Omit<A, "id">;
-/**
- * Represents the values you can use when updating an entity.
- * Providing a value of undefined for a component will delete it.
- */
-export type EntityUpdateValues<C> = Omit<
-  { [K in keyof C]?: C[K] | undefined },
-  "id"
->;
-/**
- * The JSON data type that is used to serialize and deserialize ECS data.
- */
-export type ECSJSON = {
-  ecs: true;
-  version: number;
-  components: Record<string, Schema>;
-  entities: readonly number[];
-  tables: { rows: number; columns: Record<string, Data> }[];
-};
-
-export type CoreComponents = { id: number };
-export type CoreResources = { [K: string]: Data };
-
-export interface CoreECS<
-  C extends CoreComponents = CoreComponents,
-  R extends CoreResources = {},
-> extends CoreECSRead<C, R>,
-    CoreECSWrite<C, R> {
-  /**
-   * Creates new components within this ecs and returns the same ecs with the new expanded type information.
-   */
-  withComponents<
-    S extends { readonly [K: string]: DeepReadonly<Schema> },
-    T = { -readonly [K in keyof S]: FromSchema<S[K]> },
-  >(
-    components: S
-  ): CoreECS<Simplify<C & T>, R>;
-  withResources<T extends { readonly [K: string]: Data }>(
-    resources: T
-  ): CoreECS<C, Simplify<R & T>>;
-}
-
-export interface CoreECSRead<
-  C extends CoreComponents = CoreComponents,
-  R extends CoreResources = {},
-> {
-  components: { readonly [K in keyof C]: Schema };
-  resources: R;
-  /**
-   * Returns the component value for the given entity.
-   * @param component the component to read.
-   * @param id if not provided, uses the component own entity id as with resources.
-   */
-  getComponentValue<Name extends keyof C>(
-    id: Entity,
-    component: Name
-  ): C[Name] | undefined;
-  getArchetype<Components extends (keyof C)[]>(
-    ...components: Components
-  ): CoreArchetype<{ [K in Components[number]]: C[K] }>;
-  getEntityValues(id: Entity): EntityValues<C> | undefined;
-  getEntityArchetype(id: Entity): CoreArchetype;
-  countEntities<T extends CoreComponents>(archetype: CoreArchetype<T>): number;
-  selectEntities<T extends CoreComponents>(
-    archetype: CoreArchetype<T>
-  ): Entity[];
-  toJSON(): ECSJSON;
-}
-
-export interface CoreECSWrite<
-  C extends CoreComponents = CoreComponents,
-  R extends CoreResources = {},
-> {
-  createEntity(): Entity;
-  createEntity<T extends CoreComponents>(
-    archetype: CoreArchetype<T>,
-    values: Omit<T, "id">
-  ): Entity;
-  createBatch<T extends CoreComponents>(
-    archetype: CoreArchetype<T>,
-    count: number,
-  ): Table<T>;
-  /**
-   * Sets the value of a component for the given entity.
-   * @param component the component to write.
-   * @param value the value of the component or undefined to delete the component.
-   * @param id if not provided, uses the components own entity id as with resources.
-   */
-  setComponentValue<Name extends keyof C>(
-    id: Entity,
-    component: Name,
-    value: C[Name] | undefined
-  ): void;
-  /**
-   * Gets the tables for the given archetype in read or write mode.
-   * @param exact if true, only returns the single table that exactly matches the archetype.
-   */
-  getTables<T extends CoreComponents>(
-    archetype: CoreArchetype<T>,
-    options: { mode: "read" | "write"; exact?: boolean }
-  ): Table<C>[];
-  updateEntity(id: Entity, values: EntityUpdateValues<C>): void;
-  deleteEntity(id: Entity): void;
-}
-
-export interface CoreArchetype<C = { [K: string]: unknown }> {
-  readonly components: (keyof C)[];
-}
-
-/**
- * A Table represents a collection of entities with the same exact archetype.
- */
-export interface Table<C = { [K: string]: unknown }> {
-  readonly rows: number;
-  readonly columns: { [K in keyof C]: Column<C[K]> };
-}
-
-/**
- * A column represents an array of values for a single component.
- * Each row in the column corresponds to a single entity within the containing Table.
- * The ECS stores data as a structure of arrays.
- */
-export interface Column<T> {
-  get(row: number): T;
-  set(row: number, value: T): void;
-  /**
-   * Allows unsafe direct access to the underlying native array if present.
-   * Not present for constant columns.
-   * For numeric tuples, the array will be of the form [a0, a1, a2, b0, b1, b2, ...]
-   */
-  native?: NativeArray<T extends number[] ? number : T>;
-  /**
-   * Is every value in this column the same?
-   */
-  constant: boolean;
-
-  toJSON(length: number): Data;
-  fromJSON(data: Data, length: number): void;
-}