@adobe/data 0.1.3 → 0.2.1

package/src/ecs/store/store.ts

@@ -0,0 +1,55 @@
+/*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

@@ -0,0 +1,133 @@
+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

@@ -0,0 +1,37 @@
+
+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

@@ -0,0 +1,175 @@
+/*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

@@ -0,0 +1,70 @@
+/*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

@@ -0,0 +1,27 @@
+/*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";