@module-federation/utilities 3.1.83 → 3.1.84

package/dist/esm/plugins/DelegateModulesPlugin.mjs

@@ -0,0 +1,84 @@
+
+;// CONCATENATED MODULE: ./src/plugins/DelegateModulesPlugin.ts
+class DelegateModulesPlugin {
+    getChunkByName(chunks, name) {
+        for (const chunk of chunks){
+            if (chunk.name === name) {
+                return chunk;
+            }
+        }
+        return undefined;
+    }
+    addDelegatesToChunks(compilation, chunks) {
+        for (const chunk of chunks){
+            this._delegateModules.forEach((module)=>{
+                this.addModuleAndDependenciesToChunk(module, chunk, compilation);
+            });
+        }
+    }
+    addModuleAndDependenciesToChunk(module, chunk, compilation) {
+        if (!compilation.chunkGraph.isModuleInChunk(module, chunk)) {
+            if (this.options.debug) {
+                console.log('adding ', module.identifier(), ' to chunk', chunk.name);
+            }
+            compilation.chunkGraph.connectChunkAndModule(chunk, module);
+        }
+    }
+    removeDelegatesNonRuntimeChunks(compilation, chunks) {
+        for (const chunk of chunks){
+            if (!chunk.hasRuntime()) {
+                this.options.debug && console.log('non-runtime chunk:', chunk.debugId, chunk.id, chunk.name);
+                for (const [id, module] of this._delegateModules){
+                    compilation.chunkGraph.disconnectChunkAndModule(chunk, module);
+                }
+            }
+        }
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap('DelegateModulesPlugin', (compilation)=>{
+            compilation.hooks.finishModules.tapAsync('DelegateModulesPlugin', (modules, callback)=>{
+                const { remotes } = this.options;
+                const knownDelegates = new Set(remotes ? Object.values(remotes).map((remote)=>remote.replace('internal ', '')) : []);
+                for (const module of modules){
+                    const normalModule = module;
+                    if (normalModule) {
+                        var _normalModule_userRequest;
+                        const mid = normalModule.identifier();
+                        if (normalModule === null || normalModule === void 0 ? void 0 : (_normalModule_userRequest = normalModule.userRequest) === null || _normalModule_userRequest === void 0 ? void 0 : _normalModule_userRequest.startsWith('webpack/container/reference')) {
+                            this._delegateModules.set(mid, normalModule);
+                        }
+                    }
+                    if (normalModule.resource && knownDelegates.has(normalModule.resource)) {
+                        this._delegateModules.set(normalModule.resource, normalModule);
+                    }
+                }
+                callback();
+            });
+            compilation.hooks.optimizeChunks.tap('DelegateModulesPlugin', (chunks)=>{
+                const { runtime, container } = this.options;
+                const runtimeChunk = this.getChunkByName(chunks, runtime);
+                if (!runtimeChunk || !runtimeChunk.hasRuntime()) {
+                    return;
+                }
+                // Get the container chunk if specified
+                const remoteContainer = container ? this.getChunkByName(chunks, container) : null;
+                this.options.debug && console.log(remoteContainer === null || remoteContainer === void 0 ? void 0 : remoteContainer.name, runtimeChunk.name, this._delegateModules.size);
+                this.addDelegatesToChunks(compilation, [
+                    remoteContainer,
+                    runtimeChunk
+                ].filter(Boolean));
+                this.removeDelegatesNonRuntimeChunks(compilation, chunks);
+            });
+        });
+    }
+    constructor(options){
+        this.options = {
+            debug: false,
+            ...options
+        };
+        this._delegateModules = new Map();
+    }
+}
+/* ESM default export */ const plugins_DelegateModulesPlugin = (DelegateModulesPlugin);
+
+export { plugins_DelegateModulesPlugin as default };

package/dist/esm/types/index.mjs

@@ -0,0 +1,6 @@
+
+;// CONCATENATED MODULE: ./src/types/index.ts
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="../../../../webpack/module.d.ts" />
+
+

package/dist/esm/utils/common.mjs

