repluggable-core 1.302.65 → 1.302.67

package/src/repluggableAppDebug/repluggableAppDebug.ts

@@ -0,0 +1,192 @@
+import { getPerformanceDebug } from './performanceDebugInfo'
+import { AnySlotKey, AppHost, EntryPoint, LazyEntryPointFactory, PrivateShell, SlotKey, StatisticsMemoization, Trace } from '../API'
+import _ from 'lodash'
+import { hot } from '../hot'
+import { AppHostServicesProvider } from '../appHostServices'
+import { AnyExtensionSlot } from '../extensionSlot'
+
+interface PerformanceDebugParams {
+    options: AppHost['options']
+    trace: Trace[]
+    memoizedArr: StatisticsMemoization[]
+}
+
+interface SetupDebugInfoParams {
+    readyAPIs: Set<AnySlotKey>
+    host: AppHost & AppHostServicesProvider
+    uniqueShellNames: Set<string>
+    extensionSlots: Map<AnySlotKey, AnyExtensionSlot>
+    addedShells: Map<string, PrivateShell>
+    shellInstallers: WeakMap<PrivateShell, string[]>
+    lazyShells: Map<string, LazyEntryPointFactory>
+
+    performance: PerformanceDebugParams
+
+    getUnreadyEntryPoints(): EntryPoint[]
+    getOwnSlotKey(key: SlotKey<any>): SlotKey<any>
+    getAPI: AppHost['getAPI']
+}
+
+function mapApiToEntryPoint(allPackages: EntryPoint[]) {
+    const apiToEntryPoint = new Map<string, EntryPoint | undefined>()
+    _.forEach(allPackages, (entryPoint: EntryPoint) => {
+        _.forEach(entryPoint.declareAPIs ? entryPoint.declareAPIs() : [], dependency => {
+            apiToEntryPoint.set(dependency.name, entryPoint)
+        })
+    })
+    return apiToEntryPoint
+}
+
+/**
+ * a function that returns all the entry points in the system with their declared APIs and dependencies
+ */
+const getAllEntryPoints = () => {
+    return [
+        ...globalThis.repluggableAppDebug.utils.unReadyEntryPoints(),
+        ...[...globalThis.repluggableAppDebug.addedShells].map(([_, shell]) => shell.entryPoint)
+    ]
+}
+
+/**
+ * this function is used to get the root unready API in case there are too many to understand.
+ * for example if you have 200 unready entry points, running this function will give you the first unready API that
+ * will unblock the rest of the entry point (note that there might be more than one)
+ *
+ * this function basically takes the first unready entry point, get its dependencies and iterates over them to find an API that is not ready
+ * at this point it follows the same process recursively until it reaced the target API.
+ */
+const getRootUnreadyAPI = (host: AppHost) => {
+    return () => {
+        // get all unready entry points
+        const allEntryPoints = getAllEntryPoints()
+        const unReadyAPIsArray = []
+        // get the depdenencies of the first unready entry point
+        let dependenciesOfUnreadyEntryPoint = allEntryPoints?.[0]?.getDependencyAPIs?.()
+
+        while (dependenciesOfUnreadyEntryPoint?.length) {
+            const currentAPI = dependenciesOfUnreadyEntryPoint.pop()
+
+            if (!currentAPI) {
+                continue
+            }
+            // try to get the API from this host, we are looking for an API that is not ready
+            try {
+                const api = host.getAPI(currentAPI as SlotKey<any>)
+                if (api) {
+                    continue
+                }
+            } catch (e) {
+                unReadyAPIsArray.push(currentAPI)
+                // we found an API that is unready, lets find which entry point declares it
+                const declarer = allEntryPoints.find(entryPointData =>
+                    entryPointData.declareAPIs?.().some(api => currentAPI?.name === api.name)
+                )
+                dependenciesOfUnreadyEntryPoint = declarer?.getDependencyAPIs?.()
+            }
+        }
+        return unReadyAPIsArray.reverse()
+    }
+}
+
+const getAPIOrEntryPointsDependencies = (
+    apisOrEntryPointsNames: string[],
+    entryPoints: EntryPoint[]
+): { entryPoints: EntryPoint[]; apis: AnySlotKey[] } => {
+    const apiToEntryPoint = mapApiToEntryPoint(entryPoints)
+
+    const loadedEntryPoints = new Set<string>()
+    const packagesList: EntryPoint[] = []
+    const allDependencies = new Set<AnySlotKey>()
+    const apisOrEntryPointsSet = new Set(apisOrEntryPointsNames)
+    const entryPointsQueue: EntryPoint[] = entryPoints.filter(x => apisOrEntryPointsSet.has(x.name))
+
+    apisOrEntryPointsNames.forEach(x => {
+        const ep = apiToEntryPoint.get(x)
+        ep && entryPointsQueue.push(ep)
+    })
+
+    while (entryPointsQueue.length) {
+        const currEntryPoint = entryPointsQueue.shift()
+        if (!currEntryPoint || loadedEntryPoints.has(currEntryPoint.name)) {
+            continue
+        }
+        loadedEntryPoints.add(currEntryPoint.name)
+        packagesList.push(currEntryPoint)
+        const dependencies = currEntryPoint.getDependencyAPIs ? currEntryPoint.getDependencyAPIs() : []
+        dependencies.forEach(x => allDependencies.add(x))
+        const dependencyEntryPoints = dependencies.map((API: AnySlotKey) => apiToEntryPoint.get(API.name))
+        entryPointsQueue.push(..._.compact(dependencyEntryPoints))
+    }
+
+    return {
+        entryPoints: packagesList,
+        apis: [...allDependencies]
+    }
+}
+
+export function setupDebugInfo({
+    host,
+    uniqueShellNames,
+    readyAPIs,
+    getAPI,
+    getOwnSlotKey,
+    getUnreadyEntryPoints,
+    extensionSlots,
+    addedShells,
+    lazyShells,
+    shellInstallers,
+    performance: { options, trace, memoizedArr }
+}: SetupDebugInfoParams) {
+    const utils = {
+        apis: () => {
+            return Array.from(readyAPIs).map((apiKey: AnySlotKey) => {
+                return {
+                    key: apiKey,
+                    impl: () => getAPI(apiKey)
+                }
+            })
+        },
+        getRootUnreadyAPI: getRootUnreadyAPI(host),
+        unReadyEntryPoints: (): EntryPoint[] => getUnreadyEntryPoints(),
+        whyEntryPointUnready: (name: string) => {
+            const unreadyEntryPoint = _.find(
+                utils.unReadyEntryPoints(),
+                (entryPoint: EntryPoint) => entryPoint.name.toLowerCase() === name.toLowerCase()
+            )
+
+            const dependencies = _.invoke(unreadyEntryPoint, 'getDependencyAPIs')
+
+            const unreadyDependencies = _.filter(dependencies, key => !readyAPIs.has(getOwnSlotKey(key)))
+            if (!_.isEmpty(unreadyDependencies)) {
+                const unreadyDependenciesNames = _(unreadyDependencies).map('name').join(',')
+                console.log(`There are unready dependencies for ${name}: ${unreadyDependenciesNames}`)
+            }
+        },
+        findAPI: (name: string) => {
+            return _.filter(utils.apis(), (api: any) => api.key.name.toLowerCase().indexOf(name.toLowerCase()) !== -1)
+        },
+        getAPIOrEntryPointsDependencies: (
+            apisOrEntryPointsNames: string[],
+            entryPoints = [...addedShells.values()].map(x => x.entryPoint)
+        ) => getAPIOrEntryPointsDependencies(apisOrEntryPointsNames, entryPoints),
+        performance: getPerformanceDebug(options, trace, memoizedArr)
+    }
+
+    if (typeof globalThis === 'undefined') {
+        return
+    }
+
+    globalThis.repluggableAppDebug = {
+        host,
+        uniqueShellNames,
+        extensionSlots,
+        addedShells,
+        lazyShells,
+        readyAPIs,
+        shellInstallers,
+        utils,
+        hmr: {
+            hot
+        }
+    }
+}

