add type maps to useProperties

- fix #6

Author: spearwolf

packages/shadow-objects/CHANGELOG.md

@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
       });
       ```
 - **Refactor** the `EntityApi` type
+- **Refactor** the `useProperties` supports type maps now
 - **Documentation:** Comprehensive update to the documentation structure and content.
 
 ### ⚠️ Breaking Changes

packages/shadow-objects/docs/03-api/01-shadow-object-api.md

@@ -39,12 +39,13 @@ createEffect(() => {
 
 A convenience helper to create multiple property signals at once.
 
-*   **Signature:** `useProperties(map: Record<string, any>): Record<string, () => any>`
+*   **Signature:** `useProperties<T extends Record<string, unknown>>(map: {[K in keyof T]: string}): {[K in keyof T]: SignalReader<Maybe<T[K]>>}`
 *   **Returns:** An object where keys match the input map, and values are signal readers.
 
 ```typescript
-const { x, y } = useProperties({ x: 0, y: 0 });
-// x() and y() are now signals
+const { x, y, title } = useProperties{ x: number; y: number, title: string }>({ x: "x", y: "y", title: "title" });
+// x() and y() are now number|undefined values
+// title is now a signal-reader with a string value
 ```
 
 ---

packages/shadow-objects/docs/04-patterns/best-practices.md

@@ -127,7 +127,7 @@ const myMeshResource = createResource(
 If you need multiple properties, avoid calling `useProperty` multiple times. Use `useProperties` to get a structured object of signals.
 
 ```typescript
-const { x, y, visible } = useProperties({
+const { x, y, visible } = useProperties<{ x: number; y: number; visible: boolean }>({
   x: "position-x",
   y: "position-y",
   visible: "is-visible"

packages/shadow-objects/src/in-the-dark/Kernel.spec.ts

@@ -340,6 +340,42 @@ describe('Kernel', () => {
       });
     });
 
+    it('should support typed property maps', () => {
+      const registry = new Registry();
+      const kernel = new Kernel(registry);
+
+      let capturedProps:
+        | {
+            foo: SignalReader<number | undefined>;
+            bar: SignalReader<string | undefined>;
+          }
+        | undefined;
+
+      @ShadowObject({registry, token: 'testTypedUseProperties'})
+      class TestTypedUseProperties {
+        constructor({useProperties}: ShadowObjectCreationAPI) {
+          const props = useProperties<{foo: number; bar: string}>({
+            foo: 'propA',
+            bar: 'propB',
+          });
+          capturedProps = props;
+        }
+      }
+      expect(TestTypedUseProperties).toBeDefined();
+
+      const uuid = generateUUID();
+      kernel.createEntity(uuid, 'testTypedUseProperties', undefined, 0, [
+        ['propA', 123],
+        ['propB', 'valueB'],
+      ]);
+
+      expect(capturedProps).toBeDefined();
+      expect(value(capturedProps!.foo)).toBe(123);
+      expect(value(capturedProps!.bar)).toBe('valueB');
+
+      kernel.destroy();
+    });
+
     describe('provideContext and useContext', () => {
       it('should provide and consume context values between parent and child', async () => {
         const registry = new Registry();

packages/shadow-objects/src/in-the-dark/Kernel.ts

@@ -523,8 +523,10 @@ export class Kernel {
 
         useProperty: getUseProperty,
 
-        useProperties<K extends string>(props: Record<K, string>): Record<K, SignalReader<any>> {
-          const result = {} as Record<K, SignalReader<any>>;
+        useProperties<T extends Record<string, unknown> = Record<string, unknown>>(props: {[K in keyof T]: string}): {
+          [K in keyof T]: SignalReader<Maybe<T[K]>>;
+        } {
+          const result = {} as {[K in keyof T]: SignalReader<Maybe<T[K]>>};
           for (const key in props) {
             if (Object.hasOwn(props, key)) {
               result[key] = getUseProperty(props[key]);

packages/shadow-objects/src/types.ts

@@ -132,7 +132,9 @@ export interface ShadowObjectCreationAPI {
 
   useProperty<T = unknown>(name: string, options?: SignalValueOptions<T> | CompareFunc<T | undefined>): SignalReader<Maybe<T>>;
 
-  useProperties<K extends string>(props: Record<K, string>): Record<K, SignalReader<any>>;
+  useProperties<T extends Record<string, unknown> = Record<string, unknown>>(props: {[K in keyof T]: string}): {
+    [K in keyof T]: SignalReader<Maybe<T[K]>>;
+  };
 
   createResource<T = unknown>(factory: () => T | undefined, cleanup?: (resource: NonNullable<T>) => unknown): Signal<Maybe<T>>;