silentium 0.0.179 → 0.0.181

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "silentium",
-  "version": "0.0.179",
+  "version": "0.0.181",
   "description": "Silentium messaging solution",
   "license": "MIT",
   "type": "module",

package/src/components/Shared.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { Late } from "components/Late";
 import { Shared } from "components/Shared";
 import { Diagram } from "testing/Diagram";
@@ -68,4 +68,31 @@ describe("Shared.test", () => {
 
     expect(count).toBe(1);
   });
+
+  test("destroy calls destroy on base message if base is destroyable", () => {
+    const destroyMock = vi.fn();
+    const baseMock = {
+      then: vi.fn(),
+      catch: vi.fn(),
+      destroy: destroyMock,
+    };
+    const s = Shared(baseMock);
+
+    s.destroy();
+
+    expect(destroyMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("destroy does not call destroy on base message if base is not destroyable", () => {
+    const baseMock = {
+      then: vi.fn(),
+      catch: vi.fn(),
+      // no destroy method
+    };
+    const s = Shared(baseMock);
+
+    s.destroy();
+
+    // No assertion needed, just ensure no error and destroy not called
+  });
 });

package/src/components/Shared.ts

@@ -1,7 +1,7 @@
 import { MessageType } from "types/MessageType";
 import { MessageSourceType, SourceType } from "types/SourceType";
 import { ConstructorType } from "types/ConstructorType";
-import { isFilled, isSource } from "helpers/guards";
+import { isDestroyable, isFilled, isSource } from "helpers/guards";
 import { Primitive } from "components/Primitive";
 import { ChainableType } from "types/ChainableType";
 
@@ -56,6 +56,9 @@ export class SharedImpl<T> implements MessageSourceType<T>, ChainableType<T> {
 
   public destroy() {
     this.resolvers.clear();
+    if (isDestroyable(this.$base)) {
+      this.$base.destroy();
+    }
     return this;
   }
 

package/src/components/Trackable.test.ts

@@ -0,0 +1,61 @@
+import { Trackable } from "components/Trackable";
+import { Context } from "components/Context";
+import { describe, expect, test, vi } from "vitest";
+
+describe("Trackable.test", () => {
+  test("sends created action on trackable creation", () => {
+    const transportSpy = vi.fn();
+    Context.transport.set("trackable", transportSpy);
+
+    const target = { value: 42 };
+    const name = "testComponent";
+
+    Trackable(name, target);
+
+    expect(transportSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        transport: "trackable",
+        params: { name, action: "created" },
+      }),
+    );
+
+    Context.transport.delete("trackable");
+  });
+
+  test("sends destroyed action on destroy access", () => {
+    const transportSpy = vi.fn();
+    Context.transport.set("trackable", transportSpy);
+
+    const target = { value: 42 };
+    const name = "testComponent";
+
+    const proxy = Trackable(name, target) as any;
+
+    void proxy.destroy;
+
+    expect(transportSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        transport: "trackable",
+        params: { name, action: "destroyed" },
+      }),
+    );
+
+    Context.transport.delete("trackable");
+  });
+
+  test("proxy forwards other properties normally", () => {
+    const transportSpy = vi.fn();
+    Context.transport.set("trackable", transportSpy);
+
+    const target = { value: 42, method: () => "hello" };
+    const name = "testComponent";
+
+    const proxy = Trackable(name, target) as any;
+
+    expect(proxy.value).toBe(42);
+    expect(proxy.method()).toBe("hello");
+    expect(proxy.nonExistent).toBeUndefined();
+
+    Context.transport.delete("trackable");
+  });
+});

package/src/components/Trackable.ts

@@ -0,0 +1,32 @@
+import { Context } from "components/Context";
+
+/**
+ * Track creation and destruction of components
+ * uses Context component to send messages
+ * when created sends action=created
+ * when destroyed sends action=destroyed
+ */
+export function Trackable(name: string, target: object) {
+  Context({
+    transport: "trackable",
+    params: {
+      name,
+      action: "created",
+    },
+  }).then(() => {});
+  return new Proxy(target, {
+    get(target, prop, receiver) {
+      if (prop === "destroy") {
+        Context({
+          transport: "trackable",
+          params: {
+            name,
+            action: "destroyed",
+          },
+        }).then(() => {});
+      }
+
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+}

package/src/index.ts

@@ -36,6 +36,7 @@ export * from "./components/Race";
 export * from "./components/Sequence";
 export * from "./components/Shared";
 export * from "./components/Stream";
+export * from "./components/Trackable";
 export * from "./helpers/DevTools";
 export * from "./helpers/ensures";
 export * from "./helpers/guards";