@@ -0,0 +1,126 @@
+import { loadScript } from "./pure.mjs";
+// The require scope
+var __webpack_require__ = {};
+
+/************************************************************************/
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+/************************************************************************/
+
+;// CONCATENATED MODULE: external "./pure.mjs"
+
+;// CONCATENATED MODULE: ./src/utils/common.ts
+/* eslint-disable @typescript-eslint/ban-ts-comment */ 
+const createContainerSharingScope = (asyncContainer)=>{
+    // @ts-ignore
+    return asyncContainer.then(function(container) {
+        if (!__webpack_require__.S['default']) {
+            // not always a promise, so we wrap it in a resolve
+            return Promise.resolve(__webpack_require__.I('default')).then(function() {
+                return container;
+            });
+        } else {
+            return container;
+        }
+    }).then(function(container) {
+        try {
+            // WARNING: here might be a potential BUG.
+            //   `container.init` does not return a Promise, and here we do not call `then` on it.
+            // But according to [docs](https://webpack.js.org/concepts/module-federation/#dynamic-remote-containers)
+            //   it must be async.
+            // The problem may be in Proxy in NextFederationPlugin.js.
+            //   or maybe a bug in the webpack itself - instead of returning rejected promise it just throws an error.
+            // But now everything works properly and we keep this code as is.
+            container.init(__webpack_require__.S['default']);
+        } catch (e) {
+        // maybe container already initialized so nothing to throw
+        }
+        return container;
+    });
+};
+/**
+ * Return initialized remote container by remote's key or its runtime remote item data.
+ *
+ * `runtimeRemoteItem` might be
+ *    { global, url } - values obtained from webpack remotes option `global@url`
+ * or
+ *    { asyncContainer } - async container is a promise that resolves to the remote container
+ */ const injectScript = async (keyOrRuntimeRemoteItem)=>{
+    const asyncContainer = loadScript(keyOrRuntimeRemoteItem);
+    return createContainerSharingScope(asyncContainer);
+};
+/**
+ * Creates runtime variables from the provided remotes.
+ * If the value of a remote starts with 'promise ' or 'external ', it is transformed into a function that returns the promise call.
+ * Otherwise, the value is stringified.
+ * @param {Remotes} remotes - The remotes to create runtime variables from.
+ * @returns {Record<string, string>} - The created runtime variables.
+ */ const createRuntimeVariables = (remotes)=>{
+    if (!remotes) {
+        return {};
+    }
+    return Object.entries(remotes).reduce((acc, [key, value])=>{
+        if (value.startsWith('promise ') || value.startsWith('external ')) {
+            const promiseCall = value.split(' ')[1];
+            acc[key] = `function() {
+        return ${promiseCall}
+      }`;
+        } else {
+            acc[key] = JSON.stringify(value);
+        }
+        return acc;
+    }, {});
+};
+/**
+ * Returns initialized webpack RemoteContainer.
+ * If its' script does not loaded - then load & init it firstly.
+ */ const getContainer = async (remoteContainer)=>{
+    if (!remoteContainer) {
+        throw Error(`Remote container options is empty`);
+    }
+    const containerScope = typeof window !== 'undefined' ? window : globalThis.__remote_scope__;
+    let containerKey;
+    if (typeof remoteContainer === 'string') {
+        containerKey = remoteContainer;
+    } else {
+        containerKey = remoteContainer.uniqueKey;
+        if (!containerScope[containerKey]) {
+            const container = await injectScript({
+                global: remoteContainer.global,
+                url: remoteContainer.url
+            });
+            if (!container) {
+                throw Error(`Remote container ${remoteContainer.url} is empty`);
+            }
+        }
+    }
+    return containerScope[containerKey];
+};
+/**
+ * Return remote module from container.
+ * If you provide `exportName` it automatically return exact property value from module.
+ *
+ * @example
+ *   remote.getModule('./pages/index', 'default')
+ */ const getModule = async ({ remoteContainer, modulePath, exportName })=>{
+    const container = await getContainer(remoteContainer);
+    try {
+        const modFactory = await (container === null || container === void 0 ? void 0 : container.get(modulePath));
+        if (!modFactory) {
+            return undefined;
+        }
+        const mod = modFactory();
+        if (exportName) {
+            return mod && typeof mod === 'object' ? mod[exportName] : undefined;
+        } else {
+            return mod;
+        }
+    } catch (error) {
+        console.error(error);
+        return undefined;
+    }
+};
+
+export { createRuntimeVariables, getContainer, getModule, injectScript };

