repluggable-core 1.302.66 → 1.302.67

package/dist/es/src/appHost.js

@@ -0,0 +1,898 @@
+import _ from 'lodash';
+import { createAppHostServicesEntryPoint } from './appHostServices';
+import { declaredAPIs, dependentAPIs } from './appHostUtils';
+import { createCustomExtensionSlot, createExtensionSlot } from './extensionSlot';
+import { InstalledShellsActions, InstalledShellsSelectors } from './installedShellsState';
+import { IterableWeakMap } from './IterableWeakMap';
+import { ConsoleHostLogger, createShellLogger } from './loggers';
+import { monitorAPI } from './monitorAPI';
+import { setupDebugInfo } from './repluggableAppDebug';
+import { getCycle, Graph, Tarjan } from './tarjanGraph';
+import { createObservable, createThrottledStore, updateThrottledStore } from './throttledStore';
+import { INTERNAL_DONT_USE_SHELL_GET_APP_HOST } from './__internal';
+function isMultiArray(v) {
+    return _.every(v, _.isArray);
+}
+function castMultiArray(v) {
+    return isMultiArray(v) ? v : [v];
+}
+export const makeLazyEntryPoint = (name, factory) => {
+    return {
+        name,
+        factory
+    };
+};
+export const mainViewSlotKey = {
+    name: 'mainView'
+};
+export const stateSlotKey = {
+    name: 'state'
+};
+const toShellToggleSet = (names, isInstalled) => {
+    return names.reduce((result, name) => {
+        result[name] = isInstalled;
+        return result;
+    }, {});
+};
+const createUnreadyEntryPointsStore = () => {
+    let entryPoints = [];
+    return {
+        get() {
+            return entryPoints;
+        },
+        set(newEntryPoints) {
+            entryPoints = newEntryPoints;
+        }
+    };
+};
+const verifyLayersUniqueness = (layers) => {
+    if (!layers) {
+        return;
+    }
+    const flatLayers = _.flatten(layers);
+    const nonUnique = _(flatLayers)
+        .countBy(({ name }) => name)
+        .pickBy(v => v > 1)
+        .keys()
+        .value();
+    if (nonUnique.length > 0) {
+        throw new Error(`Cannot initialize host with non unique layers: ${nonUnique}`);
+    }
+};
+export function createAppHost(initialEntryPointsOrPackages, options = { monitoring: {} }) {
+    let store = null;
+    let isInstallingEntryPoints = false;
+    let isStoreSubscribersNotifyInProgress = false;
+    let isObserversNotifyInProgress = false;
+    let shouldFlushMemoizationSync = false;
+    let isBatchingDeclarationsChangedCallbacks = false;
+    const entryPointsInstallationEndCallbacks = new Map();
+    verifyLayersUniqueness(options.layers);
+    const unReadyEntryPointsStore = createUnreadyEntryPointsStore();
+    const layers = _.map(options.layers ? castMultiArray(options.layers) : [], (singleDimension, i) => _.map(singleDimension, layer => (Object.assign(Object.assign({}, layer), { dimension: i }))));
+    const trace = [];
+    const memoizedArr = [];
+    const readyAPIs = new Set();
+    const createExtensionSlotsMap = () => {
+        const originalMap = new Map();
+        const proxyHandler = {
+            get(target, propertyName) {
+                if (propertyName === 'set') {
+                    return function (key, value) {
+                        return batchDeclarationsChangedCallbacks(() => target.set(key, value));
+                    };
+                }
+                if (propertyName === 'delete') {
+                    return function (key) {
+                        return batchDeclarationsChangedCallbacks(() => target.delete(key));
+                    };
+                }
+                const originalProperty = target[propertyName];
+                if (typeof originalProperty === 'function') {
+                    return originalProperty.bind(target);
+                }
+                return originalProperty;
+            }
+        };
+        return new Proxy(originalMap, proxyHandler);
+    };
+    const uniqueShellNames = new Set();
+    const extensionSlots = createExtensionSlotsMap();
+    const slotKeysByName = new Map();
+    const addedShells = new Map();
+    const shellInstallers = new WeakMap();
+    const lazyShells = new Map();
+    const shellsChangedCallbacks = new Map();
+    const declarationsChangedCallbacks = new Map();
+    const APILayers = new WeakMap();
+    const memoizedFunctions = new IterableWeakMap();
+    let shouldFlushMemoization = false;
+    const hostAPI = {
+        getAllEntryPoints: () => [...addedShells.entries()].map(([, { entryPoint }]) => entryPoint),
+        getAppHostOptions: () => options
+    };
+    const appHostServicesEntryPoint = createAppHostServicesEntryPoint(() => hostAPI);
+    const host = {
+        getStore,
+        getAPI,
+        hasAPI,
+        getSlot,
+        hasSlot,
+        getAllSlotKeys,
+        getAllEntryPoints,
+        hasShell,
+        isLazyEntryPoint,
+        addShells,
+        removeShells,
+        onShellsChanged,
+        onDeclarationsChanged,
+        removeShellsChangedCallback,
+        getAppHostServicesShell: appHostServicesEntryPoint.getAppHostServicesShell,
+        log: options.logger ? options.logger : ConsoleHostLogger,
+        options,
+        executeWhenFree
+    };
+    setupDebugInfo({
+        host,
+        readyAPIs,
+        uniqueShellNames,
+        extensionSlots,
+        addedShells,
+        shellInstallers,
+        lazyShells,
+        performance: {
+            options,
+            trace,
+            memoizedArr
+        },
+        getUnreadyEntryPoints: unReadyEntryPointsStore.get,
+        getOwnSlotKey,
+        getAPI
+    });
+    declareSlot(mainViewSlotKey);
+    declareSlot(stateSlotKey);
+    addShells([appHostServicesEntryPoint]);
+    const memoize = (func, resolver) => {
+        if (options.monitoring.disableMemoization) {
+            return func;
+        }
+        const memoized = _.memoize(func, resolver);
+        if (options.monitoring.debugMemoization) {
+            Object.defineProperty(memoized, 'name', { value: `${func.name}_memoized`, writable: false });
+        }
+        if (options.monitoring.disableMonitoring) {
+            return memoized;
+        }
+        const enrichedMemoization = enrichMemoization(memoized);
+        if (options.monitoring.debugMemoization) {
+            return (...args) => {
+                const memRes = enrichedMemoization(...args);
+                const res = func(...args);
+                if (!_.isEqual(memRes, res)) {
+                    console.log(`Memoization Error`);
+                    console.log(`Memoization returns:`, memRes);
+                    console.log(`Original Func returns:`, res);
+                    console.log(`Original Func:`, func);
+                }
+                return memRes;
+            };
+        }
+        return enrichedMemoization;
+    };
+    function lazyEvaluator(fn) {
+        let _value;
+        let _resolved = false;
+        return {
+            get: () => {
+                if (!_resolved) {
+                    _value = fn();
+                    _resolved = true;
+                }
+                return _value;
+            }
+        };
+    }
+    // we know that addShells completes synchronously
+    addShells(initialEntryPointsOrPackages);
+    return host;
+    //TODO: get rid of LazyEntryPointDescriptor
+    function isLazyEntryPointDescriptor(value) {
+        return typeof value.factory === 'function';
+    }
+    function enrichMemoization(memoized) {
+        const memoizedWithMissHit = _.assign(memoized, {
+            miss: 0,
+            calls: 0,
+            hit: 0,
+            printHitMiss: () => console.log(`calls: ${memoizedWithMissHit.calls}
+hit: ${memoizedWithMissHit.hit}
+miss: ${memoizedWithMissHit.miss}
+`)
+        });
+        const getter = memoizedWithMissHit.cache.get.bind(memoized.cache);
+        memoizedWithMissHit.cache.get = (key) => {
+            memoizedWithMissHit.calls++;
+            memoizedWithMissHit.hit++;
+            return getter(key);
+        };
+        const setter = memoizedWithMissHit.cache.set.bind(memoizedWithMissHit.cache);
+        memoizedWithMissHit.cache.set = (key, value) => {
+            memoizedWithMissHit.calls++;
+            memoizedWithMissHit.miss++;
+            return setter(key, value);
+        };
+        return memoizedWithMissHit;
+    }
+    function getLayerByName(layerName) {
+        const layer = _(layers).flatten().find({ name: layerName });
+        if (!layer) {
+            throw new Error(`Cannot find layer ${layerName}`);
+        }
+        return layer;
+    }
+    function validateEntryPointLayer(entryPoint) {
+        if (!entryPoint.getDependencyAPIs || !entryPoint.layer || _.isEmpty(layers)) {
+            return;
+        }
+        const highestLevelDependencies = _.chain(entryPoint.getDependencyAPIs())
+            .flatMap(apiKey => apiKey.layer
+            ? _(apiKey.layer)
+                .castArray()
+                .map(l => ({
+                layer: getLayerByName(l),
+                apiKey
+            }))
+                .value()
+            : { apiKey })
+            .groupBy(dependency => { var _a; return (_a = dependency === null || dependency === void 0 ? void 0 : dependency.layer) === null || _a === void 0 ? void 0 : _a.dimension; })
+            .map(dimension => _.maxBy(dimension, dependency => ((dependency === null || dependency === void 0 ? void 0 : dependency.layer) ? dependency.layer.level : -Infinity)))
+            .value();
+        const currentLayers = _(entryPoint.layer)
+            .castArray()
+            .map(l => getLayerByName(l))
+            .value();
+        const getCurrentLayerOfSameDimension = (layer) => {
+            return currentLayers.find(entryPointLayer => entryPointLayer.dimension === layer.dimension);
+        };
+        highestLevelDependencies.forEach(highestLevelDependency => {
+            const currentLayer = (highestLevelDependency === null || highestLevelDependency === void 0 ? void 0 : highestLevelDependency.layer) && getCurrentLayerOfSameDimension(highestLevelDependency.layer);
+            if ((highestLevelDependency === null || highestLevelDependency === void 0 ? void 0 : highestLevelDependency.layer) && currentLayer && currentLayer.level < highestLevelDependency.layer.level) {
+                throw new Error(`Entry point ${entryPoint.name} of layer ${currentLayer.name} cannot depend on API ${slotKeyToName(highestLevelDependency.apiKey)} of layer ${highestLevelDependency.layer.name}`);
+            }
+        });
+    }
+    function validateLayers(entryPoints) {
+        _.forEach(entryPoints, ep => validateEntryPointLayer(ep));
+    }
+    function addShells(entryPointsOrPackages) {
+        host.log.log('debug', `Adding ${entryPointsOrPackages.length} packages.`);
+        const entryPoints = _.flatten(entryPointsOrPackages);
+        const existingEntryPoints = Object.values(addedShells).map(shell => shell.entryPoint);
+        const allEntryPoints = existingEntryPoints.concat(unReadyEntryPointsStore.get(), entryPoints);
+        if (!options.disableLayersValidation) {
+            validateLayers(entryPoints);
+        }
+        validateUniqueShellNames(entryPoints);
+        !options.disableCheckCircularDependencies && !options.experimentalCyclicMode && validateCircularDependency(allEntryPoints);
+        const [lazyEntryPointsList, readyEntryPointsList] = _.partition(entryPoints, isLazyEntryPointDescriptor);
+        executeInstallShell(readyEntryPointsList);
+        lazyEntryPointsList.forEach(registerLazyEntryPoint);
+        setInstalledShellNames(getInstalledShellNames().concat(_.map(lazyEntryPointsList, 'name')));
+        return Promise.resolve();
+    }
+    function isAllAPIDependenciesAreReadyOrPending(checkedKey, pendingEntryPoints, passed = []) {
+        // TODO: Avoid iterating N (cycle length) times for the same cycle
+        const declarers = pendingEntryPoints.flatMap(ep => { var _a; return (((_a = ep.declareAPIs) === null || _a === void 0 ? void 0 : _a.call(ep)) || []).map(k => [k, ep]); });
+        const [, keyDeclarerEntryPoint] = declarers.find(([k, ep]) => _.isEqual(k, checkedKey)) || [];
+        if (!keyDeclarerEntryPoint) {
+            return false;
+        }
+        const dependencies = keyDeclarerEntryPoint.getDependencyAPIs && keyDeclarerEntryPoint.getDependencyAPIs();
+        const uncheckDependencies = _.differenceWith(dependencies, passed, _.isEqual);
+        const everyDependenciesReadyOrPending = _.every(uncheckDependencies, k => readyAPIs.has(getOwnSlotKey(k)) || isAllAPIDependenciesAreReadyOrPending(k, pendingEntryPoints, passed.concat(checkedKey)));
+        return everyDependenciesReadyOrPending;
+    }
+    function onInstallShellsEnd() {
+        const callbacks = entryPointsInstallationEndCallbacks.values();
+        try {
+            for (const callback of callbacks) {
+                callback();
+            }
+        }
+        finally {
+            entryPointsInstallationEndCallbacks.clear();
+        }
+    }
+    function executeInstallShell(entryPoints) {
+        const [readyEntryPoints, currentUnReadyEntryPoints] = _.partition(entryPoints, entryPoint => {
+            const dependencies = entryPoint.getDependencyAPIs && entryPoint.getDependencyAPIs();
+            return _.every(dependencies, k => readyAPIs.has(getOwnSlotKey(k)) ||
+                (options.experimentalCyclicMode && isAllAPIDependenciesAreReadyOrPending(k, entryPoints)));
+        });
+        unReadyEntryPointsStore.set(_.union(_.difference(unReadyEntryPointsStore.get(), readyEntryPoints), currentUnReadyEntryPoints));
+        if (store && _.isEmpty(readyEntryPoints)) {
+            onInstallShellsEnd();
+            return;
+        }
+        const shells = readyEntryPoints.map(createShell);
+        executeReadyEntryPoints(shells);
+    }
+    function executeReadyEntryPoints(shells) {
+        batchDeclarationsChangedCallbacks(() => {
+            isInstallingEntryPoints = true;
+            try {
+                invokeEntryPointPhase('getDependencyAPIs', shells, f => f.entryPoint.getDependencyAPIs && f.setDependencyAPIs(f.entryPoint.getDependencyAPIs()), f => !!f.entryPoint.getDependencyAPIs);
+                invokeEntryPointPhase('attach', shells, f => f.entryPoint.attach && f.entryPoint.attach(f), f => !!f.entryPoint.attach);
+                buildStore();
+                shells.forEach(f => f.setLifecycleState(true, true, false));
+                invokeEntryPointPhase('extend', shells, f => f.entryPoint.extend && f.entryPoint.extend(f), f => !!f.entryPoint.extend);
+                shells.forEach(f => {
+                    addedShells.set(f.entryPoint.name, f);
+                    f.setLifecycleState(true, true, true);
+                });
+            }
+            finally {
+                isInstallingEntryPoints = false;
+            }
+            executeInstallShell(unReadyEntryPointsStore.get());
+        });
+    }
+    function executeShellsChangedCallbacks() {
+        shellsChangedCallbacks.forEach(f => f(_.keys(InstalledShellsSelectors.getInstalledShellsSet(getStore().getState()))));
+    }
+    function executeDeclarationsChangedCallbacks() {
+        declarationsChangedCallbacks.forEach(f => f());
+    }
+    function batchDeclarationsChangedCallbacks(action) {
+        if (isBatchingDeclarationsChangedCallbacks) {
+            return action();
+        }
+        try {
+            isBatchingDeclarationsChangedCallbacks = true;
+            const result = action();
+            executeDeclarationsChangedCallbacks();
+            return result;
+        }
+        finally {
+            isBatchingDeclarationsChangedCallbacks = false;
+        }
+    }
+    function setInstalledShellNames(names) {
+        const updates = toShellToggleSet(names, true);
+        getStore().dispatch(InstalledShellsActions.updateInstalledShells(updates));
+        executeShellsChangedCallbacks();
+    }
+    function setUninstalledShellNames(names) {
+        const updates = toShellToggleSet(names, false);
+        getStore().dispatch(InstalledShellsActions.updateInstalledShells(updates));
+        executeShellsChangedCallbacks();
+    }
+    function onDeclarationsChanged(callback) {
+        const callbackId = _.uniqueId('declarations-changed-callback-');
+        declarationsChangedCallbacks.set(callbackId, callback);
+        return () => {
+            declarationsChangedCallbacks.delete(callbackId);
+        };
+    }
+    function onShellsChanged(callback) {
+        const callbackId = _.uniqueId('shells-changed-callback-');
+        shellsChangedCallbacks.set(callbackId, callback);
+        return callbackId;
+    }
+    function removeShellsChangedCallback(callbackId) {
+        shellsChangedCallbacks.delete(callbackId);
+    }
+    function declareSlot(key, declaringShell) {
+        const newSlot = registerSlotOrThrow(key, () => createExtensionSlot(key, host, declaringShell));
+        return newSlot;
+    }
+    function declareCustomSlot(key, handler, declaringShell) {
+        const newSlot = registerSlotOrThrow(key, () => createCustomExtensionSlot(key, handler, host, declaringShell));
+        return newSlot;
+    }
+    function slotKeyToName(key) {
+        return key.version === undefined ? key.name : `${key.name}(v${key.version})`;
+    }
+    function registerSlotOrThrow(key, factory) {
+        const slotName = slotKeyToName(key);
+        if (!extensionSlots.has(key) && !slotKeysByName.has(slotName)) {
+            const newSlot = factory();
+            extensionSlots.set(key, newSlot);
+            slotKeysByName.set(slotName, key);
+            return newSlot;
+        }
+        throw new Error(`Extension slot with key '${slotName}' already exists.`);
+    }
+    function getSlot(key) {
+        const ownKey = getOwnSlotKey(key);
+        const anySlot = extensionSlots.get(ownKey);
+        if (anySlot) {
+            return anySlot;
+        }
+        throw new Error(`Extension slot with key '${slotKeyToName(key)}' doesn't exist.`);
+    }
+    function hasSlot(key) {
+        const ownKey = getOwnSlotKey(key);
+        return extensionSlots.has(ownKey);
+    }
+    function tryGetAPI(key) {
+        if (!hasSlot(key)) {
+            return;
+        }
+        const APISlot = getSlot(key);
+        const item = APISlot.getSingleItem();
+        return item === null || item === void 0 ? void 0 : item.contribution;
+    }
+    function getAPI(key) {
+        const api = tryGetAPI(key);
+        if (!api) {
+            throw new Error(`API '${slotKeyToName(key)}' doesn't exist.`);
+        }
+        return api;
+    }
+    function hasAPI(key) {
+        return !!tryGetAPI(key);
+    }
+    function executeWhenFree(key, callback) {
+        if (isInstallingEntryPoints) {
+            entryPointsInstallationEndCallbacks.set(key, callback);
+        }
+        else {
+            callback();
+        }
+    }
+    function getStore() {
+        if (store) {
+            return store;
+        }
+        throw new Error('Store was not yet created');
+    }
+    function getAllSlotKeys() {
+        return Array.from(extensionSlots.keys());
+    }
+    function getAllEntryPoints() {
+        throw new Error('not implemented');
+    }
+    function hasShell(name) {
+        const installedShellsSet = InstalledShellsSelectors.getInstalledShellsSet(getStore().getState());
+        return installedShellsSet[name] === true;
+    }
+    function isLazyEntryPoint(name) {
+        return lazyShells.has(name);
+    }
+    function registerLazyEntryPoint(descriptor) {
+        lazyShells.set(descriptor.name, descriptor.factory);
+    }
+    function getOwnSlotKey(key) {
+        if (key.public === true) {
+            const ownKey = slotKeysByName.get(slotKeyToName(key));
+            if (ownKey && ownKey.public) {
+                return ownKey;
+            }
+        }
+        return key;
+    }
+    function validateUniqueShellNames(entryPoints) {
+        entryPoints.forEach(f => validateUniqueShellName(f.name));
+    }
+    function validateUniqueShellName(name) {
+        if (!uniqueShellNames.has(name)) {
+            uniqueShellNames.add(name);
+        }
+        else {
+            throw new Error(`Shell named '${name}' already exists`);
+        }
+    }
+    function validateCircularDependency(entryPoints) {
+        const allDeclaredAPIs = new Map();
+        for (const ep of entryPoints) {
+            const apis = declaredAPIs(ep);
+            for (const api of apis) {
+                const existingDeclaration = allDeclaredAPIs.get(api.name);
+                if (existingDeclaration) {
+                    host.log.log('warning', `The API: ${api.name} is declared in multiple endpoints: ${existingDeclaration.name} and ${ep.name}`);
+                }
+                else {
+                    allDeclaredAPIs.set(api.name, ep);
+                }
+            }
+        }
+        const graph = new Graph();
+        entryPoints.forEach(ep => {
+            const declaredApis = declaredAPIs(ep).map(x => slotKeyToName(x));
+            const dependencies = dependentAPIs(ep).map(x => slotKeyToName(x));
+            declaredApis.forEach(d => dependencies.forEach(y => graph.addConnection(d, y)));
+        });
+        const tarjan = new Tarjan(graph);
+        const sccs = tarjan.run();
+        for (const scc of sccs) {
+            if (scc.length > 1) {
+                const dependentGraph = {};
+                entryPoints.forEach(ep => {
+                    const declaredApis = declaredAPIs(ep).map(child => child.name);
+                    const dependencies = dependentAPIs(ep).map(child => child.name);
+                    declaredApis.forEach(d => {
+                        dependentGraph[d] = dependencies;
+                    });
+                });
+                const circle = getCycle(dependentGraph);
+                if (circle) {
+                    const reversedCircle = circle.reverse();
+                    host.log.log('error', `Circular API dependency found: ${reversedCircle.join(' -> ')}`);
+                    throw new Error(`Circular API dependency found`);
+                }
+            }
+        }
+    }
+    function buildStore() {
+        const contributedState = getSlot(stateSlotKey);
+        if (store) {
+            updateThrottledStore(host, store, contributedState);
+        }
+        else {
+            store = createThrottledStore(host, contributedState, notifySubscribersIsRunning => {
+                isStoreSubscribersNotifyInProgress = notifySubscribersIsRunning;
+            }, notifyObserversIsRunning => {
+                isObserversNotifyInProgress = notifyObserversIsRunning;
+            }, updateShouldFlushMemoizationSync => {
+                shouldFlushMemoizationSync = updateShouldFlushMemoizationSync;
+            });
+            store.subscribe(() => {
+                if (shouldFlushMemoization) {
+                    shouldFlushMemoization = false;
+                    flushMemoizedForState();
+                }
+            });
+            store.syncSubscribe(() => {
+                shouldFlushMemoization = true;
+                if (isStoreSubscribersNotifyInProgress || isObserversNotifyInProgress || shouldFlushMemoizationSync) {
+                    shouldFlushMemoization = false;
+                    flushMemoizedForState();
+                }
+            });
+        }
+        return store;
+    }
+    function flushMemoizedForState() {
+        memoizedFunctions.forEach(({ f, shouldClear }) => {
+            if ((shouldClear || _.stubTrue)()) {
+                clearCache(f);
+            }
+        });
+    }
+    function clearCache(memoizedFunction) {
+        if (memoizedFunction.cache && memoizedFunction.cache.clear) {
+            memoizedFunction.cache.clear();
+        }
+    }
+    function invokeEntryPointPhase(phase, // TODO: Exclude 'name'
+    shell, action, predicate) {
+        host.log.log('debug', `--- ${phase} phase ---`);
+        try {
+            shell.filter(f => !predicate || predicate(f)).forEach(f => invokeShell(f, action, phase));
+        }
+        catch (err) {
+            console.error(`${phase} phase FAILED`, err);
+            throw err;
+        }
+        host.log.log('debug', `--- End of ${phase} phase ---`);
+    }
+    function invokeShell(shell, action, phase) {
+        host.log.log('debug', `${phase} : ${shell.entryPoint.name}`);
+        try {
+            action(shell);
+        }
+        catch (err) {
+            host.log.log('error', 'AppHost.shellFailed', err, {
+                shell: shell.name,
+                phase,
+                message: `Shell '${shell.name}' FAILED ${phase} phase`,
+                error: err
+            });
+            throw err;
+        }
+    }
+    function getAPIContributor(key) {
+        const ownKey = getOwnSlotKey(key);
+        return extensionSlots.has(ownKey) ? _.get(getSlot(ownKey).getSingleItem(), 'shell') : undefined;
+    }
+    function doesExtensionItemBelongToShells(extensionItem, shellNames) {
+        return (_.includes(shellNames, extensionItem.shell.name) ||
+            _.some(_.invoke(extensionItem.shell.entryPoint, 'getDependencyAPIs'), APIKey => _.includes(shellNames, _.get(getAPIContributor(APIKey), 'name'))));
+    }
+    function discardSlotKey(key) {
+        const ownKey = getOwnSlotKey(key);
+        readyAPIs.delete(ownKey);
+        extensionSlots.delete(ownKey);
+        slotKeysByName.delete(slotKeyToName(ownKey));
+        host.log.log('debug', `-- Removed slot keys: ${slotKeyToName(ownKey)} --`);
+    }
+    function findDependantShells(entryShell) {
+        const cache = new Map();
+        const _findDependantShells = (declaringShell) => _([...addedShells.entries()])
+            .flatMap(([name, shell]) => {
+            var _a, _b;
+            const cachedValue = cache.get(name);
+            if (cachedValue) {
+                return cachedValue;
+            }
+            const dependencyAPIs = ((_b = (_a = shell.entryPoint) === null || _a === void 0 ? void 0 : _a.getDependencyAPIs) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
+            const isDependant = dependencyAPIs.some(key => { var _a; return ((_a = getAPIContributor(key)) === null || _a === void 0 ? void 0 : _a.name) === declaringShell.name; });
+            if (!isDependant) {
+                return [];
+            }
+            const dependencies = [shell, ..._findDependantShells(shell)];
+            cache.set(name, dependencies);
+            return dependencies;
+        })
+            .uniqBy('name')
+            .value();
+        return _findDependantShells(entryShell);
+    }
+    function isShellBeingDependantOnInGroup(declaringShell, shells) {
+        return !!shells.find(dependantShell => {
+            var _a, _b;
+            const dependencyAPIs = ((_b = (_a = dependantShell.entryPoint) === null || _a === void 0 ? void 0 : _a.getDependencyAPIs) === null || _b === void 0 ? void 0 : _b.call(_a)) || [];
+            return dependencyAPIs.find(key => { var _a; return ((_a = getAPIContributor(key)) === null || _a === void 0 ? void 0 : _a.name) === declaringShell.name; });
+        });
+    }
+    function executeDetachOnShellReadyForRemoval(shellsToBeDetached, originalRequestedRemovalNames) {
+        invokeEntryPointPhase('detach', shellsToBeDetached, f => _.invoke(f.entryPoint, 'detach', f));
+        const detachedShellsNames = shellsToBeDetached.map(({ name }) => name);
+        const slotKeysToDiscard = findContributedAPIs(detachedShellsNames).concat(findDeclaredSlotKeys(detachedShellsNames));
+        extensionSlots.forEach(extensionSlot => extensionSlot.discardBy(extensionItem => doesExtensionItemBelongToShells(extensionItem, detachedShellsNames)));
+        detachedShellsNames.forEach(name => {
+            var _a;
+            const isResultOfMissingDependency = !originalRequestedRemovalNames.includes(name);
+            if (isResultOfMissingDependency) {
+                const entryPoint = (_a = addedShells.get(name)) === null || _a === void 0 ? void 0 : _a.entryPoint;
+                entryPoint && unReadyEntryPointsStore.get().push(entryPoint);
+            }
+            addedShells.delete(name);
+            uniqueShellNames.delete(name);
+        });
+        slotKeysToDiscard.forEach(discardSlotKey);
+        host.log.log('debug', `Done uninstalling ${detachedShellsNames}`);
+    }
+    function executeUninstallShells(names) {
+        batchDeclarationsChangedCallbacks(() => {
+            host.log.log('debug', `-- Uninstalling ${names} --`);
+            const shellsCandidatesToBeDetached = _(names)
+                .map(name => addedShells.get(name))
+                .compact()
+                .flatMap(shell => [shell, ...findDependantShells(shell)])
+                .uniqBy('name')
+                .value();
+            let queue = shellsCandidatesToBeDetached;
+            while (!_.isEmpty(queue)) {
+                const shellsToBeDetached = queue.filter(ep => !isShellBeingDependantOnInGroup(ep, queue));
+                if (_.isEmpty(shellsToBeDetached)) {
+                    throw new Error(`Some shells could not detach: ${queue.map(({ name }) => name).join()}`);
+                }
+                executeDetachOnShellReadyForRemoval(shellsToBeDetached, names);
+                queue = _.differenceBy(queue, shellsToBeDetached, 'name');
+            }
+        });
+    }
+    function findContributedAPIs(shellNames) {
+        return [...readyAPIs].filter(APIKey => _.includes(shellNames, _.get(getAPIContributor(APIKey), 'name')));
+    }
+    function findDeclaredSlotKeys(shellNames) {
+        const shellNameSet = new Set(shellNames);
+        const result = [];
+        for (const entry of extensionSlots.entries()) {
+            const { declaringShell } = entry[1];
+            if (declaringShell && shellNameSet.has(declaringShell.name)) {
+                result.push(entry[0]);
+            }
+        }
+        return result;
+    }
+    function getInstalledShellNames() {
+        return [...addedShells].map(([v]) => v);
+    }
+    function removeShells(names) {
+        const shellNames = getInstalledShellNames();
+        executeUninstallShells(names);
+        setUninstalledShellNames(_.difference(shellNames, getInstalledShellNames()));
+        return Promise.resolve();
+    }
+    function createShell(entryPoint) {
+        let storeEnabled = false;
+        let APIsEnabled = false;
+        let wasInitCompleted = false;
+        let dependencyAPIs = new Set();
+        let nextObservableId = 1;
+        const boundaryAspects = [];
+        function isOwnContributedAPI(key) {
+            return getAPIContributor(key) === shell;
+        }
+        const shell = {
+            name: entryPoint.name,
+            entryPoint,
+            getSlot(key) {
+                const slot = host.getSlot(key);
+                const { declaringShell } = slot;
+                if (!declaringShell || declaringShell !== shell) {
+                    throw new Error(`Shell '${shell.name}' is trying to get slot '${slotKeyToName(key)}' that is owned by '${declaringShell ? declaringShell.name : 'Host'}'`);
+                }
+                return slot;
+            },
+            hasSlot(key) {
+                if (hasSlot(key)) {
+                    const slot = host.getSlot(key);
+                    const { declaringShell } = slot;
+                    return !!declaringShell && declaringShell === shell;
+                }
+                return false;
+            },
+            getAllSlotKeys: host.getAllSlotKeys,
+            getAllEntryPoints: host.getAllEntryPoints,
+            hasShell: host.hasShell,
+            isLazyEntryPoint: host.isLazyEntryPoint,
+            onShellsChanged: host.onShellsChanged,
+            onDeclarationsChanged: host.onDeclarationsChanged,
+            removeShellsChangedCallback: host.removeShellsChangedCallback,
+            declareSlot(key) {
+                return declareSlot(key, shell);
+            },
+            declareCustomSlot(key, handler) {
+                return declareCustomSlot(key, handler, shell);
+            },
+            setLifecycleState(enableStore, enableAPIs, initCompleted) {
+                storeEnabled = enableStore;
+                APIsEnabled = enableAPIs;
+                wasInitCompleted = initCompleted;
+            },
+            setDependencyAPIs(APIs) {
+                dependencyAPIs = new Set(APIs);
+            },
+            canUseAPIs() {
+                return APIsEnabled;
+            },
+            canUseStore() {
+                return storeEnabled;
+            },
+            wasInitializationCompleted() {
+                return wasInitCompleted;
+            },
+            runLateInitializer(initializer) {
+                const saveWasInitCompleted = wasInitCompleted;
+                try {
+                    wasInitCompleted = false;
+                    return initializer();
+                }
+                finally {
+                    wasInitCompleted = saveWasInitCompleted;
+                }
+            },
+            addShells(entryPointsOrPackages) {
+                const shellNamesToBeinstalled = _.flatten(entryPointsOrPackages).map(x => x.name);
+                const shellNamesInstalledByCurrentEntryPoint = shellInstallers.get(shell) || [];
+                shellInstallers.set(shell, [...shellNamesInstalledByCurrentEntryPoint, ...shellNamesToBeinstalled]);
+                return host.addShells(entryPointsOrPackages);
+            },
+            removeShells(names) {
+                const namesInstalledByCurrentEntryPoint = shellInstallers.get(shell) || [];
+                const namesNotInstalledByCurrentEntryPoint = _.difference(names, namesInstalledByCurrentEntryPoint);
+                // TODO: Allow entry point to uninstall its own shell ?
+                if (!_.isEmpty(namesNotInstalledByCurrentEntryPoint)) {
+                    throw new Error(`Shell ${entryPoint.name} is trying to uninstall shells: ${names} which is are not installed by entry point ${entryPoint.name} - This is not allowed`);
+                }
+                shellInstallers.set(shell, _.without(namesInstalledByCurrentEntryPoint, ...names));
+                return host.removeShells(names);
+            },
+            getAPI(key) {
+                if (dependencyAPIs.has(key) || isOwnContributedAPI(key)) {
+                    return host.getAPI(key);
+                }
+                throw new Error(`API '${slotKeyToName(key)}' is not declared as dependency by entry point '${entryPoint.name}' (forgot to return it from getDependencyAPIs?)`);
+            },
+            hasAPI(key) {
+                return (dependencyAPIs.has(key) || isOwnContributedAPI(key)) && host.hasAPI(key);
+            },
+            contributeAPI(key, factory, apiOptions) {
+                host.log.log('debug', `Contributing API ${slotKeyToName(key)}.`);
+                if (!_.includes(_.invoke(entryPoint, 'declareAPIs') || [], key)) {
+                    throw new Error(`Entry point '${entryPoint.name}' is trying to contribute API '${slotKeyToName(key)}' which it didn't declare`);
+                }
+                const areSameLayers = (l1, l2) => _.isEqual(_(l1).castArray().sort().value(), _(l2).castArray().sort().value());
+                if (!options.disableLayersValidation && (entryPoint.layer || key.layer) && !areSameLayers(entryPoint.layer, key.layer)) {
+                    throw new Error(`Cannot contribute API ${slotKeyToName(key)} of layer ${key.layer || '<BLANK>'} from entry point ${entryPoint.name} of layer ${entryPoint.layer || '<BLANK>'}`);
+                }
+                const api = factory();
+                const monitoredAPI = monitorAPI(shell, options, normalizeApiName(slotKeyToName(key)), api /*, trace, memoizedArr*/, apiOptions);
+                const apiSlot = declareSlot(key);
+                APILayers.set(key, !options.disableLayersValidation && entryPoint.layer
+                    ? _(entryPoint.layer)
+                        .castArray()
+                        .map(l => getLayerByName(l))
+                        .value()
+                    : undefined);
+                apiSlot.contribute(shell, monitoredAPI);
+                readyAPIs.add(key);
+                if (!isInstallingEntryPoints) {
+                    const shellNames = _.map(unReadyEntryPointsStore.get(), 'name');
+                    executeInstallShell(unReadyEntryPointsStore.get());
+                    setInstalledShellNames(_.difference(shellNames, _.map(unReadyEntryPointsStore.get(), 'name')));
+                }
+                return monitoredAPI;
+            },
+            contributeState(contributor) {
+                const contribution = {
+                    notificationScope: 'broadcasting',
+                    reducerFactory: contributor
+                };
+                getSlot(stateSlotKey).contribute(shell, contribution);
+            },
+            contributeObservableState(contributor, mapStateToSelectors) {
+                const observableUniqueName = `${entryPoint.name}/observable_${nextObservableId++}`;
+                const observable = createObservable(shell, observableUniqueName, mapStateToSelectors);
+                observable.subscribe(shell, () => {
+                    flushMemoizedForState();
+                });
+                const protectedObservable = {
+                    subscribe: observable.subscribe,
+                    current: (allowUnsafeReading) => {
+                        if (isStoreSubscribersNotifyInProgress && !allowUnsafeReading) {
+                            throw new Error(`Observer created by ${shell.name} current() function: ` +
+                                'Should not read observable value during subscribers notify. ' +
+                                'If you wish to read the value, you component should be observing the value directly ' +
+                                '(using observeWithShell or connectWithShellAndObserve)');
+                        }
+                        return observable.current();
+                    },
+                    notify: observable.notify
+                };
+                const contribution = {
+                    notificationScope: 'observable',
+                    reducerFactory: contributor,
+                    observable
+                };
+                getSlot(stateSlotKey).contribute(shell, contribution);
+                return protectedObservable;
+            },
+            getStore() {
+                return {
+                    dispatch: host.getStore().dispatchWithShell(shell),
+                    subscribe: host.getStore().subscribe,
+                    getState: () => {
+                        const entireStoreState = host.getStore().getState();
+                        return entireStoreState[shell.name];
+                    },
+                    flush: host.getStore().flush,
+                    hasPendingSubscribers: host.getStore().hasPendingSubscribers,
+                    deferSubscriberNotifications: host.getStore().deferSubscriberNotifications
+                };
+            },
+            contributeMainView(fromShell, contributor) {
+                getSlot(mainViewSlotKey).contribute(fromShell, contributor);
+            },
+            contributeBoundaryAspect(component) {
+                boundaryAspects.push(component);
+            },
+            memoizeForState(func, resolver, shouldClear) {
+                const memoized = memoize(func, resolver);
+                memoizedFunctions.set(memoized, shouldClear ? { f: memoized, shouldClear } : { f: memoized });
+                return memoized;
+            },
+            flushMemoizedForState,
+            memoize(func, resolver) {
+                return memoize(func, resolver);
+            },
+            clearCache,
+            getBoundaryAspects() {
+                return boundaryAspects;
+            },
+            getHostOptions: () => host.options,
+            log: createShellLogger(host, entryPoint),
+            [INTERNAL_DONT_USE_SHELL_GET_APP_HOST]: () => host,
+            lazyEvaluator
+        };
+        return shell;
+    }
+    function normalizeApiName(name) {
+        return name.charAt(0).toLowerCase() + name.substring(1).replace(new RegExp(' ', 'g'), '');
+    }
+}
+//# sourceMappingURL=appHost.js.map