@adobe/data 0.2.1 → 0.2.3

package/src/ecs/store/resource-components.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 type ResourceComponents = object;

package/src/ecs/store/store.ts

@@ -1,55 +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 { CoreComponents } from "../core-components.js";
-import { ResourceComponents } from "./resource-components.js";
-import { Core, QueryOptions, ReadonlyCore } from "./core/core.js";
-import { Entity } from "../entity.js";
-import { StringKeyof } from "../../types/types.js";
-
-interface BaseStore<C extends CoreComponents> {
-    select<
-        Include extends StringKeyof<C>,
-        Exclude extends StringKeyof<C> = never
-    >(
-        include: Include[],
-        options?: QueryOptions<Include, Exclude>
-    ): readonly Entity[];
-}
-
-export interface ReadonlyStore<
-    C extends CoreComponents = CoreComponents,
-    R extends ResourceComponents = never
-> extends BaseStore<C>, ReadonlyCore<C> {
-    readonly resources: { readonly [K in StringKeyof<R>]: R[K] };
-}
-
-export type ToReadonlyStore<T extends Store<any, any>> = T extends Store<infer C, infer R> ? ReadonlyStore<C, R> : never;
-
-/**
- * Store is the main interface for storing components, entities and resources.
- */
-export interface Store<
-    C extends CoreComponents = CoreComponents,
-    R extends ResourceComponents = never
-> extends BaseStore<C>, Core<C> {
-    readonly resources: { -readonly [K in StringKeyof<R>]: R[K] };
-}

package/src/equals-shallow.test.ts