package/src/tarjanGraph.ts

@@ -0,0 +1,96 @@
+/*
+    Based on:
+    https://en.wikipedia.org/wiki/Tarjan%27s_strongly_connected_components_algorithm
+    https://gist.github.com/chadhutchins/1440602
+*/
+
+export class Graph {
+    private readonly map = new Map<string, Vertex>()
+    private addOrGetVertex(value: string) {
+        let vertex = this.map.get(value)
+        if (!vertex) {
+            vertex = new Vertex(value)
+            this.map.set(value, vertex)
+        }
+        return vertex
+    }
+
+    getVertices() {
+        return this.map.values()
+    }
+
+    addConnection(source: string, target: string) {
+        this.addOrGetVertex(source).connections.push(this.addOrGetVertex(target))
+    }
+}
+
+class Vertex {
+    connections: Vertex[] = []
+    index = -1
+    lowLink = -1
+    constructor(public name: string) {}
+}
+
+export function getCycle(dependentGraph: { [key: string]: string[] }) {
+    let queue = Object.keys(dependentGraph).map(node => [node])
+    while (queue.length) {
+        const batch = []
+        for (const path of queue) {
+            const parents = dependentGraph[path[0]] || []
+            for (const node of parents) {
+                if (node === path[path.length - 1]) {
+                    return [node, ...path]
+                }
+                batch.push([node, ...path])
+            }
+        }
+        queue = batch
+    }
+}
+
+export class Tarjan {
+    private index = 0
+    private readonly stack: Vertex[] = []
+    private readonly scc: Vertex[][] = []
+    constructor(private readonly graph: Graph) {}
+
+    run() {
+        for (const v of this.graph.getVertices()) {
+            if (v.index < 0) {
+                this.strongConnect(v)
+            }
+        }
+        return this.scc
+    }
+
+    private strongConnect(vertex: Vertex) {
+        vertex.index = this.index
+        vertex.lowLink = this.index
+        this.index = this.index + 1
+        this.stack.push(vertex)
+
+        for (const w of vertex.connections) {
+            const v = vertex
+            if (w.index < 0) {
+                this.strongConnect(w)
+                v.lowLink = Math.min(v.lowLink, w.lowLink)
+            } else if (this.stack.some(x => x.name === w.name)) {
+                v.lowLink = Math.min(v.lowLink, w.index)
+            }
+        }
+
+        if (vertex.lowLink === vertex.index) {
+            const vertices = []
+            let w = null
+            if (this.stack.length > 0) {
+                do {
+                    w = this.stack.pop()
+                    w && vertices.push(w)
+                } while (vertex.name !== w?.name)
+            }
+            if (vertices.length > 0) {
+                this.scc.push(vertices)
+            }
+        }
+    }
+}