package/dist/esm/utils/getRuntimeRemotes.mjs

@@ -0,0 +1,52 @@
+import { extractUrlAndGlobal, remoteVars } from "./pure.mjs";
+
+;// CONCATENATED MODULE: external "./pure.mjs"
+
+;// CONCATENATED MODULE: ./src/utils/getRuntimeRemotes.ts
+
+const getRuntimeRemotes = ()=>{
+    try {
+        return Object.entries(remoteVars).reduce(function(acc, item) {
+            const [key, value] = item;
+            // if its an object with a thenable (eagerly executing function)
+            if (typeof value === 'object' && typeof value.then === 'function') {
+                acc[key] = {
+                    asyncContainer: value
+                };
+            } else if (typeof value === 'function') {
+                // @ts-ignore
+                acc[key] = {
+                    asyncContainer: value
+                };
+            } else if (typeof value === 'string' && value.startsWith('internal ')) {
+                const [request, query] = value.replace('internal ', '').split('?');
+                if (query) {
+                    const remoteSyntax = new URLSearchParams(query).get('remote');
+                    if (remoteSyntax) {
+                        const [url, global] = extractUrlAndGlobal(remoteSyntax);
+                        acc[key] = {
+                            global,
+                            url
+                        };
+                    }
+                }
+            } else if (typeof value === 'string') {
+                const [url, global] = extractUrlAndGlobal(value);
+                acc[key] = {
+                    global,
+                    url
+                };
+            } else {
+                //@ts-ignore
+                console.warn('remotes process', process.env.REMOTES);
+                throw new Error(`[mf] Invalid value received for runtime_remote "${key}"`);
+            }
+            return acc;
+        }, {});
+    } catch (err) {
+        console.warn('Unable to retrieve runtime remotes: ', err);
+    }
+    return {};
+};
+
+export { getRuntimeRemotes };

package/dist/esm/utils/getRuntimeRemotes.test.mjs

@@ -0,0 +1,87 @@
+import { getRuntimeRemotes } from "./getRuntimeRemotes.mjs";
+import { remoteVars } from "./pure.mjs";
+
+;// CONCATENATED MODULE: external "./getRuntimeRemotes.mjs"
+
+;// CONCATENATED MODULE: external "./pure.mjs"
+
+;// CONCATENATED MODULE: ./src/utils/getRuntimeRemotes.test.ts
+
+
+xdescribe('getRuntimeRemotes', ()=>{
+    afterEach(()=>{
+        Object.keys(remoteVars).forEach((key)=>{
+            delete remoteVars[key];
+        });
+    });
+    test('returns an empty object if REMOTES is not set', ()=>{
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({});
+    });
+    test('parses asyncContainer from thenable object', ()=>{
+        const thenable = Promise.resolve({
+            get: ()=>true,
+            init: ()=>true
+        });
+        // @ts-ignore
+        remoteVars.thenable = thenable;
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({
+            thenable: {
+                asyncContainer: thenable
+            }
+        });
+    });
+    test('parses asyncContainer from lazily executing function', ()=>{
+        const lazyFunction = ()=>Promise.resolve({
+                get: ()=>true,
+                init: ()=>true
+            });
+        // @ts-ignore
+        remoteVars.lazyFunction = lazyFunction;
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toHaveProperty('lazyFunction.asyncContainer');
+        expect(typeof remotes['lazyFunction'].asyncContainer).toBe('function');
+    });
+    test('parses delegate module', ()=>{
+        // @ts-ignore
+        Object.assign(remoteVars, {
+            delegate: 'internal some_module?remote=remoteGlobal@https://example.com/remoteEntry.js'
+        });
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({
+            delegate: {
+                global: 'remoteGlobal',
+                url: 'https://example.com/remoteEntry.js'
+            }
+        });
+    });
+    test('parses global@url string', ()=>{
+        // @ts-ignore
+        remoteVars.remote = 'remoteGlobal@https://example.com/remoteEntry.js';
+        const remotes = getRuntimeRemotes();
+        expect(remotes).toEqual({
+            remote: {
+                global: 'remoteGlobal',
+                url: 'https://example.com/remoteEntry.js'
+            }
+        });
+    });
+    test('console.warn should be called for unsupported types', ()=>{
+        console.warn = jest.fn();
+        // @ts-ignore
+        remoteVars.unsupported = 42;
+        // Call the function that triggers the warning message
+        getRuntimeRemotes();
+        // Check that console.warn was called with the correct message
+        //@ts-ignore
+        expect(console.warn.mock.calls[0][0]).toMatch(/Unable to retrieve runtime remotes/);
+        //@ts-ignore
+        console.log(console.warn.mock.calls[0][1].message);
+        //@ts-ignore
+        expect(console.warn.mock.calls[0][1].message).toMatch(/runtime_remote/);
+        //@ts-ignore
+        expect(console.warn.mock.calls[0][1].message).toMatch(/unsupported/);
+    });
+});
+

