@arrai-innovations/reactive-helpers 9.0.2 → 10.0.0

package/tests/unit/use/listSubscription.spec.js

@@ -21,6 +21,7 @@ describe("use/listSubscription.spec.js", function () {
         crudSubscribeResolvable = [];
         crudListResolvable.push(new CancellableResolvable());
         crudSubscribeResolvable.push(new CancellableResolvable());
+        const listCrudModule = await import("../../../config/listCrud.js");
         const listInstanceModule = await import("../../../use/listInstance");
         crudList = vi
             .fn()
@@ -30,8 +31,9 @@ describe("use/listSubscription.spec.js", function () {
                 crudListResolvable.push(newResolvable);
                 return newResolvable.promise;
             });
-        listInstanceModule.setListInstanceCrud({
+        listCrudModule.setListCrud({
             list: crudList,
+            subscribe: crudSubscribe,
             args: { stream: "test_stream" },
         });
         const listSubscriptionModule = await import("../../../use/listSubscription");
@@ -49,10 +51,6 @@ describe("use/listSubscription.spec.js", function () {
                 passedSubscriptionEventCallback = subscriptionEventCallback;
                 return newResolvable.promise;
             });
-        listSubscriptionModule.setListSubscriptionCrud({
-            subscribe: crudSubscribe,
-            args: { stream: "test_stream" },
-        });
 
         useListInstance = listInstanceModule.useListInstance;
         useListInstances = listInstanceModule.useListInstances;

package/use/list.js

@@ -1,7 +1,9 @@
-import { useListCalculated } from "./listCalculated.js";
-import { useListInstance } from "./listInstance.js";
-import { useListRelated } from "./listRelated.js";
-import { useListSubscription } from "./listSubscription.js";
+import { useListCalculated, listCalculatedFunctions } from "./listCalculated.js";
+import { useListFilter, listFilterFunctions } from "./listFilter.js";
+import { useListInstance, listInstanceFunctions } from "./listInstance.js";
+import { useListRelated, listRelatedFunctions } from "./listRelated.js";
+import { useListSort, listSortFunctions } from "./listSort.js";
+import { useListSubscription, listSubscriptionFunctions } from "./listSubscription.js";
 import { usePagedListInstance } from "./paginatedListInstance.js";
 import { effectScope, reactive, shallowReactive, shallowReadonly, toRef } from "vue";
 
@@ -42,6 +44,7 @@ export const useList = ({ props, functions, paged = false, keepOldPages = false
             listInstance: managed.listInstance,
         });
         managed.listSubscription.state.intendToList = toRef(props, "intendToList");
+        managed.listSubscription.state.intendToSubscribe = toRef(props, "intendToSubscribe");
 
         managed.listRelated = useListRelated({
             parentState: managed.listSubscription.state,
@@ -52,6 +55,23 @@ export const useList = ({ props, functions, paged = false, keepOldPages = false
             parentState: managed.listRelated.state,
             calculatedObjectsRules: toRef(props, "calculatedObjectsRules"),
         });
+
+        managed.listFilter = useListFilter({
+            parentState: managed.listCalculated.state,
+            useTextSearch: toRef(props, "useTextSearch"),
+            textSearchRules: toRef(props, "textSearchRules"),
+            textSearchValue: toRef(props, "textSearchValue"),
+            allowedValues: toRef(props, "allowedValues"),
+            excludedValues: toRef(props, "excludedValues"),
+            allowedFilter: toRef(props, "allowedFilter"),
+            excludedFilter: toRef(props, "excludedFilter"),
+        });
+
+        managed.listSort = useListSort({
+            parentState: managed.listFilter.state,
+            orderByRules: toRef(props, "orderByRules"),
+            sortThrottleWait: functions.sortThrottleWait,
+        });
     });
 
     const clearError = (error) => {
@@ -59,18 +79,32 @@ export const useList = ({ props, functions, paged = false, keepOldPages = false
         managed.listInstance.clearError(error);
     };
 
-    return reactive({
+    const returnObject = reactive({
         // we manage the keys on both of these, so hands off the root.
         managed: shallowReadonly(managed),
-        state: managed.listCalculated.state,
-        list: managed.listInstance.list,
-        addListObject: managed.listInstance.addListObject,
-        updateListObject: managed.listInstance.updateListObject,
-        deleteListObject: managed.listInstance.deleteListObject,
-        clearList: managed.listInstance.clearList,
-        clearError,
-        getFakeId: managed.listInstance.getFakeId,
-        defaultPageCallback: managed.listInstance.defaultPageCallback,
+        state: managed.listSort.state,
         effectScope: es,
     });
+    const handledDuplicateFunctions = {
+        clearError,
+    };
+    for (const [source, fnNames] of [
+        [managed.listInstance, listInstanceFunctions],
+        [managed.listSubscription, listSubscriptionFunctions],
+        [managed.listRelated, listRelatedFunctions],
+        [managed.listCalculated, listCalculatedFunctions],
+        [managed.listFilter, listFilterFunctions],
+        [managed.listSort, listSortFunctions],
+    ]) {
+        for (const fnName of fnNames) {
+            if (handledDuplicateFunctions[fnName]) {
+                continue;
+            }
+            returnObject[fnName] = source[fnName];
+        }
+    }
+    for (const [fnName, fn] of Object.entries(handledDuplicateFunctions)) {
+        returnObject[fnName] = fn;
+    }
+    return returnObject;
 };

package/use/listCalculated.js

@@ -13,6 +13,8 @@ export const listCalculatedStateKeys = [
     "calculatedObjectsWatchRunning",
 ];
 
+export const listCalculatedFunctions = [];
+
 export function useListCalculateds(instances, args) {
     for (const [key, value] of Object.entries(args)) {
         useListCalculated({
@@ -130,6 +132,7 @@ export function useListCalculated({ parentState, calculatedObjectsRules }) {
             ],
         });
 
+        state.calculatedRunning = toRef(watchesRunning.state, "running");
         state.running = computed(() => loadingCombine(watchesRunning.state.running, parentState.running));
 
         onScopeDispose(() => {

package/use/listFilter.js

@@ -1,10 +1,30 @@
 import { keyDiff } from "../utils/keyDiff.js";
+import { listCalculatedStateKeys } from "./listCalculated.js";
+import { listInstanceStateKeys } from "./listInstance.js";
+import { listRelatedStateKeys } from "./listRelated.js";
+import { listSubscriptionStateKeys } from "./listSubscription.js";
 import { useSearch } from "./search.js";
 import get from "lodash-es/get.js";
 import identity from "lodash-es/identity.js";
 import isEmpty from "lodash-es/isEmpty.js";
 import { computed, effectScope, onScopeDispose, reactive, toRef, watch, watchEffect } from "vue";
 
+export const listFilterStateKeys = [
+    "objectIndexes",
+    // override but not ours
+    // "objects",
+    "textSearchRules",
+    "textSearchValue",
+    "allowedValues",
+    "excludedValues",
+    "allowedFilter",
+    "excludedFilter",
+    "searched",
+    "searching",
+];
+
+export const listFilterFunctions = [];
+
 export function useListFilters(listFilterArgs, parentInstances) {
     const filters = {};
     for (const [key, value] of Object.entries(listFilterArgs)) {
@@ -32,6 +52,8 @@ export function useListFilter({
         excludedValues,
         allowedFilter,
         excludedFilter,
+        searched: undefined,
+        searching: undefined,
     });
 
     const es = effectScope();
@@ -39,6 +61,21 @@ export function useListFilter({
     let textSearchIndex;
 
     es.run(() => {
+        for (const key of listInstanceStateKeys) {
+            if (key === "objects") {
+                continue;
+            }
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listSubscriptionStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listRelatedStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listCalculatedStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
         if (useTextSearch) {
             textSearchIndex = useSearch();
             textSearchIndex.state.search = toRef(state, "textSearchValue");
@@ -46,9 +83,11 @@ export function useListFilter({
             state.searching = toRef(textSearchIndex.state, "searching");
         }
 
+        // todo: computed is not the solution here for deep reactions
         state.objectsInOrder = computed(() => parentState.order.map((id) => state.objects[id]).filter(identity));
         state.order = computed(() => state.objectsInOrder.map((object) => `${object.id}`));
 
+        // todo: this huge watchEffect is fairly gross, but also doesn't watch deep similarly to computed
         watchEffect(() => {
             const allowedValuesEmpty = !state.allowedValues || isEmpty(state.allowedValues);
             const excludedValuesEmpty = !state.excludedValues || isEmpty(state.excludedValues);
@@ -104,6 +143,7 @@ export function useListFilter({
         if (useTextSearch) {
             const stopIndexWatch = {};
 
+            // todo: this huge watchEffect is fairly gross, but also doesn't watch deep similarly to computed
             watchEffect(() => {
                 const { removedKeys, addedKeys } = keyDiff(
                     Object.keys(parentState.objects),

package/use/listInstance.js

@@ -1,9 +1,8 @@
-import { addOrUpdateReactiveObject, assignReactiveObject } from "../utils/assignReactiveObject.js";
+import { getListCrud } from "../config/listCrud.js";
+import { assignReactiveObject } from "../utils/assignReactiveObject.js";
 import { getFakeId } from "../utils/getFakeId.js";
 import inspect from "browser-util-inspect";
-import cloneDeep from "lodash-es/cloneDeep.js";
-import isFunction from "lodash-es/isFunction.js";
-import { computed, effectScope, reactive, toRef, watchEffect } from "vue";
+import { computed, effectScope, reactive, toRef } from "vue";
 
 export class ListError extends Error {
     constructor(message, code) {
@@ -13,11 +12,6 @@ export class ListError extends Error {
     }
 }
 
-const defaultCrud = {
-    args: {},
-    list: undefined,
-};
-
 export const listInstanceStateKeys = [
     "crud",
     "retrieveArgs",
@@ -34,11 +28,39 @@ export const listInstanceStateKeys = [
     "perPage",
 ];
 
-export function setListInstanceCrud({ list, args = {} } = {}) {
-    defaultCrud.list = list;
-    Object.assign(defaultCrud.args, args);
-}
+export const listInstanceFunctions = [
+    "list",
+    "addListObject",
+    "updateListObject",
+    "deleteListObject",
+    "clearList",
+    "clearError",
+    "getFakeId",
+    "defaultPageCallback",
+    "pageCallback",
+];
 
+/**
+ * The configuration options used to create a list instance.
+ * @typedef {object} ListInstanceOptions
+ * @property {object} props - props passed to the component
+ * @property {object} props.retrieveArgs - the arguments passed to the server
+ * @property {object} props.listArgs - the arguments passed to the server
+ * @property {object} props.crudArgs - implementation specific arguments
+ * @property {object} functions - optional. default implementation are used as set by `setListCrud`.
+ * @property {Function} functions.list - provide the implementation for the list function
+ * @property {Function} functions.subscribe - provide the implementation for the subscribe function
+ * @property {boolean} keepOldPages - if true, pages will not be cleared when defaultPageCallback is called. default is false.
+ */
+
+/* eslint-disable jsdoc/check-types */
+// types valid for jsdoc-to-markdown, which uses the strict jsdoc.app. Object shorthand syntax doesn't work.
+/**
+ * A Vue composition function that creates multiple list instances, and returns them as an object.
+ * @param {Object.<string, ListInstanceOptions>} listInstanceArgs - each desired list instance options, keyed by an instance name.
+ * @returns {Object.<string, ListInstance>} - each list instance, keyed by the instance name.
+ */
+/* eslint-enable jsdoc/check-types */
 export function useListInstances(listInstanceArgs) {
     const instances = {};
     for (const [key, value] of Object.entries(listInstanceArgs)) {
@@ -47,6 +69,48 @@ export function useListInstances(listInstanceArgs) {
     return instances;
 }
 
+/**
+ * A reactive object that manages a list of objects, as returned by `useListInstance`.
+ * @typedef {object} ListInstanceState
+ * @property {object} crud - the crud functions
+ * @property {object} crud.args - the arguments passed to the crud functions
+ * @property {Function} crud.list - the list function
+ * @property {Function} crud.subscribe - the subscribe function
+ * @property {object} retrieveArgs - the arguments passed to the server
+ * @property {object} listArgs - the arguments passed to the server
+ * @property {Map} objects - the objects in the list
+ * @property {boolean} loading - true if the list is loading
+ * @property {boolean} errored - true if the list has errored
+ * @property {object} error - the error object
+ * @property {Array} objectsInOrder - the objects in the list in order
+ * @property {Array} order - the order of the objects in the list
+ * @property {number} totalRecords - the total number of records
+ * @property {number} totalPages - the total number of pages
+ * @property {number} perPage - the number of records per page
+ */
+
+/**
+ * @typedef {object} ListInstance
+ * @property {Function} list - subscribe to updates from the implementation
+ * @property {Function} addListObject - add an object to the list
+ * @property {Function} updateListObject - update an object in the list
+ * @property {Function} deleteListObject - delete an object from the list
+ * @property {Function} clearList - clear the list
+ * @property {Function} clearError - clear the error
+ * @property {Function} getFakeId - get a fake id
+ * @property {Function} defaultPageCallback - the default page callback
+ * @property {Function} pageCallback - the page callback
+ * @property {ListInstanceState} state - the list instance state
+ * @property {object} effectScope - a Vue effect scope
+ */
+
+/**
+ * `useListInstance` is a Vue composition function that manages a list of objects.
+ * It has the ability to retrieve the list from an implementation, or subscribe to updates from an implementation.
+ * It tracks the objects in the list, and their added order.
+ * @param {ListInstanceOptions} options - the options used to create the list instance
+ * @returns {ListInstance} - the list instance
+ */
 export function useListInstance({ props, functions = {}, keepOldPages = false }) {
     if (!props) {
         throw new ListError(`useListInstance requires props`);
@@ -98,20 +162,8 @@ export function useListInstance({ props, functions = {}, keepOldPages = false })
         error: null,
     });
     const es = effectScope();
-    watchEffect(() => {
-        // prevent linking of all instances to the same default .args object
-        Object.assign(state.crud, cloneDeep(defaultCrud));
-        if (props.crudArgs) {
-            addOrUpdateReactiveObject(state.crud.args, props.crudArgs);
-        }
-        for (const [key, value] of Object.entries(functions)) {
-            if (isFunction(value) && key in state.crud) {
-                state.crud[key] = value;
-            } else {
-                throw ListError(`Invalid function "${key}" for useListInstance: invalid key or not a function.`);
-            }
-        }
-    });
+
+    getListCrud(state.crud, { props, functions });
 
     const defaultPageCallback = (newObjects) => {
         // with keepOldPages, you are responsible for clearing the list as needed
@@ -173,6 +225,7 @@ export function useListInstance({ props, functions = {}, keepOldPages = false })
             .finally(() => {
                 state.loading = false;
                 returnPromiseResolve(resolveState);
+                promises.list = null;
             });
         return promises.list;
     }

package/use/listRelated.js

@@ -1,4 +1,5 @@
-import { keyDiff, loadingCombine } from "../utils/index.js";
+import { keyDiff } from "../utils/keyDiff.js";
+import { loadingCombine } from "../utils/loadingCombine.js";
 import { listInstanceStateKeys } from "./listInstance.js";
 import { listSubscriptionStateKeys } from "./listSubscription.js";
 import { useWatchesRunning } from "./watchesRunning.js";
@@ -15,6 +16,8 @@ export const listRelatedStateKeys = [
     "relatedObjectsParentStateObjectsWatchRunning",
 ];
 
+export const listRelatedFunctions = [];
+
 export function useListRelateds(instances, args) {
     for (const [key, value] of Object.entries(args)) {
         useListRelated({
@@ -130,6 +133,7 @@ export function useListRelated({ parentState, relatedObjectsRules }) {
             ],
         });
 
+        state.relatedRunning = toRef(watchesRunning.state, "running");
         state.running = computed(() => loadingCombine(watchesRunning.state.running, parentState.running));
 
         onScopeDispose(() => {

package/use/listSort.js

@@ -1,4 +1,9 @@
 import { assignReactiveObject, keyDiff } from "../utils/index.js";
+import { listCalculatedStateKeys } from "./listCalculated.js";
+import { listFilterStateKeys } from "./listFilter.js";
+import { listInstanceStateKeys } from "./listInstance.js";
+import { listRelatedStateKeys } from "./listRelated.js";
+import { listSubscriptionStateKeys } from "./listSubscription.js";
 import cloneDeep from "lodash-es/cloneDeep.js";
 import get from "lodash-es/get.js";
 import identity from "lodash-es/identity.js";
@@ -10,6 +15,17 @@ import throttle from "lodash-es/throttle.js";
 import zip from "lodash-es/zip.js";
 import { effectScope, onScopeDispose, reactive, toRef, unref, watch } from "vue";
 
+export const listSortStateKeys = [
+    "orderByRules",
+    // "order",
+    // "objectsInOrder",
+    "sortCriteria",
+    "sortCriteriaWatches",
+    "orderByDesc",
+];
+
+export const listSortFunctions = [];
+
 const collator = new Intl.Collator(undefined, { numeric: true });
 
 const defaultSortThrottleWait = Symbol("defaultSortThrottleWait");
@@ -161,7 +177,24 @@ export function useListSort({ parentState, orderByRules, sortThrottleWait = defa
     const throttledSortWatch = throttle(sortWatch, sortThrottleWait);
 
     es.run(() => {
-        state.objects = toRef(parentState, "objects");
+        for (const key of listInstanceStateKeys) {
+            if (["order", "objectsInOrder"].includes(key)) {
+                continue;
+            }
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listSubscriptionStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listRelatedStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listCalculatedStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
+        for (const key of listFilterStateKeys) {
+            state[key] = toRef(parentState, key);
+        }
         // we do not need two immediate watches to the same function.
         watch(() => Object.keys(parentState.objects), sortCriteriaWatch);
         watch(() => cloneDeep(state.orderByRules), sortCriteriaWatch, {

package/use/listSubscription.js

@@ -14,10 +14,6 @@ export class ListSubscriptionError extends Error {
     }
 }
 
-const defaultCrud = {
-    subscribe: undefined,
-};
-
 export const listSubscriptionStateKeys = [
     "subscriptionLoading",
     "subscriptionErrored",
@@ -27,10 +23,25 @@ export const listSubscriptionStateKeys = [
     "subscribed",
 ];
 
-export function setListSubscriptionCrud({ subscribe }) {
-    defaultCrud.subscribe = subscribe;
-}
+export const listSubscriptionFunctions = ["subscribe", "unsubscribe", "clearError"];
 
+/**
+ * The configuration options used to create a list subscription.
+ * @typedef {object} ListSubscriptionOptions
+ * @property {object} props - passed on to a created list instance if one is not provided
+ * @property {object} functions - passed on to a created list instance if one is not provided
+ * @property {ListInstance} listInstance - a list instance to use instead of creating one
+ * @property {boolean} keepOldPages - if true, pages will not be cleared when defaultPageCallback is called. default is false.
+ */
+
+/* eslint-disable jsdoc/check-types */
+// types valid for jsdoc-to-markdown, which uses the strict jsdoc.app. Object shorthand syntax doesn't work.
+/**
+ * A Vue composition function that creates multiple list instances, and returns them as an object.
+ * @param {Object.<string, ListInstanceOptions>} listInstanceArgs - each desired list instance options, keyed by an instance name.
+ * @returns {Object.<string, ListInstance>} - each list instance, keyed by the instance name.
+ */
+/* eslint-enable jsdoc/check-types */
 export function useListSubscriptions(args, listInstances = {}) {
     const subscriptions = {};
     for (const [key, value] of Object.entries(args)) {
@@ -39,13 +50,43 @@ export function useListSubscriptions(args, listInstances = {}) {
     return subscriptions;
 }
 
-export function useListSubscription({ listInstance, props, functions }) {
+/**
+ * A reactive object that manages a list of objects, as returned by `useListInstance`.
+ * @typedef {object} ListSubscriptionState
+ * @augments ListInstanceState
+ * @property {boolean} subscriptionLoading - true if the subscription is loading
+ * @property {boolean} subscriptionErrored - true if the subscription errored
+ * @property {Error} subscriptionError - the error that caused the subscription to error
+ * @property {boolean} intendToList - true if the list should be fetched, or refetched when args change
+ * @property {boolean} intendToSubscribe - true if the list should subscribe for updates
+ * @property {boolean} subscribed - true if the subscription is active
+ */
+
+/**
+ * @typedef {object} ListSubscription
+ * @property {ListSubscriptionState} state - the reactive state of the list subscription
+ * @property {ListInstance} listInstance - the list instance used by the subscription
+ * @property {object} listIntent - the useCancelleableIntent object managing if the list should be (re)fetched
+ * @property {object} subscriptionIntent - the useCancelleableIntent object managing if the subscription should be (un)subscribed
+ * @property {Function} subscribe - subscribe to the list
+ * @property {Function} unsubscribe - unsubscribe from the list
+ * @property {Function} clearError - clear the subscription error
+ * @property {object} effectScope - a Vue effect scope
+ */
+
+/**
+ * `useListSubscription` creates a reactive object that manages a list of objects, as returned by `useListInstance`,
+ *  causing the list to be re-fetched as needed and listening for updates to the list.
+ * @param {ListSubscriptionOptions} options
+ * @returns ListSubscription
+ */
+export function useListSubscription({ listInstance, props, functions, keepOldPages = false }) {
     if (!listInstance && !props) {
-        throw new ListSubscriptionError("useListSubscription should be passed listInstance or props and crudArgs.");
+        throw new ListSubscriptionError("useListSubscription should be passed listInstance or props and functions.");
     }
     if (listInstance && props) {
         throw new ListSubscriptionError(
-            "useListSubscription should be passed listInstance or props and crudArgs, not both."
+            "useListSubscription should be passed listInstance or props and functions, not both."
         );
     }
     if (!listInstance) {
@@ -55,10 +96,11 @@ export function useListSubscription({ listInstance, props, functions }) {
         if (!("retrieveArgs" in props)) {
             console.error("retrieveArgs not set, must be true for intendToList or intendToSubscribe to work.");
         }
-        listInstance = useListInstance({ props, functions });
-    }
-    if (!listInstance.state.crud.subscribe) {
-        listInstance.state.crud.subscribe = defaultCrud.subscribe;
+        listInstance = useListInstance({ props, functions, keepOldPages });
+    } else {
+        if (functions) {
+            console.error("functions passed to useListSubscription, but listInstance was passed. functions ignored.");
+        }
     }
     const parentState = listInstance.state;
 

package/use/object.js

@@ -1,7 +1,7 @@
-import { useObjectCalculated } from "./objectCalculated.js";
-import { useObjectInstance } from "./objectInstance.js";
-import { useObjectRelated } from "./objectRelated.js";
-import { useObjectSubscription } from "./objectSubscription.js";
+import { useObjectCalculated, objectCalculatedFunctions } from "./objectCalculated.js";
+import { useObjectInstance, objectInstanceFunctions } from "./objectInstance.js";
+import { useObjectRelated, objectRelatedFunctions } from "./objectRelated.js";
+import { useObjectSubscription, objectSubscriptionFunctions } from "./objectSubscription.js";
 import { effectScope, reactive, shallowReadonly, toRef } from "vue";
 
 // Manages a chain of useObject* functions
@@ -49,7 +49,7 @@ export const useObject = ({ props, functions }) => {
         // objectInstance.clear also does objectInstance.clearError
         managed.objectInstance.clear();
     };
-    return reactive({
+    const returnObject = reactive({
         managed: shallowReadonly(managed),
         state: managed.objectCalculated.state,
         retrieve: managed.objectInstance.retrieve,
@@ -64,4 +64,25 @@ export const useObject = ({ props, functions }) => {
         clear,
         effectScope: es,
     });
+    const handledDuplicateFunctions = {
+        clearError,
+        clear,
+    };
+    for (const [source, fnNames] of [
+        [managed.objectInstance, objectInstanceFunctions],
+        [managed.objectSubscription, objectSubscriptionFunctions],
+        [managed.objectRelated, objectRelatedFunctions],
+        [managed.objectCalculated, objectCalculatedFunctions],
+    ]) {
+        for (const fnName of fnNames) {
+            if (handledDuplicateFunctions[fnName]) {
+                continue;
+            }
+            returnObject[fnName] = source[fnName];
+        }
+    }
+    for (const [fnName, fn] of Object.entries(handledDuplicateFunctions)) {
+        returnObject[fnName] = fn;
+    }
+    return returnObject;
 };