@arrai-innovations/reactive-helpers 2.2.0 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@arrai-innovations/reactive-helpers",
-    "version": "2.2.0",
+    "version": "2.3.0",
     "description": "VueJS 3 utility composition functions to help manipulate objects and lists.",
     "main": "index.js",
     "directories": {

package/use/index.js

@@ -4,6 +4,7 @@ export * from "./listInstance.js";
 export * from "./listRelated.js";
 export * from "./listSort.js";
 export * from "./listSubscription.js";
+export * from "./objectCalculated.js";
 export * from "./objectInstance.js";
 export * from "./objectSubscription.js";
 export * from "./paginatedListInstance.js";

package/use/listCalculated.js

@@ -2,6 +2,14 @@ import { isEmpty } from "lodash";
 import { computed, effectScope, onScopeDispose, reactive, toRef, toRefs, watch } from "vue";
 import { keyDiff } from "../utils";
 
+export function useListCalculateds(instances, args) {
+    for (const [key, value] of Object.entries(args)) {
+        useListCalculated({
+            parentState: instances[key].state,
+            ...value,
+        });
+    }
+}
 // the simpler sibling of useListRelated
 // rules are just keys to functions that will be called with the object
 // and the result will be added as a computed property

package/use/listRelated.js

@@ -4,7 +4,10 @@ import { keyDiff } from "../utils/keyDiff";
 
 export function useListRelateds(instances, args) {
     for (const [key, value] of Object.entries(args)) {
-        useListRelated({ listInstance: instances[key], ...value });
+        useListRelated({
+            parentState: instances[key].state,
+            ...value,
+        });
     }
 }
 

package/use/objectCalculated.js

@@ -0,0 +1,88 @@
+import { computed, effectScope, onScopeDispose, reactive, toRef, toRefs, watch } from "vue";
+import { keyDiff } from "../utils";
+
+export function useObjectCalculateds(instances, args) {
+    for (const [key, value] of Object.entries(args)) {
+        useObjectCalculated({
+            parentState: instances[key].state,
+            ...value,
+        });
+    }
+}
+// the single object version of useListCalculated
+export function useObjectCalculated({
+    parentState,
+    calculatedObjectRules,
+    calculatedObjectPropertyName = "calculatedObject", // NOT REACTIVE
+}) {
+    const state = reactive({
+        calculatedObjectRules,
+        calculatedObjectObject: {},
+        object: {},
+    });
+    const calculatedObjectEffectScopes = {};
+    const calculatedObjectOriginalFunctions = {};
+
+    // don't change calculatedObjectPropertyName on us or it will break
+    const copn = calculatedObjectPropertyName + "";
+
+    const es = effectScope();
+
+    es.run(() => {
+        state.object = computed(() =>
+            reactive({
+                [copn]: toRef(state, "calculatedObjectObject"),
+                ...toRefs(parentState.object),
+            })
+        );
+
+        watch(
+            [() => Object.keys(state.calculatedObjectRules)],
+            () => {
+                const { addedKeys, removedKeys, changedKeys } = keyDiff(
+                    state.calculatedObjectRules,
+                    calculatedObjectOriginalFunctions
+                );
+                for (const removedKey of removedKeys) {
+                    delete calculatedObjectOriginalFunctions[removedKey];
+                    delete state.calculatedObjectObject[removedKey];
+                    if (calculatedObjectEffectScopes[removedKey]) {
+                        calculatedObjectEffectScopes[removedKey].stop();
+                        delete calculatedObjectEffectScopes[removedKey];
+                    }
+                }
+                for (const addedKey of addedKeys) {
+                    calculatedObjectOriginalFunctions[addedKey] = state.calculatedObjectRules[addedKey];
+                    calculatedObjectEffectScopes[addedKey] = effectScope();
+                    calculatedObjectEffectScopes[addedKey].run(() => {
+                        state.calculatedObjectObject[addedKey] = computed(() =>
+                            calculatedObjectOriginalFunctions[addedKey](state.object)
+                        );
+                    });
+                }
+                for (const changedKey of changedKeys) {
+                    calculatedObjectOriginalFunctions[changedKey] = state.calculatedObjectRules[changedKey];
+                    calculatedObjectEffectScopes[changedKey].stop();
+                    calculatedObjectEffectScopes[changedKey] = effectScope();
+                    calculatedObjectEffectScopes[changedKey].run(() => {
+                        state.calculatedObjectObject[changedKey] = computed(() =>
+                            calculatedObjectOriginalFunctions[changedKey](state.object)
+                        );
+                    });
+                }
+            },
+            {
+                immediate: true,
+            }
+        );
+
+        onScopeDispose(() => {
+            for (const key in calculatedObjectEffectScopes) {
+                calculatedObjectEffectScopes[key].stop();
+            }
+            for (const key in calculatedObjectOriginalFunctions) {
+                delete calculatedObjectOriginalFunctions[key];
+            }
+        });
+    });
+}