breeze-client 2.2.1-cjs → 2.2.2

package/esm2022/src/config.mjs

@@ -0,0 +1,232 @@
+import { core } from './core';
+import { assertParam } from './assert-param';
+import { BreezeEvent } from './event';
+export class InterfaceDef {
+    name;
+    defaultInstance;
+    /** @hidden @internal */
+    _implMap;
+    constructor(name) {
+        this.name = name;
+        this.defaultInstance = undefined;
+        this._implMap = {};
+    }
+    /** Define an implementation of the given adaptername */
+    registerCtor(adapterName, ctor) {
+        this._implMap[adapterName.toLowerCase()] = { ctor: ctor, defaultInstance: undefined };
+    }
+    /** Return the definition for the given adapterName */
+    getImpl(adapterName) {
+        return this._implMap[adapterName.toLowerCase()];
+    }
+    /** Return the first implementation for this InterfaceDef */
+    getFirstImpl() {
+        let kv = core.objectFirst(this._implMap, function () {
+            return true;
+        });
+        return kv ? kv.value : null;
+    }
+    getDefaultInstance() {
+        return this.defaultInstance;
+    }
+}
+export class BreezeConfig {
+    functionRegistry = {};
+    typeRegistry = {};
+    objectRegistry = {};
+    interfaceInitialized;
+    stringifyPad = '';
+    /** whether to prohibit eval() and Function() in breeze code */
+    noEval;
+    /** @hidden @internal */
+    _interfaceRegistry; // will be set in adapter-interfaces. untyped here to avoid circularity issues.
+    constructor() {
+        this.interfaceInitialized = new BreezeEvent("interfaceInitialized", this);
+        if (this.noEval === undefined) {
+            try {
+                Error['x'] = Function('');
+                this.noEval = false; // eval succeeded
+            }
+            catch {
+                this.noEval = true; // eval failed, probably due to CSP
+            }
+        }
+    }
+    /**
+    Method use to register implementations of standard breeze interfaces.  Calls to this method are usually
+    made as the last step within an adapter implementation.
+    @method registerAdapter
+    @param interfaceName {String} - one of the following interface names: "ajax", "dataService", "modelLibrary", "uriBuilder"
+    @param adapterCtor {Function} - an ctor function that returns an instance of the specified interface.
+    **/
+    registerAdapter(interfaceName, adapterCtor) {
+        assertParam(interfaceName, "interfaceName").isNonEmptyString().check();
+        assertParam(adapterCtor, "adapterCtor").isFunction().check();
+        // this impl will be thrown away after the name is retrieved.
+        let impl = new adapterCtor();
+        let implName = impl.name;
+        if (!implName) {
+            throw new Error("Unable to locate a 'name' property on the constructor passed into the 'registerAdapter' call.");
+        }
+        let idef = this.getInterfaceDef(interfaceName);
+        idef.registerCtor(implName, adapterCtor);
+    }
+    /**
+    Returns the ctor function used to implement a specific interface with a specific adapter name.
+    @method getAdapter
+    @param interfaceName {String} One of the following interface names: "ajax", "dataService", "modelLibrary", "uriBuilder"
+    @param [adapterName] {String} The name of any previously registered adapter. If this parameter is omitted then
+    this method returns the "default" adapter for this interface. If there is no default adapter, then a null is returned.
+    @return {Function|null} Returns either a ctor function or null.
+    **/
+    getAdapter(interfaceName, adapterName) {
+        let idef = this.getInterfaceDef(interfaceName);
+        if (adapterName) {
+            let impl = idef.getImpl(adapterName);
+            return impl ? impl.ctor : null;
+        }
+        else {
+            return idef.defaultInstance ? idef.defaultInstance._$impl.ctor : null;
+        }
+    }
+    /**
+    Initializes a single adapter implementation. Initialization means either newing a instance of the
+    specified interface and then calling "initialize" on it or simply calling "initialize" on the instance
+    if it already exists.
+    @method initializeAdapterInstance
+    @param interfaceName {String} The name of the interface to which the adapter to initialize belongs.
+    @param adapterName {String} - The name of a previously registered adapter to initialize.
+    @param [isDefault=true] {Boolean} - Whether to make this the default "adapter" for this interface.
+    @return {an instance of the specified adapter}
+    **/
+    initializeAdapterInstance(interfaceName, adapterName, isDefault = true) {
+        isDefault = isDefault === undefined ? true : isDefault;
+        assertParam(interfaceName, "interfaceName").isNonEmptyString().check();
+        assertParam(adapterName, "adapterName").isNonEmptyString().check();
+        assertParam(isDefault, "isDefault").isBoolean().check();
+        let idef = this.getInterfaceDef(interfaceName);
+        let impl = idef.getImpl(adapterName);
+        if (!impl) {
+            throw new Error("Unregistered adapter.  Interface: " + interfaceName + " AdapterName: " + adapterName);
+        }
+        return this._initializeAdapterInstanceCore(idef, impl, isDefault);
+    }
+    /**
+    Returns the adapter instance corresponding to the specified interface and adapter names.
+    @method getAdapterInstance
+    @param interfaceName {String} The name of the interface.
+    @param [adapterName] {String} - The name of a previously registered adapter.  If this parameter is
+    omitted then the default implementation of the specified interface is returned. If there is
+    no defaultInstance of this interface, then the first registered instance of this interface is returned.
+    @return {an instance of the specified adapter}
+    @internal
+    **/
+    getAdapterInstance(interfaceName, adapterName) {
+        let idef = this.getInterfaceDef(interfaceName);
+        let impl;
+        let isDefault = adapterName == null || adapterName === "";
+        if (isDefault) {
+            if (idef.defaultInstance)
+                return idef.defaultInstance;
+            impl = idef.getFirstImpl();
+        }
+        else {
+            impl = idef.getImpl(adapterName);
+        }
+        if (!impl)
+            return undefined;
+        if (impl.defaultInstance) {
+            return impl.defaultInstance;
+        }
+        else {
+            return this._initializeAdapterInstanceCore(idef, impl, isDefault);
+        }
+    }
+    /** this is needed for reflection purposes when deserializing an object that needs a fn or ctor.
+        Used to register validators. */
+    registerFunction(fn, fnName) {
+        assertParam(fn, "fn").isFunction().check();
+        assertParam(fnName, "fnName").isString().check();
+        if (fn.prototype) {
+            fn.prototype._$fnName = fnName;
+        }
+        this.functionRegistry[fnName] = fn;
+    }
+    registerType(ctor, typeName) {
+        assertParam(ctor, "ctor").isFunction().check();
+        assertParam(typeName, "typeName").isString().check();
+        if (ctor.prototype) {
+            ctor.prototype._$typeName = typeName;
+        }
+        this.typeRegistry[typeName] = ctor;
+    }
+    getRegisteredFunction(fnName) {
+        return this.functionRegistry[fnName];
+    }
+    getInterfaceDef(interfaceName) {
+        let lcName = interfaceName.toLowerCase();
+        // source may be null
+        let kv = core.objectFirst(this._interfaceRegistry || {}, function (k, v) {
+            return k.toLowerCase() === lcName;
+        });
+        if (!kv) {
+            throw new Error("Unknown interface name: " + interfaceName);
+        }
+        return kv.value;
+    }
+    /** @deprecated @internal no-op kept for backward compatibility */
+    setQ(q) {
+        console && console.warn("setQ does nothing; ES6 Promise support is required - use a shim if necessary.");
+    }
+    /** @hidden @internal */
+    _storeObject(obj, type, name) {
+        // uncomment this if we make this public.
+        //assertParam(obj, "obj").isObject().check();
+        //assertParam(name, "objName").isString().check();
+        let key = (typeof (type) === "string" ? type : type.prototype._$typeName) + "." + name;
+        this.objectRegistry[key] = obj;
+    }
+    /** @hidden @internal */
+    _fetchObject(type, name) {
+        if (!name)
+            return undefined;
+        let key = (typeof (type) === "string" ? type : type.prototype._$typeName) + "." + name;
+        let result = this.objectRegistry[key];
+        if (!result) {
+            throw new Error("Unable to locate a registered object by the name: " + key);
+        }
+        return result;
+    }
+    /** @hidden @internal */
+    _initializeAdapterInstanceCore(interfaceDef, impl, isDefault) {
+        let instance;
+        let inst = impl.defaultInstance;
+        if (!inst) {
+            instance = new (impl.ctor)();
+            impl.defaultInstance = instance;
+            instance._$impl = impl;
+        }
+        else {
+            instance = inst;
+        }
+        instance.initialize();
+        if (isDefault) {
+            // next line needs to occur before any recomposition
+            interfaceDef.defaultInstance = instance;
+        }
+        // recomposition of other impls will occur here.
+        this.interfaceInitialized.publish({ interfaceName: interfaceDef.name, instance: instance, isDefault: true });
+        if (instance.checkForRecomposition != null) {
+            // now register for own dependencies.
+            this.interfaceInitialized.subscribe((interfaceInitializedArgs) => {
+                // TODO: why '!'s needed here for typescript to compile correctly???
+                instance.checkForRecomposition(interfaceInitializedArgs);
+            });
+        }
+        return instance;
+    }
+}
+export const config = new BreezeConfig();
+// legacy
+core.config = config;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/config.ts"],"names":[],"mappings":"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","sourcesContent":["import { core } from './core';\r\nimport { assertParam  } from './assert-param';\r\nimport { BreezeEvent } from './event';\r\n\r\n/** @hidden */\r\nexport interface AdapterCtor<T extends BaseAdapter> { new (...args: any[]): T; }\r\n/** @hidden */\r\nexport interface IDef<T extends BaseAdapter> { ctor: AdapterCtor<T>; defaultInstance?: T; }\r\n\r\nexport type AdapterType = 'dataService'|'modelLibrary'|'ajax'|'uriBuilder';\r\n\r\nexport class InterfaceDef<T extends BaseAdapter> {\r\n\r\n    name: string;\r\n    defaultInstance?: T;\r\n    /** @hidden @internal */\r\n    _implMap: { [name: string]: IDef<T> };\r\n\r\n    constructor(name: string) {\r\n        this.name = name;\r\n        this.defaultInstance = undefined;\r\n        this._implMap = {};\r\n    }\r\n\r\n    /** Define an implementation of the given adaptername */\r\n    registerCtor(adapterName: string, ctor: AdapterCtor<T>): void {\r\n        this._implMap[adapterName.toLowerCase()] = { ctor: ctor, defaultInstance: undefined };\r\n    }\r\n\r\n    /** Return the definition for the given adapterName */\r\n    getImpl(adapterName: string): IDef<T> {\r\n        return this._implMap[adapterName.toLowerCase()];\r\n    }\r\n\r\n    /** Return the first implementation for this InterfaceDef */\r\n    getFirstImpl(): IDef<T> {\r\n        let kv = core.objectFirst(this._implMap, function () {\r\n            return true;\r\n        });\r\n        return kv ? kv.value : null;\r\n    }\r\n\r\n    getDefaultInstance() {\r\n        return this.defaultInstance as T;\r\n    }\r\n}\r\n\r\nexport interface BaseAdapter {\r\n    /** @hidden @internal */\r\n    _$impl?: any;\r\n    name: string;\r\n    initialize(): void;\r\n    checkForRecomposition?: (context: any) => void;\r\n}\r\n\r\nexport class BreezeConfig {\r\n    functionRegistry = {};\r\n    typeRegistry = {};\r\n    objectRegistry = {};\r\n    interfaceInitialized: BreezeEvent<{ interfaceName: string, instance: BaseAdapter, isDefault: boolean }>;\r\n\r\n    stringifyPad = '';\r\n    /** whether to prohibit eval() and Function() in breeze code */\r\n    noEval: boolean;\r\n    /** @hidden @internal */\r\n    _interfaceRegistry: any;  // will be set in adapter-interfaces. untyped here to avoid circularity issues.\r\n\r\n    constructor() {\r\n        this.interfaceInitialized = new BreezeEvent(\"interfaceInitialized\", this);\r\n        if (this.noEval === undefined) {\r\n            try {\r\n                Error['x'] = Function('');\r\n                this.noEval = false; // eval succeeded\r\n            } catch {\r\n                this.noEval = true; // eval failed, probably due to CSP\r\n            }\r\n        }\r\n        \r\n    }\r\n\r\n    /**\r\n    Method use to register implementations of standard breeze interfaces.  Calls to this method are usually\r\n    made as the last step within an adapter implementation.\r\n    @method registerAdapter\r\n    @param interfaceName {String} - one of the following interface names: \"ajax\", \"dataService\", \"modelLibrary\", \"uriBuilder\"\r\n    @param adapterCtor {Function} - an ctor function that returns an instance of the specified interface.\r\n    **/\r\n    registerAdapter<T extends BaseAdapter>(interfaceName: AdapterType, adapterCtor: AdapterCtor<T>) {\r\n        assertParam(interfaceName, \"interfaceName\").isNonEmptyString().check();\r\n        assertParam(adapterCtor, \"adapterCtor\").isFunction().check();\r\n        // this impl will be thrown away after the name is retrieved.\r\n        let impl = new adapterCtor();\r\n        let implName = impl.name;\r\n        if (!implName) {\r\n            throw new Error(\"Unable to locate a 'name' property on the constructor passed into the 'registerAdapter' call.\");\r\n        }\r\n        let idef = this.getInterfaceDef(interfaceName);\r\n        idef.registerCtor(implName, adapterCtor);\r\n    }\r\n\r\n    /**\r\n    Returns the ctor function used to implement a specific interface with a specific adapter name.\r\n    @method getAdapter\r\n    @param interfaceName {String} One of the following interface names: \"ajax\", \"dataService\", \"modelLibrary\", \"uriBuilder\"\r\n    @param [adapterName] {String} The name of any previously registered adapter. If this parameter is omitted then\r\n    this method returns the \"default\" adapter for this interface. If there is no default adapter, then a null is returned.\r\n    @return {Function|null} Returns either a ctor function or null.\r\n    **/\r\n    getAdapter(interfaceName: AdapterType, adapterName: string) {\r\n        let idef = this.getInterfaceDef(interfaceName);\r\n        if (adapterName) {\r\n            let impl = idef.getImpl(adapterName);\r\n            return impl ? impl.ctor : null;\r\n        } else {\r\n            return idef.defaultInstance ? idef.defaultInstance._$impl.ctor : null;\r\n        }\r\n    }\r\n\r\n    /**\r\n    Initializes a single adapter implementation. Initialization means either newing a instance of the\r\n    specified interface and then calling \"initialize\" on it or simply calling \"initialize\" on the instance\r\n    if it already exists.\r\n    @method initializeAdapterInstance\r\n    @param interfaceName {String} The name of the interface to which the adapter to initialize belongs.\r\n    @param adapterName {String} - The name of a previously registered adapter to initialize.\r\n    @param [isDefault=true] {Boolean} - Whether to make this the default \"adapter\" for this interface.\r\n    @return {an instance of the specified adapter}\r\n    **/\r\n    initializeAdapterInstance(interfaceName: AdapterType, adapterName: string, isDefault: boolean = true) {\r\n        isDefault = isDefault === undefined ? true : isDefault;\r\n        assertParam(interfaceName, \"interfaceName\").isNonEmptyString().check();\r\n        assertParam(adapterName, \"adapterName\").isNonEmptyString().check();\r\n        assertParam(isDefault, \"isDefault\").isBoolean().check();\r\n\r\n        let idef = this.getInterfaceDef(interfaceName);\r\n        let impl = idef.getImpl(adapterName);\r\n        if (!impl) {\r\n            throw new Error(\"Unregistered adapter.  Interface: \" + interfaceName + \" AdapterName: \" + adapterName);\r\n        }\r\n\r\n        return this._initializeAdapterInstanceCore(idef, impl, isDefault);\r\n    }\r\n\r\n    /**\r\n    Returns the adapter instance corresponding to the specified interface and adapter names.\r\n    @method getAdapterInstance\r\n    @param interfaceName {String} The name of the interface.\r\n    @param [adapterName] {String} - The name of a previously registered adapter.  If this parameter is\r\n    omitted then the default implementation of the specified interface is returned. If there is\r\n    no defaultInstance of this interface, then the first registered instance of this interface is returned.\r\n    @return {an instance of the specified adapter}\r\n    @internal\r\n    **/\r\n    getAdapterInstance<T extends BaseAdapter>(interfaceName: AdapterType, adapterName?: string) {\r\n        let idef = this.getInterfaceDef<T>(interfaceName);\r\n        let impl: IDef<T>;\r\n\r\n        let isDefault = adapterName == null || adapterName === \"\";\r\n        if (isDefault) {\r\n            if (idef.defaultInstance) return idef.defaultInstance;\r\n            impl = idef.getFirstImpl();\r\n        } else {\r\n            impl = idef.getImpl(adapterName!);\r\n        }\r\n        if (!impl) return undefined;\r\n        if (impl.defaultInstance) {\r\n            return impl.defaultInstance;\r\n        } else {\r\n            return this._initializeAdapterInstanceCore(idef, impl, isDefault);\r\n        }\r\n    }\r\n\r\n    /** this is needed for reflection purposes when deserializing an object that needs a fn or ctor.\r\n        Used to register validators. */\r\n    registerFunction(fn: Function, fnName: string) {\r\n        assertParam(fn, \"fn\").isFunction().check();\r\n        assertParam(fnName, \"fnName\").isString().check();\r\n        if (fn.prototype) {\r\n            fn.prototype._$fnName = fnName;\r\n        }\r\n        this.functionRegistry[fnName] = fn;\r\n    }\r\n\r\n    registerType(ctor: Function, typeName: string) {\r\n        assertParam(ctor, \"ctor\").isFunction().check();\r\n        assertParam(typeName, \"typeName\").isString().check();\r\n        if (ctor.prototype) {\r\n            ctor.prototype._$typeName = typeName;\r\n        }\r\n        this.typeRegistry[typeName] = ctor;\r\n    }\r\n\r\n    getRegisteredFunction(fnName: string) {\r\n        return this.functionRegistry[fnName];\r\n    }\r\n\r\n    getInterfaceDef<T extends BaseAdapter>(interfaceName: string) {\r\n        let lcName = interfaceName.toLowerCase();\r\n        // source may be null\r\n        let kv = core.objectFirst(this._interfaceRegistry || {}, function (k, v) {\r\n            return k.toLowerCase() === lcName;\r\n        });\r\n        if (!kv) {\r\n            throw new Error(\"Unknown interface name: \" + interfaceName);\r\n        }\r\n        return <InterfaceDef<T>>kv.value;\r\n    }\r\n\r\n    /** @deprecated @internal no-op kept for backward compatibility */\r\n    setQ(q: any) {\r\n        console && console.warn(\"setQ does nothing; ES6 Promise support is required - use a shim if necessary.\");\r\n    }\r\n\r\n    /** @hidden @internal */\r\n    _storeObject(obj: Object, type: string | Function, name: string) {\r\n        // uncomment this if we make this public.\r\n        //assertParam(obj, \"obj\").isObject().check();\r\n        //assertParam(name, \"objName\").isString().check();\r\n        let key = (typeof (type) === \"string\" ? type : type.prototype._$typeName) + \".\" + name;\r\n        this.objectRegistry[key] = obj;\r\n    }\r\n\r\n    /** @hidden @internal */\r\n    _fetchObject(type: string | Function, name: string) {\r\n        if (!name) return undefined;\r\n        let key = (typeof (type) === \"string\" ? type : type.prototype._$typeName) + \".\" + name;\r\n        let result = this.objectRegistry[key];\r\n        if (!result) {\r\n            throw new Error(\"Unable to locate a registered object by the name: \" + key);\r\n        }\r\n        return result;\r\n    }\r\n\r\n    /** @hidden @internal */\r\n    _initializeAdapterInstanceCore<T extends BaseAdapter>(interfaceDef: InterfaceDef<T>, impl: IDef<T>, isDefault: boolean) {\r\n        let instance: T;\r\n        let inst = impl.defaultInstance;\r\n        if (!inst) {\r\n            instance = new (impl.ctor)();\r\n            impl.defaultInstance = instance;\r\n            instance._$impl = impl;\r\n        } else {\r\n            instance = inst;\r\n        }\r\n\r\n        instance.initialize();\r\n\r\n        if (isDefault) {\r\n            // next line needs to occur before any recomposition\r\n            interfaceDef.defaultInstance = instance;\r\n        }\r\n\r\n        // recomposition of other impls will occur here.\r\n        this.interfaceInitialized.publish({ interfaceName: interfaceDef.name, instance: instance, isDefault: true });\r\n\r\n        if (instance.checkForRecomposition != null) {\r\n            // now register for own dependencies.\r\n            this.interfaceInitialized.subscribe((interfaceInitializedArgs) => {\r\n                // TODO: why '!'s needed here for typescript to compile correctly???\r\n                instance.checkForRecomposition!(interfaceInitializedArgs);\r\n            });\r\n        }\r\n\r\n        return instance;\r\n    }\r\n\r\n}\r\n\r\nexport const config = new BreezeConfig();\r\n\r\n// legacy\r\n(core as any).config = config;\r\n\r\n\r\n\r\n"]}