@praxisjs/decorators 0.7.4 → 0.8.0

package/src/properties/deep-state.ts

@@ -0,0 +1,60 @@
+import { signal } from "@praxisjs/core/internal";
+
+import { createFieldDecorator } from "../create-field-decorator";
+
+function deepProxy<T extends object>(target: T, notify: () => void): T {
+  return new Proxy(target, {
+    get(obj, key, receiver) {
+      const val: unknown = Reflect.get(obj, key, receiver);
+      if (val !== null && typeof val === "object") {
+        return deepProxy(val, notify);
+      }
+      return val;
+    },
+    set(obj, key, value) {
+      const result = Reflect.set(obj, key, value);
+      notify();
+      return result;
+    },
+    deleteProperty(obj, key) {
+      const result = Reflect.deleteProperty(obj, key);
+      notify();
+      return result;
+    },
+  });
+}
+
+export function DeepState() {
+  return createFieldDecorator({
+    bind(instance, _name, initialValue) {
+      const version = signal(0);
+      let current = initialValue;
+      let proxy =
+        current !== null && typeof current === "object"
+          ? deepProxy(current, notify)
+          : current;
+
+      function notify() {
+        instance._stateDirty = true;
+        version.update((v) => v + 1);
+      }
+
+      return {
+        descriptor: {
+          get() {
+            version();
+            return proxy;
+          },
+          set(value: unknown) {
+            current = value;
+            proxy =
+              value !== null && typeof value === "object"
+                ? deepProxy(value, notify)
+                : value;
+            notify();
+          },
+        },
+      };
+    },
+  });
+}

package/src/properties/index.ts

@@ -6,3 +6,5 @@ export { Slot, initSlots } from "./slot";
 export { History, type HistoryOf } from "./history";
 export { Compose } from "./compose";
 export { Resource, type ResourceInstance, type ResourceOptions } from "./resource";
+export { Synced } from "./synced";
+export { DeepState } from "./deep-state";

package/src/properties/synced.ts

@@ -0,0 +1,28 @@
+import { syncedSignal, type SyncedSignal } from "@praxisjs/core/internal";
+
+import { createFieldDecorator } from "../create-field-decorator";
+
+const signalMap = new WeakMap<object, Map<string, SyncedSignal<unknown>>>();
+
+export function Synced(channelName?: string) {
+  return createFieldDecorator({
+    bind(instance, name, initialValue) {
+      const key = channelName ?? name;
+
+      if (!signalMap.has(instance)) signalMap.set(instance, new Map());
+      const map = signalMap.get(instance) as Map<string, SyncedSignal<unknown>>;
+      if (!map.has(key)) map.set(key, syncedSignal(key, initialValue));
+      const sig = map.get(key) as SyncedSignal<unknown>;
+
+      return {
+        descriptor: {
+          get: () => sig(),
+          set: (value: unknown) => { sig.set(value); },
+        },
+        onUnmount() {
+          sig.close();
+        },
+      };
+    },
+  });
+}