@finsemble/finsemble-ui 7.3.9 → 7.3.10

package/clients/configClient.js

@@ -0,0 +1,960 @@
+/*!
+ * Copyright 2017 - 2020 by ChartIQ, Inc.
+ * All rights reserved.
+ */
+/**
+ * This client provides run-time access to Finsemble's configuration.
+ * The Config Client functions similar to a global store created with the Distributed Store Client and offers many of the same methods.
+ * Values modified at runtime are not persisted.
+ *
+ *
+ * See the [Configuration tutorial](/docs/customize/customize-with-SDK/configuration) for a configuration overview.
+ *
+ * @module ConfigClient
+ */
+/**
+This is how we want our API to work going forward, the way the world does it: import { processAndSet } from "configClient"
+```
+export const processAndSet = () => { ... }
+```
+
+This module's single exported object gives us backward compatibility when our core code does this: import { ConfigClient } from "configClient"
+and provides the object that is attached to FSBL.Clients. This export should be kept as clean and simple as possible.
+```
+export const ConfigClient = {
+   processAndSet
+}
+```
+
+The default export gives us backward compatibility where our core code does this: import ConfigClient from "configClient"
+This can be eliminated when our core core is converted to normal imports as in the first example.
+```
+export default ConfigClient;
+```
+*/
+import { RouterClient } from "./routerClient";
+import SystemManagerClient from "../common/systemManagerClient";
+import Logger from "./logger";
+import { singleton } from "../common/Singleton";
+import { generateMappingString } from "../platform/services/distributedStore/storeUtils";
+class ConfigClientController {
+    constructor() {
+        this.listeners = {};
+        // Prevents multiple listener requests on the same field from being sent to the DistributedStoreService
+        this.subs = {};
+    }
+}
+let configServiceStarted = false;
+const waitForConfigService = async () => {
+    if (!configServiceStarted) {
+        await SystemManagerClient.waitForStartup("configService");
+        configServiceStarted = true;
+    }
+};
+const getControllerInstance = () => singleton("ConfigClient", ConfigClientController);
+const INVALID_PATH_ERROR_MESSAGE = `Invalid path - MUST be a path array. e.g. for myObject.property use ['myObj', 'property']`;
+/**
+ * Trigger any function that is listening for changes
+ */
+const triggerListeners = (listenerKey, data) => {
+    var _a;
+    const controller = getControllerInstance();
+    const listeners = (_a = controller.listeners[listenerKey]) !== null && _a !== void 0 ? _a : [];
+    listeners.forEach((listener) => {
+        Logger.system.debug("ConfigClient.triggerListeners", listenerKey, data);
+        listener(null, {
+            field: listenerKey,
+            value: data,
+        });
+    });
+};
+/**
+ * Handles incoming changes from the config service
+ */
+const handleChanges = (err, response) => {
+    if (err) {
+        Logger.system.error("ConfigClient handleChanges() error", err);
+    }
+    else {
+        if (!response.data.field) {
+            response.data.field = null;
+        }
+        const { field, storeData, value } = response.data;
+        const val = storeData ? storeData : value;
+        triggerListeners(field ? field : "configService", val);
+    }
+};
+/**
+ * make sure we don't have duplicate router subscribers
+ */
+const changeSub = async (change) => {
+    const controller = getControllerInstance();
+    if (!controller.subs)
+        controller.subs = {};
+    if (!controller.subs[change]) {
+        controller.subs[change] = true;
+        waitForConfigService();
+        const { err } = await RouterClient.query("configService.addListener", change);
+        if (err) {
+            Logger.system.error("Error adding listener to config service", err);
+        }
+        await RouterClient.subscribe(change, handleChanges);
+    }
+};
+/**
+ * @language javascript, dotnet
+ * Retrieves the entire manifest
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getManifest(function(err, value){ });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getManifest();
+ * ```
+ */
+export const getManifest = async (cb) => {
+    waitForConfigService();
+    const { err, response } = await RouterClient.query("configService.getValues", { fields: null });
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java
+ * Get a value from the config.
+ *
+ * If a field does not exists in the configuration, `data` will be undefined and `err` will
+ * be null.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.get(
+ *   ['field1', 'property1'], // field1.property1
+ *   function(err,value){ }
+ * );
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.get(
+ *   ['field1', 'property1'] // field1.property1
+ * );
+ * ```
+ *
+ * :::note
+ * In Java, this method is named `getValue`.
+ * :::
+ * @param {Function} cb Will return the value if found.
+ */
+export const get = async (path, cb) => {
+    if (!Array.isArray(path)) {
+        cb === null || cb === void 0 ? void 0 : cb(INVALID_PATH_ERROR_MESSAGE);
+        return { err: INVALID_PATH_ERROR_MESSAGE };
+    }
+    waitForConfigService();
+    const { err, response } = await RouterClient.query("configService.getValue", path);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java
+ *
+ * Get multiple values from the config.
+ *
+ * If a field does not exists in the configuration, `data` will be undefined and `err` will
+ * be null.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getMultiple(
+ *  [
+ *    // field1.property1.subproperty1
+ *    ["field1", "property1", "subproperty1"],
+ *
+ *    // field1.property2
+ *    ["field1", "property2"]
+ *  ], (err, values) => {
+ *    if(!err){
+ *      console.log("Values: ", values);
+ *   }
+ * });
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.getMultiple([
+ *   // field1.property1.subproperty1
+ *   ["field1", "property1", "subproperty1"],
+ *
+ *   // field1.property2
+ *   ["field1", "property2"]                  // field1.property2
+ * ]);
+ * if(!err){
+ *   console.log("Values: ", data);
+ * }
+ * ```
+ * @param {Function} cb Will return the value if found.
+ */
+export const getMultiple = async (paths, cb) => {
+    if (!Array.isArray(paths)) {
+        cb === null || cb === void 0 ? void 0 : cb(INVALID_PATH_ERROR_MESSAGE);
+        return { err: INVALID_PATH_ERROR_MESSAGE };
+    }
+    await SystemManagerClient.waitForStartup("configService");
+    const { err, response } = await RouterClient.query("configService.getValues", { fields: paths });
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [ `FSBL.Clients.ConfigClient.get()`](#get) instead.
+ *
+ * Get a value from the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getValue({ field:'field1' }, function(err,value){ });
+ * FSBL.Clients.ConfigClient.getValue('field1', function(err,value){ });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getValue({ field:'field1' });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getValue('field1');
+ * ```
+ * @param {Function} cb Will return the value if found.
+ *
+ */
+export const getValue = async (params, cb) => {
+    if (typeof params === "string") {
+        params = { field: params };
+    }
+    if (!params.field) {
+        const err = "no field provided";
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    waitForConfigService();
+    const { err, response } = await RouterClient.query("configService.getValue", {
+        field: params.field,
+    });
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.getMultiple()`](#getmultiple) instead.
+ *
+ * Get multiple values from the config.
+ *
+ * :::caution
+ * **Deprecated functionality**: If there are no fields provided, the complete configuration manifest
+ * is returned (use [getManifest()](#getmanifest)).
+ * :::
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getValues(['field1','field2'], function(err,values){ });
+ * FSBL.Clients.ConfigClient.getValues(null, callback); // returns the complete manifest containing the finsemble property
+ * const {err, data} = await FSBL.Clients.ConfigClient.getValues(['field1', 'field2']);
+ * ```
+ * @param {fieldOnlyParam[] | string[]} fields An array of objects containing a field property or an array of string field names.
+ * @param {Function} cb Will return the value if found.
+ */
+export const getValues = async (fields, cb) => {
+    if (typeof fields === "function") {
+        cb = fields;
+        fields = null;
+    }
+    if (fields && !Array.isArray(fields)) {
+        return getValue(fields, cb);
+    }
+    waitForConfigService();
+    const { err, response } = await RouterClient.query("configService.getValues", { fields });
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java
+ * Sets a value in the config.
+ *
+ * Setting a value will trigger events that you can listen to using [`addListener()`](#addlistener).
+ *
+ * ```javascript
+ * // Set field1.property1 = "foo"
+ * FSBL.Clients.ConfigClient.set(
+ *   ['field1', 'property1'],
+ *   "foo",
+ *   function(err,value){ }
+ * );
+ *
+ * // Set field1.property1 = "foo"
+ * const {err, data} = await FSBL.Clients.ConfigClient.set(['field1', 'property1'], "foo");
+ * ```
+ * :::note
+ * In Java, this method is named `setValue`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export const set = async (path, value, cb) => {
+    if (!Array.isArray(path)) {
+        cb === null || cb === void 0 ? void 0 : cb(INVALID_PATH_ERROR_MESSAGE);
+        return { err: INVALID_PATH_ERROR_MESSAGE };
+    }
+    waitForConfigService();
+    const fieldPathArrayAndValue = {
+        field: path,
+        value,
+    };
+    const { err, response } = await RouterClient.query("configService.setValue", fieldPathArrayAndValue);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java
+ * Sets multiple values in the config.
+ *
+ * Setting a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * // Set both field1.property1 = "foo" AND field2.property2 = "bar"
+ * FSBL.Clients.ConfigClient.setMultiple(
+ *   [
+ * 		{field: ['field1', 'property1'], value: "foo"},
+ * 		{field: ['field2', 'property2'], value: "bar"}
+ *   ],
+ *   function(err,value){ }
+ * );
+ *
+ * // Set both field1.property1 = "foo" AND field2.property2 = "bar"
+ * const {err, data} = await FSBL.Clients.ConfigClient.setMultiple([
+ *   {field: ['field1', 'property1'], value: "foo"},
+ *   {field: ['field2', 'property2'], value: "bar"}
+ * ]);
+ * ```
+ *
+ *
+ * :::note
+ * In Java, this method is named `setValues`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export const setMultiple = async (pathsAndValues, cb) => {
+    if (!Array.isArray(pathsAndValues)) {
+        cb === null || cb === void 0 ? void 0 : cb(INVALID_PATH_ERROR_MESSAGE);
+        return { err: INVALID_PATH_ERROR_MESSAGE };
+    }
+    await SystemManagerClient.waitForStartup("configService");
+    const { err, response } = await RouterClient.query("configService.setValues", pathsAndValues);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.set()`](#set) instead.
+ *
+ * Set a value in the config. Setting a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.setValue({ field:'field1', value:"new value" }, function(err){ });
+ * const {err} = await FSBL.Clients.ConfigClient.setValue({ field:'field1', value:'new value' })
+ * ```
+ * @param {function} cb Optional callback
+ */
+export const setValue = async (params, cb) => {
+    const data = {
+        field: params.field,
+        value: params.value,
+    };
+    waitForConfigService();
+    const { err } = await RouterClient.query("configService.setValue", data);
+    cb === null || cb === void 0 ? void 0 : cb(err);
+    return { err };
+};
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [FSBL.Clients.ConfigClient.setMultiple()](#setmultiple) instead.
+ *
+ * Set multiple values in the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.setValues([{ field:'field1', value: "new value" }]);
+ * const {err} = await FSBL.Clients.ConfigClient.setValues([{ field:'field1', value: "new value" }]);
+ * ```
+ * @param {function} cb Optional callback
+ */
+export const setValues = async (fields, cb) => {
+    if (!fields) {
+        const err = "ConfigClient.SetValues. No params given";
+        Logger.system.error(err);
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    if (!Array.isArray(fields)) {
+        const err = "ConfigClient.SetValues. Params must be an array";
+        Logger.system.error(err);
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    waitForConfigService();
+    const { err } = await RouterClient.query("configService.setValues", fields);
+    cb === null || cb === void 0 ? void 0 : cb(err);
+    return { err };
+};
+/**
+ * @language javascript, java
+ * Remove a value (and its key) from the config.
+ *
+ * Removing a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.remove(
+    ['field1', 'property1'],  // field1.property1
+    function(err,value){ }
+   );
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.remove(
+    ['field1', 'property1']); // field1.property1
+ * ```
+ *
+ * :::note
+ * In Java, this method is named `removeValue`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export const remove = async (path, cb) => {
+    if (!Array.isArray(path)) {
+        cb === null || cb === void 0 ? void 0 : cb(INVALID_PATH_ERROR_MESSAGE);
+        return { err: INVALID_PATH_ERROR_MESSAGE };
+    }
+    waitForConfigService();
+    const { err, response } = await RouterClient.query("configService.removeValue", path);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java
+ * Remove multiple values (and their keys) from the config.
+ *
+ * Removing a value will trigger events that you can listen to using <a href="#addlistener">`addListener()`</a>.
+ *
+ * ```javascript
+ * // Remove field1.property1 AND field2.property2
+ * FSBL.Clients.ConfigClient.removeMultiple(
+ *   [
+ * 		['field1', 'property1'],
+ * 		['field2', 'property2']
+ *   ],
+ *   function(err,value){ }
+ * );
+ *
+ * // Remove field1.property1 AND field2.property2
+ * const {err, data} = await FSBL.Clients.ConfigClient.removeMultiple([
+ *   ['field1', 'property1'],
+ *   ['field2', 'property2']
+ * ]);
+ * ```
+ *
+ * :::note
+ * In Java, this method is named `removeValues`.
+ * :::
+ * @param {Function} cb Optional callback.
+ */
+export const removeMultiple = async (paths, cb) => {
+    if (!Array.isArray(paths)) {
+        cb === null || cb === void 0 ? void 0 : cb(INVALID_PATH_ERROR_MESSAGE);
+        return { err: INVALID_PATH_ERROR_MESSAGE };
+    }
+    await SystemManagerClient.waitForStartup("configService");
+    const { err, response } = await RouterClient.query("configService.removeValues", paths);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.remove()`](#remove) instead.
+ *
+ * Remove a value from the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.removeValue({ field:'field1' }, function(err){ });
+ * FSBL.Clients.ConfigClient.removeValue('field1', function(err){ });
+ *
+ * const {err} = await FSBL.Clients.ConfigClient.removeValue({ field:'field1' });
+ * const {err} = await FSBL.Clients.ConfigClient.removeValue('field1');
+ * ```
+ * @param {String} field - Name of field to remove
+ * @param {Function} cb -  Returns an error if there is one
+ */
+export const removeValue = async (params, cb) => {
+    if (typeof params === "string") {
+        params = { field: params };
+    }
+    if (!(params === null || params === void 0 ? void 0 : params.field)) {
+        const err = "No field provided";
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    waitForConfigService();
+    const { err } = await RouterClient.query("configService.removeValue", params);
+    cb === null || cb === void 0 ? void 0 : cb(err);
+    return { err };
+};
+/**
+ * @language javascript, java, dotnet
+ * @deprecated - Use [`FSBL.Clients.ConfigClient.removeMultiple()`](#removemultiple) instead.
+ *
+ * Removes multiple values from the config.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.removeValues(['field1'], function(err){ });
+ * const {err} = await FSBL.Clients.ConfigClient.removeValues(['field1'])
+ * ```
+ * @param {FieldOnlyParam[] | string[]} fields - An array of objects containing a field property or an array of string field names.
+ * @param {Function} cb -  Returns an error if there is one.
+ */
+export const removeValues = async (fields, cb) => {
+    if (!fields) {
+        const err = "ConfigClient.removeValues. No params given";
+        Logger.system.error(err);
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    if (!Array.isArray(fields)) {
+        const err = "ConfigClient.removeValues. Params must be an array";
+        Logger.system.error(err);
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    waitForConfigService();
+    const { err } = await RouterClient.query("configService.removeValues", fields);
+    cb === null || cb === void 0 ? void 0 : cb(err);
+    return { err };
+};
+/**
+ * @language javascript, java, dotnet
+ * Add a listener to the config at either the root config level or field level.
+ * If no field is given, the root config level is used. You can also listen for changes to config fields any number of levels deep -- finsemble.configitem.deeperconfigitem.evendeeperconfigitem
+ *
+ * ```javascript
+ * const myFunction = function(err,data){ };
+ *
+ * FSBL.Clients.ConfigClient.addListener({ field:'field1' }, myFunction, cb);
+ * FSBL.Clients.ConfigClient.addListener(['field1', 'property1'], myFunction, cb); // field1.property1
+ * ```
+ * @param {{ field: string | null } | PathArray} params The piece of data that you want to listen on. If this is empty it listens to all changes of the store.
+ * @param {ListenerFunction} fn The function to be called when the observed piece of config is modified.
+ * @param {Function} cb Callback to be invoked after the listener is added.
+ */
+export const addListener = async (params, fn, cb) => {
+    var _a;
+    const controller = getControllerInstance();
+    let field = null;
+    if (typeof params === "function") {
+        fn = params;
+        params = { field: null };
+    }
+    if (Array.isArray(params)) {
+        field = generateMappingString(params);
+    }
+    else {
+        ({ field } = params);
+    }
+    const fieldName = field ? `.${field}` : "";
+    const combined = `configService${fieldName}`;
+    controller.listeners[combined] = [fn].concat((_a = controller.listeners[combined]) !== null && _a !== void 0 ? _a : []);
+    changeSub(combined);
+    cb === null || cb === void 0 ? void 0 : cb();
+};
+/**
+ * @language javascript, java, dotnet
+ * Add an array of listeners as objects, strings or path arrays.
+ * If using strings, you must provide a function callback as the second parameter.
+ *
+ * ```javascript
+ * const myFunction = function(err,data){}
+ * FSBL.Clients.ConfigClient.addListeners(
+ * 	[
+ * 		{ field: "field1", listener: myFunction },
+ * 		{ field: "field2", listener: myFunction }
+ * 	],
+ * 	null,
+ * 	cb
+ * );
+ *
+ * FSBL.Clients.ConfigClient.addListeners(
+ * [{ field: "field1" }, { field: "field2", listener: myFunction }],
+ * myFunction,
+ * cb
+ * );
+ *
+ * FSBL.Clients.ConfigClient.addListeners(["field1", "field2"], myFunction, cb);
+ * ```
+ * @param {listenerParam[] | string[] | PathArrayListenerParam[]} params.field The piece of data that you want listen on. If this is empty it listen to all config changes.
+ * @param {ListenerFunction} params.listener The function to call when the piece of data is modified. If this is empty, fn is used.
+ * @param {function} fn The function to be called when the observed piece of config is modified.
+ * @param {function} cb Callback to be invoked after the listeners are added.
+
+ */
+export const addListeners = (params, fn, cb) => {
+    var _a;
+    const controller = getControllerInstance();
+    if (!Array.isArray(params)) {
+        Logger.deprecated("configClient - addListeners() with an object instead of an array is deprecated. Please use addListener() instead.");
+        return addListener(params, fn, cb);
+    }
+    const overrideFunction = typeof fn === "function" ? fn : null;
+    for (let i = 0; i < params.length; i++) {
+        const item = params[i];
+        let field = "";
+        if (typeof item === "string") {
+            field = item;
+        }
+        else if (typeof item === "object" && Array.isArray(item.field)) {
+            field = generateMappingString(item.field);
+        }
+        else if (typeof item === "object" && typeof item.field === "string") {
+            field = item.field;
+        }
+        const ls = typeof item !== "string" ? item.listener : overrideFunction;
+        if (ls) {
+            const fieldName = field ? `.${field}` : "";
+            const combined = `configService${fieldName}`;
+            controller.listeners[combined] = [ls].concat((_a = controller.listeners[combined]) !== null && _a !== void 0 ? _a : []);
+            changeSub(combined);
+        }
+    }
+    cb === null || cb === void 0 ? void 0 : cb();
+};
+/**
+ * @language javascript, java, dotnet
+ * Remove a listener from config. If no field is given, we look for a config root listener
+ *
+ * ```javascript
+ * let myFunction = function(err,data){ }
+ *
+ * FSBL.Clients.ConfigClient.removeListener({field:'field1'}, myFunction, function(err, bool){ });
+ * FSBL.Clients.ConfigClient.removeListener(myFunction, function(err, bool){ });
+ * FSBL.Clients.ConfigClient.removeListener(['field1'], myFunction, function(err, bool){ });
+ * ```
+ * @param {function} fn The listener to remove.
+ * @param {function} cb Returns true if it was successful in removing the listener.
+ *
+ */
+export const removeListener = (params, fn, cb) => {
+    const controller = getControllerInstance();
+    let field = null;
+    // The case below is for removing the root level config listener
+    if (typeof params === "function") {
+        cb = fn;
+        fn = params;
+        params = { field };
+    }
+    if (Array.isArray(params)) {
+        field = generateMappingString(params);
+    }
+    else {
+        ({ field } = params);
+    }
+    const fieldName = field ? `.${field}` : "";
+    const combined = `configService${fieldName}`;
+    if (controller.listeners[combined]) {
+        for (let i = 0; i < controller.listeners[combined].length; i++) {
+            if (controller.listeners[combined][i] === fn) {
+                controller.listeners[combined].splice(i, 1);
+                cb === null || cb === void 0 ? void 0 : cb(null, true);
+                return;
+            }
+        }
+    }
+    cb === null || cb === void 0 ? void 0 : cb(null, false);
+};
+/**
+ * @language javascript, java, dotnet
+ * Remove an array of listeners from the config
+ *
+ * ```javascript
+ * let myFunction = function(err,data){ };
+ * FSBL.Clients.ConfigClient.removeListeners(
+ *   {
+ * 	    field: 'field1'
+ *   },
+ *   MyFunction,
+ *   function(bool){ }
+ * );
+ *
+ * FSBL.Clients.ConfigClient.removeListeners(
+ *   [{ field:'field1', listener: MyFunction }],
+ *   function(bool){ }
+ * );
+ *
+ * FSBL.Clients.ConfigClient.removeListeners(
+ *   ['field1'],
+ *   MyFunction,
+ *   function(bool) { }
+ * );
+ * ```
+ * @param {removeListenersType} params
+ * @param {function} fn The listener to remove
+ * @param {function} cb Returns true if it was successful in removing the listener.
+ *
+ */
+export const removeListeners = (params, fn, cb) => {
+    const controller = getControllerInstance();
+    if (!Array.isArray(params)) {
+        if (typeof params === "function") {
+            removeListener({}, params, cb);
+        }
+        else if (params.field && fn) {
+            removeListener(params, fn, cb);
+        }
+        return cb === null || cb === void 0 ? void 0 : cb(null, true);
+    }
+    const overrideFunction = typeof fn === "function" ? fn : null;
+    params.forEach((item) => {
+        let field = "";
+        if (typeof item === "string") {
+            field = item;
+        }
+        else if (typeof item === "object" && Array.isArray(item.field)) {
+            field = generateMappingString(item.field);
+        }
+        else if (typeof item === "object" && typeof item.field === "string") {
+            field = item.field;
+        }
+        const ls = typeof item !== "string" ? item.listener : overrideFunction;
+        const fieldName = field ? `.${field}` : "";
+        const combined = `configService${fieldName}`;
+        controller.listeners[combined] = controller.listeners[combined].filter((listener) => listener !== ls);
+    });
+    cb === null || cb === void 0 ? void 0 : cb(null, true);
+};
+/**
+ * @language javascript, java, dotnet
+ * Dynamically set config values within the Finsemble configuration. You can set new config properties
+ * or modify existing ones. Note that configuration changes will not necessarily dynamically modify
+ * the components or services that use the corresponding configuration -- it depends if the component
+ * or service handles the corresponding change notifications (either though PubSub or the config's
+ * DataStore). Also, these changes do not persist in any config files.
+ *
+ * Only services and components that reside on the same domain as Finsemble can use `proessAndSet`.
+ * If you want to use it from a domain other than Finsemble, you can't do so directly. Instead,
+ * you need to set up a proxy service that is hosted on the same domain as Finsemble.
+ * Because this proxy server is on the same domain as Finsemble, it can use `processAndSet`.
+ * Now, you can have an externally hosted service or app communicate with this proxy service.
+ *
+ * Here is an example:
+ * 1. Create a proxy app service on the Finsemble domain and make it subscribe to a channel
+ * (for example, "customerName.app.config").
+ * 2. The cross domain app publishes the new config on that same channel ("customerName.app.config").
+ * 3. When the proxy app service receives this request, it invokes `ConfigClient.processAndSet(...)` using
+ * the payload from the router message.
+ *
+ * :::note
+ * Any time you set config by using this API, the newConfig along with the updated manifest will by
+ * published to the PubSub topic "Config.changeNotification". To get these notifications any
+ * component or service you can subscribe to the topic. See an example below.
+ * :::
+ *
+ * :::note
+ * Anytime you set config by using this API, the dataStore underlying configuration
+ * 'Finsemble-Configuration-Store' will also be updated. To get these dataStore events, you can set
+ * a listener as shown in the example below. However, any config modifications made directly though
+ * the DataStore will not result in corresponding PubSub notifications.
+ * :::
+ *
+ * :::caution
+ * During dynamic configuration, Finsemble can overwrite components already in the configuration when
+ * `ConfigClient.processAndSet` is called. To prevent this from happening, set
+ * `manifest.component.category = "system"` in the config of the component. For example, use this setting
+ * to prevent system UI components from being dropped out of the config.
+ * :::
+ *
+ * ```javascript
+ * // Examples using processAndSet()
+ * FSBL.Clients.ConfigClient.processAndSet({ newConfig: { myNewConfigField: 12345 }, overwrite: false });
+ * FSBL.Clients.ConfigClient.processAndSet(
+ * {
+ *	newConfig: {
+ *		"myNewConfigField": 12345,
+ *		"myNewConfigObject": {
+ *			A: "this is a test",
+ *			B: "more test"
+ *		},
+ *		"importConfig": [
+ *			"$applicationRoot/configs/application/test.json",
+ *		]
+ *	},
+ *	overwrite: true,
+ *  replace: false,
+ * },
+ *	function (err, finsemble) {
+ *		if (err) {
+ *			console.error("ConfigClient.set", err);
+ *		} else {
+ *			console.log("new finsemble config", finsemble);
+ *		}
+ *	}
+ * );
+ *
+ *  // example subscribing to PubSub to get notifications of dynamic updates
+ * RouterClient.subscribe("Config.changeNotification", function (err, notify) {
+ *		console.log("set notification", notify.data.newConfig, notify.data.finsemble);
+ *	});
+ *
+ *  // example using DataStore to get notifications of dynamic updates
+ * DistributedStoreClient.getStore({ store: 'Finsemble-Configuration-Store', global: true }, function (err, configStore) {
+ *		configStore.addListener({ field: "finsemble" }, function (err, newFinsembleConfig) {
+ *			console.log("new manifest.finsemble configuration", newFinsembleConfig);
+ *		});
+ * });
+ * ```
+ *
+ * @param {object} params
+ * @param {object} params.newConfig Provides the configuration properties to add into the existing configuration under manifest.finsemble. This config must match the Finsemble config requirements as described in the [Configuration tutorial](/docs/customize/customize-with-SDK/configuration). It can include importConfig references to dynamically fetch additional configuration files.
+ * @param {boolean} params.overwrite If true then overwrite any preexisting config with new config (can only set to true when running from same origin, not cross-domain); if false then newConfig must not match properties of existing config, including service and component configuration.
+ * @param {boolean} params.replace True specifies any component, app, or service definitions in the new config will place all existing non-system component and service configuration
+ * @param {StandardErrorCallback} callback Callback to be invoked upon task completion.
+ *
+ */
+export const processAndSet = async (params, cb) => {
+    Logger.system.debug("ConfigClient.processAndSet", params);
+    if (!params.overwrite && params.replace) {
+        const err = "cannot use replace option unless overwrite is also true";
+        Logger.system.warn("ConfigClient.processAndSet:", err);
+        cb === null || cb === void 0 ? void 0 : cb(err);
+        return { err };
+    }
+    else {
+        waitForConfigService();
+        const { err, response } = await RouterClient.query("configService.processAndSet", params);
+        cb === null || cb === void 0 ? void 0 : cb(err, response);
+        return { err, data: response.data };
+    }
+};
+/**
+ * @language javascript, java, dotnet
+ * Sets a value on the configStore and persists that value to storage. On application restart, this value will overwrite any application defaults.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.setPreference({
+ * 	field: "finsemble.initialWorkspace",
+ * 	value: "Workspace 2"
+ * }, (err, response) => {
+ * 		// preference has been set
+ * });
+ *
+ * const {err, data} = await FSBL.Clients.ConfigClient.setPreference({
+ *   field: "finsemble.initialWorkspace",
+ *   value: "Workspace 2"
+ * });
+ * ```
+ * @param {fieldAndValueParam} params
+ * @param {StandardErrorCallback} callback Callback to be invoked when preferences have been retrieved from the service or on error.
+ */
+export const setPreference = async (params, cb) => {
+    const { err, response } = await RouterClient.query("PreferencesService.setPreference", params);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, java, dotnet
+ * Retrieves all of the preferences set for the application.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.getPreferences((err, preferences)=> {
+ * 		 if (!err) {
+ * 		 	console.log(preferences); // an object containing the entire user preferences.
+ * 		 }
+ * });
+ * const {err, data} = await FSBL.Clients.ConfigClient.getPreferences();
+ * ```
+ *
+ * @param {StandardErrorCallback} callback Callback to be invoked when preferences have been retrieved from the service.
+ */
+export const getPreferences = async (cb) => {
+    // need to check since preferences doesn't come up until after authentication, so not always ready
+    await SystemManagerClient.waitForBootStage("authentication", "stageCompleted");
+    const { err, response } = await RouterClient.query("PreferencesService.getPreferences", {});
+    Logger.system.debug("PreferencesService.getPreferences response", response);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @language javascript, dotnet
+ * Reset a user preference value to default. On application restart, the application default value will be used instead of the preference.
+ *
+ * ```javascript
+ * FSBL.Clients.ConfigClient.unsetPreference({
+ * 	field: "finsemble.initialWorkspace",
+ * }, (err, response) => {
+ * 		//preference has been unset
+ * });
+ * const {err, data} = await FSBL.Clients.ConfigClient.unsetPreference({
+ *   field: "finsemble.initialWorkspace"
+ * });
+ * ```
+ * @param params The preference field to unset.
+ * @param callback The callback to be invoked after the preference is removed or on error.
+ */
+export const unsetPreference = async (params, cb) => {
+    Logger.system.debug("ConfigClient.unsetPreference", params);
+    const { err, response } = await RouterClient.query("PreferencesService.unsetPreference", params);
+    cb === null || cb === void 0 ? void 0 : cb(err, response.data);
+    return { err, data: response.data };
+};
+/**
+ * @ignore
+ */
+export const ConfigClient = {
+    /**
+     * For backward compatibility
+     * @private
+     * @deprecated
+     */
+    initialize() {
+        Logger.deprecated("There is no need to call ConfigClient.initialize() anymore.");
+    },
+    /**
+     * For backward compatibility
+     * @private
+     * @deprecated
+     */
+    onReady: (cb) => {
+        Logger.system.deprecated("It is no longer necessary to call ConfigClient.onReady()");
+        cb === null || cb === void 0 ? void 0 : cb();
+    },
+    /**
+     * @private
+     * @deprecated
+     */
+    triggerListeners(listenerKey, data) {
+        Logger.deprecated("Calling ConfigClient.triggerListeners() directly is not legal.");
+        triggerListeners(listenerKey, data);
+    },
+    /**
+     * @private
+     * @deprecated
+     */
+    handleChanges(err, response) {
+        Logger.deprecated("It is illegal to call ConfigClient.handleChanges() directly.");
+        handleChanges(err, response);
+    },
+    /**
+     * @private
+     * @deprecated
+     */
+    async changeSub(change) {
+        Logger.deprecated("Calling ConfigClient.changeSub() directly is not legal.");
+        changeSub(change);
+    },
+    addListener,
+    addListeners,
+    getManifest,
+    getPreferences,
+    getValue,
+    getValues,
+    processAndSet,
+    removeListener,
+    removeListeners,
+    removeValue,
+    removeValues,
+    setPreference,
+    setValue,
+    setValues,
+    unsetPreference,
+    get,
+    getMultiple,
+    set,
+    setMultiple,
+    remove,
+    removeMultiple,
+};
+/**
+ * @ignore
+ */
+export default ConfigClient;
+//# sourceMappingURL=configClient.js.map