@@ -1,133 +0,0 @@
-import { equalsShallow } from './equals-shallow.js';
-import { describe, expect, it } from 'vitest';
-
-describe('equalsShallow', () => {
-  describe('primitives and identical refs', () => {
-    it('should return true for identical primitive values', () => {
-      expect(equalsShallow(1, 1)).toBe(true);
-      expect(equalsShallow('hello', 'hello')).toBe(true);
-      expect(equalsShallow(true, true)).toBe(true);
-      expect(equalsShallow(false, false)).toBe(true);
-      expect(equalsShallow(undefined, undefined)).toBe(true);
-      expect(equalsShallow(null, null)).toBe(true);
-    });
-
-    it('should return true for identical object references', () => {
-      const obj = { a: 1 };
-      expect(equalsShallow(obj, obj)).toBe(true);
-      
-      const arr = [1, 2, 3];
-      expect(equalsShallow(arr, arr)).toBe(true);
-    });
-
-    it('should return false for different primitive values', () => {
-      expect(equalsShallow(1, 2)).toBe(false);
-      expect(equalsShallow('hello', 'world')).toBe(false);
-      expect(equalsShallow(true, false)).toBe(false);
-      expect(equalsShallow(1, '1')).toBe(false);
-    });
-  });
-
-  describe('null and non-objects', () => {
-    it('should return false when one is null and other is not', () => {
-      expect(equalsShallow(null, {})).toBe(false);
-      expect(equalsShallow({}, null)).toBe(false);
-      expect(equalsShallow(null, [])).toBe(false);
-      expect(equalsShallow([], null)).toBe(false);
-    });
-
-    it('should return false when one is not an object', () => {
-      expect(equalsShallow(1, {})).toBe(false);
-      expect(equalsShallow({}, 1)).toBe(false);
-      expect(equalsShallow('string', [])).toBe(false);
-      expect(equalsShallow([], 'string')).toBe(false);
-    });
-  });
-
-  describe('arrays', () => {
-    it('should return true for identical arrays', () => {
-      expect(equalsShallow([1, 2, 3], [1, 2, 3])).toBe(true);
-      expect(equalsShallow(['a', 'b'], ['a', 'b'])).toBe(true);
-      expect(equalsShallow([], [])).toBe(true);
-    });
-
-    it('should return false when one is array and other is not', () => {
-      expect(equalsShallow([1, 2, 3], {})).toBe(false);
-      expect(equalsShallow({}, [1, 2, 3])).toBe(false);
-    });
-
-    it('should return false for arrays with different lengths', () => {
-      expect(equalsShallow([1, 2], [1, 2, 3])).toBe(false);
-      expect(equalsShallow([1, 2, 3], [1, 2])).toBe(false);
-    });
-
-    it('should return false for arrays with different elements', () => {
-      expect(equalsShallow([1, 2, 3], [1, 2, 4])).toBe(false);
-      expect(equalsShallow([1, 2, 3], [1, 3, 2])).toBe(false);
-    });
-
-    it('should handle nested objects in arrays (shallow comparison)', () => {
-      const obj1 = { a: 1 };
-      const obj2 = { a: 1 };
-      expect(equalsShallow([obj1], [obj1])).toBe(true);
-      expect(equalsShallow([obj1], [obj2])).toBe(false); // Different references
-    });
-  });
-
-  describe('plain objects', () => {
-    it('should return true for identical objects', () => {
-      expect(equalsShallow({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
-      expect(equalsShallow({}, {})).toBe(true);
-    });
-
-    it('should return false for objects with different values', () => {
-      expect(equalsShallow({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
-      expect(equalsShallow({ a: 1 }, { a: 2 })).toBe(false);
-    });
-
-    it('should return false for objects with different keys', () => {
-      expect(equalsShallow({ a: 1, b: 2 }, { a: 1, c: 2 })).toBe(false);
-      expect(equalsShallow({ a: 1 }, { b: 1 })).toBe(false);
-    });
-
-    it('should return false when one object has extra keys', () => {
-      expect(equalsShallow({ a: 1 }, { a: 1, b: 2 })).toBe(false);
-      expect(equalsShallow({ a: 1, b: 2 }, { a: 1 })).toBe(false);
-    });
-
-    it('should handle nested objects (shallow comparison)', () => {
-      const nested1 = { x: 1 };
-      const nested2 = { x: 1 };
-      expect(equalsShallow({ a: nested1 }, { a: nested1 })).toBe(true);
-      expect(equalsShallow({ a: nested1 }, { a: nested2 })).toBe(false); // Different references
-    });
-
-    it('should handle arrays as object values (shallow comparison)', () => {
-      const arr1 = [1, 2, 3];
-      const arr2 = [1, 2, 3];
-      expect(equalsShallow({ a: arr1 }, { a: arr1 })).toBe(true);
-      expect(equalsShallow({ a: arr1 }, { a: arr2 })).toBe(false); // Different references
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle objects with same keys but different order', () => {
-      expect(equalsShallow({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true);
-    });
-
-    it('should handle objects with undefined values', () => {
-      expect(equalsShallow({ a: undefined }, { a: undefined })).toBe(true);
-      expect(equalsShallow({ a: undefined }, { a: 1 })).toBe(false);
-    });
-
-    it('should handle objects with null values', () => {
-      expect(equalsShallow({ a: null }, { a: null })).toBe(true);
-      expect(equalsShallow({ a: null }, { a: 1 })).toBe(false);
-    });
-
-    it('should handle mixed types in arrays', () => {
-      expect(equalsShallow([1, 'string', true], [1, 'string', true])).toBe(true);
-      expect(equalsShallow([1, 'string', true], [1, 'string', false])).toBe(false);
-    });
-  });
-}); 

package/src/equals-shallow.ts

@@ -1,37 +0,0 @@
-
-export function equalsShallow(a: unknown, b: unknown): boolean {
-    // primitives / identical refs
-    if (a === b) return true;
-    if (
-      a === null || b === null ||
-      typeof a !== "object" || typeof b !== "object"
-    ) return false;
-  
-    // arrays
-    if (Array.isArray(a)) {
-      if (!Array.isArray(b)) return false;
-      const aa = a as unknown[];
-      const bb = b as unknown[];
-      if (aa.length !== bb.length) return false;
-      for (let i = 0; i < aa.length; i++) {
-        if (aa[i] !== bb[i]) return false;
-      }
-      return true;
-    }
-    if (Array.isArray(b)) return false;
-  
-    // plain objects
-    let keysA = 0;
-    for (const k in a as Record<string, unknown>) {
-      if ((a as Record<string, unknown>)[k] !== (b as Record<string, unknown>)[k])
-        return false;
-      keysA++;
-    }
-  
-    // ensure no extra keys in b
-    let keysB = 0;
-    for (const _ in b as Record<string, unknown>) keysB++;
-  
-    return keysA === keysB;
-  }
-  

package/src/equals.test.ts

@@ -1,175 +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 { equals } from './equals.js';
-import { describe, expect, it } from 'vitest';
-
-describe('equals', () => {
-  describe('primitives and identical references', () => {
-    it('should return true for identical primitive values', () => {
-      expect(equals(42, 42)).toBe(true);
-      expect(equals('hello', 'hello')).toBe(true);
-      expect(equals(true, true)).toBe(true);
-      expect(equals(false, false)).toBe(true);
-    });
-
-    it('should return true for identical object references', () => {
-      const obj = { a: 1 };
-      expect(equals(obj, obj)).toBe(true);
-    });
-
-    it('should return false for different primitive values', () => {
-      expect(equals(42, 43)).toBe(false);
-      expect(equals('hello', 'world')).toBe(false);
-      expect(equals(true, false)).toBe(false);
-    });
-  });
-
-  describe('null and undefined handling', () => {
-    it('should return false when one value is null and other is not', () => {
-      expect(equals(null, 42)).toBe(false);
-      expect(equals(42, null)).toBe(false);
-      expect(equals(null, 'hello')).toBe(false);
-      expect(equals('hello', null)).toBe(false);
-    });
-
-    it('should return false when one value is undefined and other is not', () => {
-      expect(equals(undefined, 42)).toBe(false);
-      expect(equals(42, undefined)).toBe(false);
-      expect(equals(undefined, 'hello')).toBe(false);
-      expect(equals('hello', undefined)).toBe(false);
-    });
-
-    it('should return false when one is null and other is undefined', () => {
-      expect(equals(null, undefined)).toBe(false);
-      expect(equals(undefined, null)).toBe(false);
-    });
-  });
-
-  describe('type mismatch handling', () => {
-    it('should return false when one is primitive and other is object', () => {
-      expect(equals(42, {})).toBe(false);
-      expect(equals({}, 42)).toBe(false);
-      expect(equals('hello', [])).toBe(false);
-      expect(equals([], 'hello')).toBe(false);
-    });
-  });
-
-  describe('arrays', () => {
-    it('should return true for identical arrays', () => {
-      expect(equals([1, 2, 3], [1, 2, 3])).toBe(true);
-      expect(equals(['a', 'b'], ['a', 'b'])).toBe(true);
-      expect(equals([], [])).toBe(true);
-    });
-
-    it('should return false when one is array and other is object', () => {
-      expect(equals([1, 2, 3], { 0: 1, 1: 2, 2: 3 })).toBe(false);
-      expect(equals({ 0: 1, 1: 2, 2: 3 }, [1, 2, 3])).toBe(false);
-    });
-
-    it('should return false for arrays with different lengths', () => {
-      expect(equals([1, 2], [1, 2, 3])).toBe(false);
-      expect(equals([1, 2, 3], [1, 2])).toBe(false);
-    });
-
-    it('should return false for arrays with different values', () => {
-      expect(equals([1, 2, 3], [1, 2, 4])).toBe(false);
-      expect(equals([1, 2, 3], [1, 3, 2])).toBe(false);
-    });
-
-    it('should handle nested arrays', () => {
-      expect(equals([[1, 2], [3, 4]], [[1, 2], [3, 4]])).toBe(true);
-      expect(equals([[1, 2], [3, 4]], [[1, 2], [3, 5]])).toBe(false);
-    });
-
-    it('should handle arrays with mixed content', () => {
-      expect(equals([1, 'hello', { a: 1 }], [1, 'hello', { a: 1 }])).toBe(true);
-      expect(equals([1, 'hello', { a: 1 }], [1, 'hello', { a: 2 }])).toBe(false);
-    });
-  });
-
-  describe('objects', () => {
-    it('should return true for identical objects', () => {
-      expect(equals({ a: 1, b: 2 }, { a: 1, b: 2 })).toBe(true);
-      expect(equals({}, {})).toBe(true);
-    });
-
-    it('should return false for objects with different keys', () => {
-      expect(equals({ a: 1 }, { b: 1 })).toBe(false);
-      expect(equals({ a: 1, b: 2 }, { a: 1 })).toBe(false);
-      expect(equals({ a: 1 }, { a: 1, b: 2 })).toBe(false);
-    });
-
-    it('should return false for objects with same keys but different values', () => {
-      expect(equals({ a: 1, b: 2 }, { a: 1, b: 3 })).toBe(false);
-      expect(equals({ a: 1 }, { a: 2 })).toBe(false);
-    });
-
-    it('should handle nested objects', () => {
-      expect(equals({ a: { b: 1 } }, { a: { b: 1 } })).toBe(true);
-      expect(equals({ a: { b: 1 } }, { a: { b: 2 } })).toBe(false);
-    });
-
-    it('should handle objects with arrays', () => {
-      expect(equals({ a: [1, 2] }, { a: [1, 2] })).toBe(true);
-      expect(equals({ a: [1, 2] }, { a: [1, 3] })).toBe(false);
-    });
-
-    it('should handle complex nested structures', () => {
-      const obj1 = { a: [1, { b: 2, c: [3, 4] }], d: { e: 5 } };
-      const obj2 = { a: [1, { b: 2, c: [3, 4] }], d: { e: 5 } };
-      const obj3 = { a: [1, { b: 2, c: [3, 5] }], d: { e: 5 } };
-      
-      expect(equals(obj1, obj2)).toBe(true);
-      expect(equals(obj1, obj3)).toBe(false);
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle objects with numeric keys', () => {
-      expect(equals({ '0': 1, '1': 2 }, { '0': 1, '1': 2 })).toBe(true);
-      expect(equals({ '0': 1, '1': 2 }, { '0': 1, '1': 3 })).toBe(false);
-    });
-
-    it('should handle empty arrays and objects', () => {
-      expect(equals([], [])).toBe(true);
-      expect(equals({}, {})).toBe(true);
-      expect(equals([], {})).toBe(false);
-    });
-
-    it('should handle objects with undefined values', () => {
-      expect(equals({ a: undefined }, { a: undefined })).toBe(true);
-      expect(equals({ a: undefined }, { a: null })).toBe(false);
-    });
-
-    it('should handle objects with null values', () => {
-      expect(equals({ a: null }, { a: null })).toBe(true);
-      expect(equals({ a: null }, { a: undefined })).toBe(false);
-    });
-
-    it('should handle NaN values', () => {
-      expect(equals(NaN, NaN)).toBe(true);
-      expect(equals(NaN, 42)).toBe(false);
-      expect(equals(42, NaN)).toBe(false);
-    });
-  });
-}); 

package/src/equals.ts

@@ -1,70 +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.*/
-
-/**
- * Very-fast deep equality for JSON-style values.
- *
- * Assumptions
- * ───────────
- * • Only JSON primitives, plain objects, and arrays appear.
- * • Objects have **no prototype chain** (so every enumerable key is "own,"
- *   letting us skip costly `hasOwnProperty` checks).
- * • No cyclic references (add a WeakMap if you need that).
- */
-export function equals(a: unknown, b: unknown): boolean {
-  // 1  Primitives / identical reference
-  if (Object.is(a, b)) return true; // Handles NaN === NaN
-  if (a == null || b == null) return false;          // null / undefined mismatch
-  if (typeof a !== "object" || typeof b !== "object") return false;
-
-  // 2  Arrays
-  const aIsArr = Array.isArray(a);
-  const bIsArr = Array.isArray(b);
-  if (aIsArr || bIsArr) {
-    if (aIsArr !== bIsArr) return false;             // one array, one object
-    const aa = a as unknown[];
-    const bb = b as unknown[];
-    if (aa.length !== bb.length) return false;
-    for (let i = 0; i < aa.length; i++) {
-      if (!equals(aa[i], bb[i])) return false;
-    }
-    return true;
-  }
-
-  // 3  Plain objects
-  const ao = a as Record<string, unknown>;
-  const bo = b as Record<string, unknown>;
-
-  let keyBalance = 0;                                // = keys(a) – keys(b)
-
-  // Pass 1: walk keys of a, compare values, and tally count.
-  for (const k in ao) {
-    keyBalance++;                                    // saw a key from a
-    if (!(k in bo)) return false;                    // missing in b
-    if (!equals(ao[k], bo[k])) return false;         // value differs
-  }
-
-  // Pass 2: walk keys of b to detect extras.
-  for (const _ in bo) keyBalance--;
-
-  return keyBalance === 0;                           // zero ⇒ same key set
-}

package/src/index.ts

@@ -1,27 +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 { type Data } from "./data.js";
-export { type IsData } from "./is-data.js";
-export { equals } from "./equals.js";
-export { normalize} from "./normalize.js";
-export { mutableClone } from "./mutable-clone.js";