package/dist/esm/utils/importDelegateModule.test.mjs

@@ -0,0 +1,90 @@
+import { importDelegatedModule } from "./importDelegatedModule.mjs";
+import { loadScript } from "./pure.mjs";
+// The require scope
+var __webpack_require__ = {};
+
+/************************************************************************/
+// webpack/runtime/global
+(() => {
+__webpack_require__.g = (() => {
+	if (typeof globalThis === 'object') return globalThis;
+	try {
+		return this || new Function('return this')();
+	} catch (e) {
+		if (typeof window === 'object') return window;
+	}
+})();
+})();
+/************************************************************************/
+
+;// CONCATENATED MODULE: external "./importDelegatedModule.mjs"
+
+;// CONCATENATED MODULE: external "./pure.mjs"
+
+;// CONCATENATED MODULE: ./src/utils/importDelegateModule.test.ts
+
+
+jest.mock('./pure');
+describe('importDelegatedModule', ()=>{
+    let mockLoadScript;
+    let mockRuntimeRemote;
+    beforeEach(()=>{
+        mockLoadScript = jest.fn();
+        mockRuntimeRemote = {
+            get: jest.fn(),
+            init: jest.fn()
+        };
+        loadScript.mockImplementation(()=>Promise.resolve(mockRuntimeRemote));
+    });
+    afterEach(()=>{
+        jest.resetAllMocks();
+    });
+    it('should successfully import a delegated module', async ()=>{
+        const result = await importDelegatedModule('test');
+        expect(loadScript).toHaveBeenCalledWith('test');
+        expect(result).toBe(mockRuntimeRemote);
+    });
+    it('should handle the case when globalThis is not defined', async ()=>{
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        expect(loadScript).toHaveBeenCalledWith({
+            global: 'test'
+        });
+        expect(result).toBe(mockRuntimeRemote);
+    });
+    // Test case for when the module has a function property
+    it('should return a Promise that resolves to the result when the module is a Promise', async ()=>{
+        __webpack_require__.g.window = undefined;
+        mockRuntimeRemote.get.mockImplementation(()=>Promise.resolve('test'));
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        expect(await result.get('test')).toBe('test');
+        __webpack_require__.g.window = {}; // Reset window object
+    });
+    // Test case for when the module has a non-function property
+    xit('should define a non-function property on the result when the module has a non-function property', async ()=>{
+        __webpack_require__.g.window = undefined;
+        mockRuntimeRemote.get.mockImplementation(()=>Promise.resolve(()=>({
+                    testProp: 'test'
+                })));
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        const getterFunction = await result.get('testProp');
+        const getter = getterFunction();
+        expect(getter).toBe('test');
+    });
+    // Test case for when the module is a Promise
+    it('should return a Promise that resolves to the result when the module is a Promise', async ()=>{
+        __webpack_require__.g.window = undefined;
+        mockRuntimeRemote.get.mockImplementation(()=>Promise.resolve('test'));
+        const result = await importDelegatedModule({
+            global: 'test'
+        });
+        expect(result.get('test')).resolves.toBe('test');
+        __webpack_require__.g.window = {}; // Reset window object
+    });
+});
+

