fix(types): correct type management in Deep class

- Fix type index management in set type method
- Add Watch functionality for tracking changes
- Add tests for Watch functionality

The type setter now properly manages internal indices by always
unsetting the previous type before setting a new one. This fixes
issues with stale references in the _many index.

Resolves type tracking issues in Deep class.

Author: ivansglazunov

src/deep.ts

@@ -937,6 +937,34 @@ export class Deep {
         return difference;
       });
 
+      deep.Watch = deep.contains.Watch = deep.new((difference: Deep) => {
+        const watch = deep.Watch.new(() => {
+          const newPatch = difference.call();
+          watch.to = newPatch;
+          watch.emit(newPatch);
+          return newPatch;
+        });
+        watch.from = difference;
+        const selection = difference.from;
+        selection.on((event: Event) => {
+          console.log('watch on', event);
+          if (
+            ['new', 'change', 'kill'].includes(event.name) &&
+            event.deep.type != deep.Selection
+          ) {
+            watch.call();
+          }
+          // if (['add', 'update', 'remove'].includes(event.name)) {
+          //   watch.call();
+          // }
+        });
+
+        // Make initial call to set initial state
+        watch.to = difference.to;
+
+        return watch;
+      });
+
       deep._events = true;
     }
   }
@@ -1079,8 +1107,8 @@ export class Deep {
    */
   set type(it: Deep | undefined) {
     const previous = this.type;
-    if (isUndefined(it)) this.deep.memory.types.unset(this);
-    else this.deep.memory.types.set(this, it);
+    this.deep.memory.types.unset(this);
+    if (!isUndefined(it)) this.deep.memory.types.set(this, it);
     if (!this.deep._events) return;
     if ((this.type != this.deep.Selection && this.type != this.deep.Id) && previous !== it) {
       this.on.emit(this._createChangeEvent('change', 'type', previous, it));

src/tests/sync.ts

@@ -312,6 +312,43 @@ test('selection events', () => {
   ]);
 });
 
+test('Watch functionality', () => {
+  const deep = new Deep();
+
+  const A = deep.new();
+
+  const a1 = deep.new();
+  const a2 = A.new();
+  const a3 = A.new();
+  
+  // Create selection to watch
+  const selection = deep.select({ type: A });
+  
+  // Create difference for selection
+  const difference = deep.Difference.call(selection);
+  
+  // Create watch for difference
+  const watch = deep.Watch.call(difference);
+  
+  // Test add event
+  a1.type = A;
+  assert.equal(difference.to.call.added.length, 0);
+  assert.equal(difference.to.call.updated.length, 1);
+  assert.equal(difference.to.call.removed.length, 0);
+  
+  // Test update event
+  a1.value = 'test';
+  assert.equal(difference.to.call.added.length, 0);
+  assert.equal(difference.to.call.updated.length, 1);
+  assert.equal(difference.to.call.removed.length, 0);
+  
+  // Test remove event
+  a1.type = a3;
+  assert.equal(difference.to.call.added.length, 0);
+  assert.equal(difference.to.call.updated.length, 0);
+  assert.equal(difference.to.call.removed.length, 1);
+});
+
 // test('sync json file', async () => {
 //   // Create first Deep instance and setup initial data
 //   const deep1 = new Deep();