package/src/throttledStore.ts

@@ -0,0 +1,355 @@
+import _ from 'lodash'
+import { Action, AnyAction, Dispatch, Reducer, ReducersMapObject, Store, Unsubscribe, combineReducers, createStore } from 'redux'
+import { devToolsEnhancer } from 'redux-devtools-extension'
+import { AppHost, ExtensionSlot, ObservableState, ReducersMapObjectContributor, Shell, SlotKey, StateObserver } from './API'
+import { AppHostServicesProvider } from './appHostServices'
+import { contributeInstalledShellsState } from './installedShellsState'
+import { interceptAnyObject } from './interceptAnyObject'
+import { invokeSlotCallbacks } from './invokeSlotCallbacks'
+
+type ReducerNotificationScope = 'broadcasting' | 'observable'
+interface ShellsReducersMap {
+    [shellName: string]: ReducersMapObject
+}
+
+interface AnyShellAction extends AnyAction {
+    __shellName?: string
+}
+
+
+function createTimeOutPublisher ( notify: () => void)  {
+    let id : undefined | NodeJS.Timeout =  undefined 
+    return () => {
+        if (id === undefined) {
+            id = setTimeout(() => {
+                id = undefined
+                notify()
+            },0)
+        }
+        return () => {
+            if(id === undefined) {
+                return
+            }
+            clearTimeout(id)
+            id = undefined
+        }
+    }
+}
+
+function createAnimationFramePublisher ( notify: () => void)  {
+    let id : undefined | number =  undefined 
+    return () => {
+        if (id === undefined) {
+            id = requestAnimationFrame(() => {
+                id = undefined
+                notify()
+            })
+        }
+        return () => {
+            if(id === undefined) {
+                return
+            }
+            cancelAnimationFrame(id)
+            id = undefined
+        }
+    }
+}
+
+
+
+
+type Subscriber = () => void
+
+export interface StateContribution<TState = {}, TAction extends AnyAction = AnyAction> {
+    reducerFactory: ReducersMapObjectContributor<TState, TAction>
+    notificationScope: ReducerNotificationScope
+    observable?: AnyPrivateObservableState
+}
+
+export interface ThrottledStore<T = any> extends Store<T> {
+    hasPendingSubscribers(): boolean
+    flush(config?: { excecutionType: 'scheduled' | 'immediate' | 'default' }): void
+    deferSubscriberNotifications<K>(action: () => K | Promise<K>, shouldDispatchClearCache?: boolean): Promise<K>
+}
+
+export interface PrivateThrottledStore<T = any> extends ThrottledStore<T> {
+    broadcastNotify(): void
+    observableNotify(observer: AnyPrivateObservableState): void
+    resetPendingNotifications(): void
+    syncSubscribe(listener: () => void): Unsubscribe
+    dispatchWithShell(shell: Shell): Dispatch
+}
+
+export interface PrivateObservableState<TState, TSelector> extends ObservableState<TSelector> {
+    notify(): void
+}
+
+export type AnyPrivateObservableState = PrivateObservableState<any, any>
+
+const buildStoreReducer = (
+    contributedState: ExtensionSlot<StateContribution>,
+    broadcastNotify: PrivateThrottledStore['broadcastNotify'],
+    observableNotify: PrivateThrottledStore['observableNotify'],
+    shouldScopeReducers?: boolean
+): Reducer => {
+    function withNotifyAction(
+        originalReducersMap: ReducersMapObject,
+        notifyAction: () => void,
+        storeShellName?: string
+    ): ReducersMapObject {
+        const decorateReducer = (originalReducer: Reducer): Reducer => {
+            return (state0, action: AnyShellAction) => {
+                if (shouldScopeReducers && state0 && storeShellName && action.__shellName && storeShellName !== action.__shellName) {
+                    return state0
+                }
+                const state1 = originalReducer(state0, action)
+                if (state1 !== state0) {
+                    notifyAction()
+                }
+                return state1
+            }
+        }
+        const wrapper = interceptAnyObject(originalReducersMap, (name, func) => {
+            const originalReducer = func as Reducer
+            return decorateReducer(originalReducer)
+        })
+        return wrapper
+    }
+
+    function withBroadcastOrObservableNotify(
+        { notificationScope, reducerFactory, observable }: StateContribution,
+        storeShellName: string
+    ): ReducersMapObject {
+        const originalReducersMap = reducerFactory()
+        if (notificationScope === 'broadcasting') {
+            return withNotifyAction(originalReducersMap, broadcastNotify, storeShellName)
+        }
+        if (!observable) {
+            // should never happen; would be an internal bug
+            throw new Error(
+                `getPerShellReducersMapObject: notificationScope=observable but 'observable' is falsy, in shell '${storeShellName}'`
+            )
+        }
+        return withNotifyAction(originalReducersMap, () => observableNotify(observable))
+    }
+
+    function getPerShellReducersMapObject(): ShellsReducersMap {
+        return contributedState.getItems().reduce((map: ShellsReducersMap, item) => {
+            const shellName = item.shell.name
+            map[shellName] = {
+                ...map[shellName],
+                ...withBroadcastOrObservableNotify(item.contribution, shellName)
+            }
+            return map
+        }, {})
+    }
+
+    function getCombinedShellReducers(): ReducersMapObject {
+        const shellsReducerMaps = getPerShellReducersMapObject()
+        const combinedReducersMap = _.mapValues(shellsReducerMaps, singleMap => combineReducers(singleMap))
+        return combinedReducersMap
+    }
+
+    function buildReducersMapObject(): ReducersMapObject {
+        // TODO: get rid of builtInReducersMaps
+        const builtInReducersMaps: ReducersMapObject = {
+            ...contributeInstalledShellsState()
+        }
+        return { ...builtInReducersMaps, ...getCombinedShellReducers() }
+    }
+
+    const reducersMap = buildReducersMapObject()
+    const combinedReducer = combineReducers(reducersMap)
+    return combinedReducer
+}
+
+export const updateThrottledStore = (
+    host: AppHost & AppHostServicesProvider,
+    store: PrivateThrottledStore,
+    contributedState: ExtensionSlot<StateContribution>
+): void => {
+    const newReducer = buildStoreReducer(contributedState, store.broadcastNotify, store.observableNotify, host.options.shouldScopeReducers)
+    store.replaceReducer(newReducer)
+    store.resetPendingNotifications()
+}
+
+export const createThrottledStore = (
+    host: AppHost & AppHostServicesProvider,
+    contributedState: ExtensionSlot<StateContribution>,
+    updateIsSubscriptionNotifyInProgress: (isSubscriptionNotifyInProgress: boolean) => void,
+    updateIsObserversNotifyInProgress: (isObserversNotifyInProgress: boolean) => void,
+    updateShouldFlushMemoizationSync: (shouldFlushMemoizationSync: boolean) => void
+): PrivateThrottledStore => {
+    let pendingBroadcastNotification = false
+    let pendingObservableNotifications: Set<AnyPrivateObservableState> | undefined
+    let isDeferrringNotifications = false
+    let pendingFlush = false
+
+    const onBroadcastNotify = () => {
+        pendingBroadcastNotification = true
+    }
+
+    const onObservableNotify = (observable: AnyPrivateObservableState) => {
+        if (!pendingObservableNotifications) {
+            pendingObservableNotifications = new Set<AnyPrivateObservableState>()
+        }
+        pendingObservableNotifications.add(observable)
+    }
+
+    const resetAllPendingNotifications = () => {
+        pendingBroadcastNotification = false
+        pendingObservableNotifications = undefined
+    }
+
+    const reducer = buildStoreReducer(contributedState, onBroadcastNotify, onObservableNotify, host.options.shouldScopeReducers)
+    const store: Store = host.options.enableReduxDevtoolsExtension
+        ? createStore(reducer, devToolsEnhancer({ name: 'repluggable' }))
+        : createStore(reducer)
+    const invoke = (f: Subscriber) => f()
+
+    let broadcastSubscribers: Subscriber[] = []
+
+    const subscribe = (subscriber: Subscriber) => {
+        broadcastSubscribers = _.concat(broadcastSubscribers, subscriber)
+        return () => {
+            broadcastSubscribers = _.without(broadcastSubscribers, subscriber)
+        }
+    }
+
+    const notifySubscribers = () => {
+        if (pendingBroadcastNotification || !pendingObservableNotifications) {
+            host.getAppHostServicesShell().log.monitor('ThrottledStore.notifySubscribers', {}, () =>
+                _.forEach(broadcastSubscribers, invoke)
+            )
+        }
+    }
+
+    const notifyObservers = () => {
+        if (pendingObservableNotifications) {
+            pendingObservableNotifications.forEach(observable => {
+                observable.notify()
+            })
+        }
+    }
+
+    const notifyAll = () => {
+        try {
+            updateIsObserversNotifyInProgress(true)
+            notifyObservers()
+            updateIsSubscriptionNotifyInProgress(true)
+            notifySubscribers()
+        } finally {
+            resetAllPendingNotifications()
+            updateIsSubscriptionNotifyInProgress(false)
+            updateIsObserversNotifyInProgress(false)
+        }
+    }
+
+    const scheduledNotifyAll = () => {
+        if (isDeferrringNotifications) {
+            return
+        }
+        notifyAll()
+    }
+
+
+   
+
+    const notifyAllOnPublish = typeof window === 'undefined' ? createTimeOutPublisher(scheduledNotifyAll) : createAnimationFramePublisher(scheduledNotifyAll)
+
+    let cancelRender = _.noop
+
+    store.subscribe(() => {
+        cancelRender = notifyAllOnPublish()
+    })
+
+    const flush = (config = { excecutionType: 'default' }) => {
+        if (isDeferrringNotifications && config.excecutionType !== 'immediate') {
+            pendingFlush = true
+            return
+        }
+        if (config.excecutionType !== 'scheduled') {
+            cancelRender()
+        }
+        notifyAll()
+    }
+
+    const dispatch: Dispatch<AnyAction> = action => {
+        return store.dispatch(action)
+    }
+
+    const toShellAction = <T extends Action>(shell: Shell, action: T): T => ({
+        ...action,
+        __shellName: shell.name
+    })
+
+    const executePendingActions = () => {
+        if (pendingFlush) {
+            pendingFlush = false
+            flush()
+        } else if (pendingBroadcastNotification || pendingObservableNotifications) {
+            notifyAll()
+        }
+    }
+
+    const result: PrivateThrottledStore = {
+        ...store,
+        subscribe,
+        syncSubscribe: store.subscribe,
+        dispatch,
+        dispatchWithShell: shell => action => dispatch(toShellAction(shell, action)),
+        flush,
+        broadcastNotify: onBroadcastNotify,
+        observableNotify: onObservableNotify,
+        resetPendingNotifications: resetAllPendingNotifications,
+        hasPendingSubscribers: () => pendingBroadcastNotification,
+        deferSubscriberNotifications: async (action, shouldDispatchClearCache) => {
+            if (isDeferrringNotifications) {
+                return action()
+            }
+            try {
+                executePendingActions()
+                isDeferrringNotifications = true
+                shouldDispatchClearCache && updateShouldFlushMemoizationSync(isDeferrringNotifications)
+                const functionResult = await action()
+                return functionResult
+            } finally {
+                isDeferrringNotifications = false
+                shouldDispatchClearCache && updateShouldFlushMemoizationSync(isDeferrringNotifications)
+                executePendingActions()
+            }
+        }
+    }
+
+    resetAllPendingNotifications()
+    return result
+}
+
+export const createObservable = <TState, TSelector>(
+    shell: Shell,
+    uniqueName: string,
+    selectorFactory: (state: TState) => TSelector
+): PrivateObservableState<TState, TSelector> => {
+    const subscribersSlotKey: SlotKey<StateObserver<TSelector>> = {
+        name: uniqueName
+    }
+    const observersSlot = shell.declareSlot(subscribersSlotKey)
+
+    const createSelector = (): TSelector => {
+        return selectorFactory(shell.getStore<TState>().getState())
+    }
+
+    return {
+        subscribe(fromShell, callback) {
+            observersSlot.contribute(fromShell, callback)
+            return () => {
+                observersSlot.discardBy(item => item.contribution === callback)
+            }
+        },
+        notify() {
+            const newSelector = createSelector()
+            invokeSlotCallbacks(observersSlot, newSelector)
+        },
+        current: createSelector
+    }
+}