package/dist/esm/utils/importDelegatedModule.mjs

@@ -0,0 +1,74 @@
+import { loadScript } from "./pure.mjs";
+
+;// CONCATENATED MODULE: external "./pure.mjs"
+
+;// CONCATENATED MODULE: ./src/utils/importDelegatedModule.ts
+
+const importDelegatedModule = async (keyOrRuntimeRemoteItem)=>{
+    // @ts-ignore
+    return loadScript(keyOrRuntimeRemoteItem).then((asyncContainer)=>{
+        return asyncContainer;
+    }).then((asyncContainer)=>{
+        // most of this is only needed because of legacy promise based implementation
+        // can remove proxies once we remove promise based implementations
+        if (typeof window === 'undefined') {
+            if (!Object.hasOwnProperty.call(keyOrRuntimeRemoteItem, 'globalThis')) {
+                return asyncContainer;
+            }
+            // return asyncContainer;
+            //TODO: need to solve chunk flushing with delegated modules
+            return {
+                get: function(arg) {
+                    //@ts-ignore
+                    return asyncContainer.get(arg).then((f)=>{
+                        const m = f();
+                        const result = {
+                            __esModule: m.__esModule
+                        };
+                        for(const prop in m){
+                            if (typeof m[prop] === 'function') {
+                                Object.defineProperty(result, prop, {
+                                    get: function() {
+                                        return function() {
+                                            //@ts-ignore
+                                            if (globalThis.usedChunks) {
+                                                //@ts-ignore
+                                                globalThis.usedChunks.add(//@ts-ignore
+                                                `${keyOrRuntimeRemoteItem.global}->${arg}`);
+                                            }
+                                            //eslint-disable-next-line prefer-rest-params
+                                            return m[prop](...arguments);
+                                        };
+                                    },
+                                    enumerable: true
+                                });
+                            } else {
+                                Object.defineProperty(result, prop, {
+                                    get: ()=>{
+                                        //@ts-ignore
+                                        if (globalThis.usedChunks) {
+                                            //@ts-ignore
+                                            globalThis.usedChunks.add(//@ts-ignore
+                                            `${keyOrRuntimeRemoteItem.global}->${arg}`);
+                                        }
+                                        return m[prop];
+                                    },
+                                    enumerable: true
+                                });
+                            }
+                        }
+                        if (m.then) {
+                            return Promise.resolve(()=>result);
+                        }
+                        return ()=>result;
+                    });
+                },
+                init: asyncContainer.init
+            };
+        } else {
+            return asyncContainer;
+        }
+    });
+};
+
+export { importDelegatedModule };

package/dist/esm/utils/importRemote.mjs

@@ -0,0 +1,137 @@
+var __webpack_modules__ = ({});
+/************************************************************************/
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+/************************************************************************/
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+/************************************************************************/
+
+;// CONCATENATED MODULE: ./src/utils/importRemote.ts
+/**
+ * Constant for remote entry file
+ * @constant {string}
+ */ const REMOTE_ENTRY_FILE = 'remoteEntry.js';
+/**
+ * Function to load remote
+ * @function
+ * @param {ImportRemoteOptions['url']} url - The url of the remote module
+ * @param {ImportRemoteOptions['scope']} scope - The scope of the remote module
+ * @param {ImportRemoteOptions['bustRemoteEntryCache']} bustRemoteEntryCache - Flag to bust the remote entry cache
+ * @returns {Promise<void>} A promise that resolves when the remote is loaded
+ */ const loadRemote = (url, scope, bustRemoteEntryCache)=>new Promise((resolve, reject)=>{
+        const timestamp = bustRemoteEntryCache ? `?t=${new Date().getTime()}` : '';
+        const webpackRequire = __webpack_require__;
+        webpackRequire.l(`${url}${timestamp}`, (event)=>{
+            var _event_target;
+            if ((event === null || event === void 0 ? void 0 : event.type) === 'load') {
+                // Script loaded successfully:
+                return resolve();
+            }
+            const realSrc = event === null || event === void 0 ? void 0 : (_event_target = event.target) === null || _event_target === void 0 ? void 0 : _event_target.src;
+            const error = new Error();
+            error.message = 'Loading script failed.\n(missing: ' + realSrc + ')';
+            error.name = 'ScriptExternalLoadError';
+            reject(error);
+        }, scope);
+    });
+const loadEsmRemote = async (url, scope)=>{
+    const module = await import(/* webpackIgnore: true */ url);
+    if (!module) {
+        throw new Error(`Unable to load requested remote from ${url} with scope ${scope}`);
+    }
+    window[scope] = {
+        ...module,
+        __initializing: false,
+        __initialized: false
+    };
+};
+/**
+ * Function to initialize sharing
+ * @async
+ * @function
+ */ const initSharing = async ()=>{
+    const webpackShareScopes = __webpack_require__.S;
+    if (!(webpackShareScopes === null || webpackShareScopes === void 0 ? void 0 : webpackShareScopes.default)) {
+        await __webpack_require__.I('default');
+    }
+};
+/**
+ * Function to initialize container
+ * @async
+ * @function
+ * @param {WebpackRemoteContainer} containerScope - The container scope
+ */ const initContainer = async (containerScope)=>{
+    try {
+        const webpackShareScopes = __webpack_require__.S;
+        if (!containerScope.__initialized && !containerScope.__initializing) {
+            containerScope.__initializing = true;
+            await containerScope.init(webpackShareScopes.default);
+            containerScope.__initialized = true;
+            delete containerScope.__initializing;
+        }
+    } catch (error) {
+        console.error(error);
+    }
+};
+/**
+ * Function to import remote
+ * @async
+ * @function
+ * @param {ImportRemoteOptions} options - The options for importing the remote
+ * @returns {Promise<T>} A promise that resolves with the imported module
+ */ const importRemote = async ({ url, scope, module, remoteEntryFileName = REMOTE_ENTRY_FILE, bustRemoteEntryCache = true, esm = false })=>{
+    const remoteScope = scope;
+    if (!window[remoteScope]) {
+        let remoteUrl = '';
+        if (typeof url === 'string') {
+            remoteUrl = url;
+        } else {
+            remoteUrl = await url();
+        }
+        const remoteUrlWithEntryFile = `${remoteUrl}/${remoteEntryFileName}`;
+        const asyncContainer = !esm ? loadRemote(remoteUrlWithEntryFile, scope, bustRemoteEntryCache) : loadEsmRemote(remoteUrlWithEntryFile, scope);
+        // Load the remote and initialize the share scope if it's empty
+        await Promise.all([
+            asyncContainer,
+            initSharing()
+        ]);
+        if (!window[remoteScope]) {
+            throw new Error(`Remote loaded successfully but ${scope} could not be found! Verify that the name is correct in the Webpack configuration!`);
+        }
+        // Initialize the container to get shared modules and get the module factory:
+        const [, moduleFactory] = await Promise.all([
+            initContainer(window[remoteScope]),
+            window[remoteScope].get(module === '.' || module.startsWith('./') ? module : `./${module}`)
+        ]);
+        return moduleFactory();
+    } else {
+        const moduleFactory = await window[remoteScope].get(module === '.' || module.startsWith('./') ? module : `./${module}`);
+        return moduleFactory();
+    }
+};
+
+export { importRemote };

package/dist/esm/utils/isEmpty.mjs

@@ -0,0 +1,10 @@
+
+;// CONCATENATED MODULE: ./src/utils/isEmpty.ts
+const isObjectEmpty = (obj)=>{
+    for(const x in obj){
+        return false;
+    }
+    return true;
+};
+
+export { isObjectEmpty };