repluggable-core 1.302.66 → 1.302.68

package/src/appHostServices.ts

@@ -0,0 +1,42 @@
+import { AppHostOptions, EntryPoint, Shell, SlotKey } from './API'
+
+export interface AppHostAPI {
+    getAllEntryPoints(): EntryPoint[]
+    getAppHostOptions(): AppHostOptions
+}
+
+export const AppHostServicesEntryPointName = 'APP-HOST-SERVICES'
+
+export const AppHostAPI: SlotKey<AppHostAPI> = {
+    name: 'AppHost API',
+    public: true
+}
+
+export interface AppHostServicesProvider {
+    getAppHostServicesShell(): Shell
+}
+
+export function createAppHostServicesEntryPoint(apiFactory: () => AppHostAPI): EntryPoint & AppHostServicesProvider {
+    let cachedShell: Shell | null = null
+
+    return {
+        name: AppHostServicesEntryPointName,
+
+        declareAPIs() {
+            return [AppHostAPI]
+        },
+
+        attach(shell: Shell) {
+            cachedShell = shell
+            shell.contributeAPI(AppHostAPI, apiFactory)
+        },
+
+        getAppHostServicesShell() {
+            if (cachedShell) {
+                return cachedShell
+            }
+
+            throw new Error('Shell for AppHostServices entry point was not yet created')
+        }
+    }
+}

package/src/appHostUtils.ts

@@ -0,0 +1,11 @@
+import { AnyEntryPoint, AnySlotKey } from './API'
+
+import _ from 'lodash'
+
+export const dependentAPIs = (entryPoint: AnyEntryPoint): AnySlotKey[] => {
+    return _.chain(entryPoint).invoke('getDependencyAPIs').defaultTo([]).value()
+}
+
+export const declaredAPIs = (entryPoint: AnyEntryPoint): AnySlotKey[] => {
+    return _.chain(entryPoint).invoke('declareAPIs').defaultTo([]).value()
+}

package/src/extensionSlot.ts

@@ -0,0 +1,96 @@
+import {
+    AppHost,
+    ContributionPredicate,
+    ExtensionItem,
+    ExtensionItemFilter,
+    PrivateExtensionSlot,
+    Shell,
+    SlotKey,
+    CustomExtensionSlot,
+    CustomExtensionSlotHandler,
+    PrivateAppHost
+} from './API'
+import _ from 'lodash'
+
+export interface AnyExtensionSlot {
+    readonly name: string
+    readonly declaringShell?: Shell
+}
+
+const alwaysTrue = () => true
+
+type Unsubscribe = () => void
+
+export function createExtensionSlot<T>(
+    key: SlotKey<T>,
+    host: PrivateAppHost,
+    declaringShell?: Shell
+): PrivateExtensionSlot<T> & AnyExtensionSlot {
+    let items: ExtensionItem<T>[] = []
+    let subscribers: (() => void)[] = []
+    const slotUniqueId = _.uniqueId()
+
+    return {
+        host,
+        declaringShell,
+        name: key.name,
+        contribute,
+        getItems,
+        getSingleItem,
+        getItemByName,
+        discardBy,
+        subscribe
+    }
+
+    function contribute(fromShell: Shell, item: T, condition?: ContributionPredicate): void {
+        items.push({
+            shell: fromShell,
+            contribution: item,
+            condition: condition || alwaysTrue,
+            uniqueId: _.uniqueId(`${fromShell.name}_extItem_`)
+        })
+        host.executeWhenFree(slotUniqueId, () => subscribers.forEach(func => func()))
+    }
+
+    function getItems(forceAll: boolean = false): ExtensionItem<T>[] {
+        return forceAll ? items : items.filter(item => item.condition())
+    }
+
+    function getSingleItem(): ExtensionItem<T> | undefined {
+        return items.find(item => item.condition())
+    }
+
+    function getItemByName(name: string): ExtensionItem<T> | undefined {
+        return items.find(item => item.name === name && item.condition())
+    }
+
+    function discardBy(predicate: ExtensionItemFilter<T>) {
+        const originalContributionCount = items.length
+        items = items.filter(v => !predicate(v))
+        if (items.length !== originalContributionCount) {
+            subscribers.forEach(func => func())
+        }
+    }
+
+    function subscribe(callback: () => void): Unsubscribe {
+        subscribers.push(callback)
+        return () => {
+            subscribers = subscribers.filter(func => func !== callback)
+        }
+    }
+}
+
+export function createCustomExtensionSlot<T>(
+    key: SlotKey<T>,
+    handler: CustomExtensionSlotHandler<T>,
+    host: AppHost,
+    declaringShell?: Shell
+): CustomExtensionSlot<T> & AnyExtensionSlot {
+    return {
+        name: key.name,
+        host,
+        declaringShell,
+        contribute: (...args) => handler.contribute(...args),
+        discardBy: (...args) => handler.discardBy(...args)
+    }
+}

package/src/hot.ts

@@ -0,0 +1,53 @@
+import { AppHost, EntryPoint } from './API'
+
+export type Hot = typeof hot
+
+/**
+ * To enable HMR, use the `hot` util to wrap the export of your repluggable package
+ *
+ * @param {NodeModule} sourceModule
+ * @param {EntryPoint[]} entryPoints
+ * @param {AppHost} [host] Optional. The AppHost to be used for removing / adding entrypoints. If not provided, `window.repluggableAppDebug.host` will be used,
+ * @example ```ts
+ * export default hot(module, [FooEntryPoint, BarEntryPoint])
+ * ```
+ */
+export function hot(sourceModule: any, entryPoints: EntryPoint[], host?: AppHost) {
+    if (!sourceModule.hot) {
+        return entryPoints
+    }
+
+    const getHostInstance = () => {
+        const hostInstance = host ?? globalThis.repluggableAppDebug?.host
+        if (!hostInstance) {
+            console.error(
+                `HMR error: cannot find host object.\n` +
+                    `hot(...) was called without the optional host parameter, and the fallback globalThis.repluggableAppDebug.host doesn't exist`
+            )
+        }
+
+        return hostInstance
+    }
+
+    const shellNames = entryPoints.map(x => x.name)
+    const shortModuleId = sourceModule.id.split('/').pop()
+
+    sourceModule.hot.accept()
+    sourceModule.hot.dispose(async () => {
+        const hostInstance = getHostInstance()
+        if (hostInstance) {
+            console.debug(`----- HMR[${shortModuleId}] > REMOVING SHELLS >`, shellNames)
+            await hostInstance.removeShells(shellNames)
+        }
+    })
+
+    if (sourceModule.hot.status() === 'apply') {
+        const hostInstance = getHostInstance()
+        if (hostInstance) {
+            console.debug(`----- HMR[${shortModuleId}] > ADDING SHELLS >`, shellNames)
+            hostInstance.addShells(entryPoints)
+        }
+    }
+
+    return entryPoints
+}

package/src/index.ts

@@ -1,6 +1,46 @@
 export {
+    EntryPointOrPackage,
+    EntryPointOrPackagesMap,
+    EntryPoint,
+    AppHost,
+    AppHostAPI,
+    AppHostOptions,
+    Shell,
+    ExtensionSlot,
+    ExtensionItem,
+    CustomExtensionSlot,
+    CustomExtensionSlotHandler,
     AnySlotKey,
-    SlotKey
+    SlotKey,
+    ReactComponentContributor,
+    ReducersMapObjectContributor,
+    EntryPointInterceptor,
+    ShellLogger,
+    ShellLoggerSpan,
+    HostLogger,
+    LogSeverity,
+    APILayer,
+    StateObserverUnsubscribe,
+    StateObserver,
+    ObservableState,
+    ScopedStore
 } from './API'
 
-export * from './__internal'
+
+
+export { ConsoleHostLogger } from './loggers'
+
+export { createAppHost, makeLazyEntryPoint, mainViewSlotKey, stateSlotKey } from './appHost'
+
+export {AppHostServicesProvider} from './appHostServices'
+
+export { InstalledShellsSelectors, ShellToggleSet } from './installedShellsState'
+
+export { invokeSlotCallbacks } from './invokeSlotCallbacks'
+
+export { interceptAnyObject } from './interceptAnyObject'
+export { monitorAPI } from './monitorAPI'
+export { hot } from './hot'
+
+
+export {INTERNAL_DONT_USE_SHELL_GET_APP_HOST} from './__internal'

package/src/installedShellsState.ts

@@ -0,0 +1,54 @@
+import _ from 'lodash'
+import { Action, AnyAction, ReducersMapObject } from 'redux'
+
+export interface ShellToggleSet {
+    [name: string]: boolean
+}
+
+export interface InstalledShellsState {
+    readonly installedShells: ShellToggleSet
+}
+
+export interface UpdateInstalledShellsAction extends Action {
+    readonly updates: ShellToggleSet
+}
+
+const UPDATE_INSTALLED_SHELLS_ACTION = '$installedShells/update'
+
+export const contributeInstalledShellsState = (): ReducersMapObject => {
+    return {
+        $installedShells: installedShellsReducer
+    }
+}
+
+const selectRootState = (state: any): InstalledShellsState => state.$installedShells
+
+export const InstalledShellsSelectors = {
+    getInstalledShellsSet(state: any): ShellToggleSet {
+        return selectRootState(state).installedShells
+    }
+}
+
+export const InstalledShellsActions = {
+    updateInstalledShells: (updates: ShellToggleSet): UpdateInstalledShellsAction => {
+        return {
+            type: UPDATE_INSTALLED_SHELLS_ACTION,
+            updates
+        }
+    }
+}
+
+const toggleInstalledShells = (currentlyInstalled: ShellToggleSet, updates: ShellToggleSet): ShellToggleSet =>
+    _.pickBy(_.assign({}, currentlyInstalled, updates), _.identity)
+
+export const installedShellsReducer = (state: InstalledShellsState = { installedShells: {} }, action: AnyAction): InstalledShellsState => {
+    switch (action.type) {
+        case UPDATE_INSTALLED_SHELLS_ACTION:
+            return {
+                ...state,
+                installedShells: toggleInstalledShells(state.installedShells, action.updates)
+            }
+    }
+
+    return state
+}

package/src/interceptAnyObject.ts

@@ -0,0 +1,39 @@
+import _ from 'lodash'
+
+export type FunctionInterceptor = (name: string, original: Function) => Function
+export type PropertyInterceptor = (name: string, original: any) => any
+
+export interface AnyObject {
+    [key: string]: any
+}
+const isPlainObject = (value: any): value is AnyObject => _.isPlainObject(value)
+
+export function interceptAnyObject<T>(
+    inner: T,
+    onFunction?: FunctionInterceptor,
+    onProperty?: PropertyInterceptor,
+    includeNestedLevels?: number
+): T {
+    if (isPlainObject(inner)) {
+        const result = _.mapValues(inner, (original, key) => {
+            if (typeof original === 'function' && typeof onFunction === 'function') {
+                return onFunction(key, original)
+            }
+            if (includeNestedLevels && _.isPlainObject(original)) {
+                return interceptAnyObject(
+                    original,
+                    onFunction ? (name, func) => onFunction(`${key}.${name}`, func) : undefined,
+                    onProperty ? (name, value) => onProperty(`${key}.${name}`, value) : undefined,
+                    includeNestedLevels - 1
+                )
+            }
+            if (typeof onProperty === 'function') {
+                return onProperty(key, original)
+            }
+            return original
+        }) as T
+
+        return result
+    }
+    return inner
+}

package/src/invokeSlotCallbacks.ts

@@ -0,0 +1,20 @@
+import { ExtensionSlot } from './API'
+
+export function invokeSlotCallbacks<T extends any[]>(slot: ExtensionSlot<(...args: T) => void | Promise<void>>, ...args: T): void {
+    const slotItems = slot.getItems()
+
+    if (slot.host.options.monitoring.disableMonitoring) {
+        slotItems.forEach(slotItem => {
+            try {
+                slotItem.contribution(...args)
+            } catch (e) {
+                console.error(e)
+            }
+        })
+    } else {
+        slotItems.forEach(slotItem => {
+            const messageId = `${slot.host}-${slot.name}:${slotItem.shell.name}${slotItem.name && '-' + slotItem.name}`
+            slotItem.shell.log.monitor(messageId, {}, () => slotItem.contribution(...args))
+        })
+    }
+}

package/src/loggers.ts

@@ -0,0 +1,112 @@
+import { HostLogger, LogSeverity, ShellLogger, EntryPoint, AppHost, ShellLoggerSpan, EntryPointTags } from './API'
+
+const consoleLoggerSpan: ShellLoggerSpan = {
+    end(success, error, keyValuePairs) {
+        if (error) {
+            console.error(error, keyValuePairs)
+        }
+    }
+}
+
+export const ConsoleHostLogger: HostLogger = {
+    spanRoot(messageId: string, error?: Error, keyValuePairs?: Object): ShellLoggerSpan {
+        return consoleLoggerSpan
+    },
+    spanChild(messageId: string, error?: Error, keyValuePairs?: Object): ShellLoggerSpan {
+        return consoleLoggerSpan
+    },
+    log(severity: LogSeverity, id: string, error?: Error, keyValuePairs?: Object): void {
+        const consoleFunc = getConsoleOutputFunc(severity)
+        consoleFunc(id, keyValuePairs)
+    }
+}
+
+export function createShellLogger(host: AppHost, entryPoint: EntryPoint): ShellLogger {
+    const entryPointTags = buildEntryPointTags()
+
+    const spanChild = (messageId: string, keyValuePairs?: Object): ShellLoggerSpan => {
+        return host.log.spanChild(messageId, withEntryPointTags(keyValuePairs))
+    }
+
+    const spanRoot = (messageId: string, keyValuePairs?: Object): ShellLoggerSpan => {
+        return host.log.spanRoot(messageId, withEntryPointTags(keyValuePairs))
+    }
+
+    return {
+        log(severity: LogSeverity, id: string, keyValuePairs?: Object): void {
+            host.log.log(severity, id, undefined, withEntryPointTags(keyValuePairs))
+        },
+        debug(messageId: string, keyValuePairs?: Object): void {
+            host.log.log('debug', messageId, undefined, withEntryPointTags(keyValuePairs))
+        },
+        info(messageId: string, keyValuePairs?: Object): void {
+            host.log.log('info', messageId, undefined, withEntryPointTags(keyValuePairs))
+        },
+        warning(messageId: string, keyValuePairs?: Object): void {
+            host.log.log('warning', messageId, undefined, withEntryPointTags(keyValuePairs))
+        },
+        error(messageId: string, error?: Error, keyValuePairs?: Object): void {
+            host.log.log('error', messageId, error, withEntryPointTags(keyValuePairs))
+        },
+        critical(messageId: string, error?: Error, keyValuePairs?: Object): void {
+            host.log.log('critical', messageId, error, withEntryPointTags(keyValuePairs))
+        },
+        spanChild,
+        spanRoot,
+        monitor
+    }
+
+    function monitor(messageId: string, keyValuePairs: Object, monitoredCode: () => any): any {
+        const allTags = withEntryPointTags(keyValuePairs)
+        const span = spanChild(messageId, allTags)
+
+        try {
+            const returnValue = monitoredCode()
+
+            if (isPromise(returnValue)) {
+                return returnValue
+                    .then(retVal => {
+                        span.end(true, undefined, { ...allTags, returnValue: retVal })
+                        return retVal
+                    })
+                    .catch(error => {
+                        span.end(false, error, allTags)
+                        throw error
+                    })
+            }
+            span.end(true, undefined, { ...allTags, returnValue })
+            return returnValue
+        } catch (error) {
+            span.end(false, error, allTags)
+            throw error
+        }
+    }
+
+    function buildEntryPointTags(): EntryPointTags {
+        return entryPoint.tags ? { ...entryPoint.tags, $ep: entryPoint.name } : { $ep: entryPoint.name }
+    }
+
+    function withEntryPointTags(keyValuePairs?: Object) {
+        return keyValuePairs ? { ...keyValuePairs, ...entryPointTags } : entryPointTags
+    }
+
+    function isPromise(obj: any | Promise<any>): obj is Promise<any> {
+        return !!obj && typeof obj === 'object' && typeof obj.then === 'function'
+    }
+}
+
+function getConsoleOutputFunc(severity: LogSeverity): Console['log'] {
+    switch (severity) {
+        case 'debug':
+            return console.debug
+        case 'event':
+            return console.info
+        case 'warning':
+            return console.warn
+        case 'error':
+        case 'critical':
+            return console.error
+        default:
+            return console.log
+    }
+}

package/src/monitorAPI.ts

@@ -0,0 +1,71 @@
+import { AppHostOptions, Shell, enrichedMemoizationFunction, ContributeAPIOptions } from './API'
+import { interceptAnyObject } from './interceptAnyObject'
+
+function isEnrichedMemoizationFunction(func: any): func is enrichedMemoizationFunction {
+    return func.hasOwnProperty('cache') && func.hasOwnProperty('hit')
+}
+
+function isMemberNamesArray<TAPI>(value: boolean | (keyof TAPI)[] | undefined): value is (keyof TAPI)[] {
+    return Array.isArray(value)
+}
+
+export function monitorAPI<TAPI>(
+    shell: Shell,
+    hostOptions: AppHostOptions,
+    apiName: string,
+    api: TAPI,
+    //trace: Trace[],
+    //memoized: StatisticsMemoization[]
+    apiOptions?: ContributeAPIOptions<TAPI>
+): TAPI {
+    if (hostOptions.monitoring.disableMonitoring || (apiOptions && apiOptions.disableMonitoring === true)) {
+        return api
+    }
+
+    const shouldMonitor =
+        apiOptions && isMemberNamesArray(apiOptions.disableMonitoring)
+            ? (funcName: string) => {
+                  const { disableMonitoring } = apiOptions
+                  if (isMemberNamesArray(disableMonitoring)) {
+                      return !disableMonitoring.find(memberName => {
+                          const memberNameString = memberName as string
+                          return (
+                              funcName.indexOf(memberNameString) === 0 &&
+                              (funcName.length === memberNameString.length || funcName.charAt(memberNameString.length) === '.')
+                          )
+                      })
+                  }
+              }
+            : () => true
+
+    return interceptAnyObject(
+        api,
+        (funcName, originalFunc) => {
+            if (!shouldMonitor(funcName)) {
+                console.log('DISABLED MONITORING>', funcName)
+                return originalFunc
+            }
+            //let funcId = `${apiName}::${funcName}`
+            let isMemoized = false
+            if (isEnrichedMemoizationFunction(originalFunc)) {
+                isMemoized = true
+                //funcId += '(Memoized)'
+                //memoized.push({ name: funcId, func: originalFunc })
+            }
+            return (...args: any[]) => {
+                const tags = {
+                    $api: apiName,
+                    $apiFunc: funcName,
+                    $args: args,
+                    $memoized: isMemoized || undefined
+                }
+                return shell.log.monitor(`${apiName}.${funcName}`, tags, () => {
+                    return originalFunc.apply(api, args)
+                    //wrapWithMeasure(options, originalFunc, api, args, funcId, trace)
+                })
+            }
+        },
+        undefined,
+        apiOptions && apiOptions.includesNamespaces ? 4 : 0
+    )
+}

package/src/repluggableAppDebug/debug.d.ts

@@ -0,0 +1,37 @@
+import { EntryPoint, AppHost, AnySlotKey, LazyEntryPointFactory, PrivateShell, SlotKey } from '../API'
+import { AnyExtensionSlot } from '../extensionSlot'
+import { Hot } from '../hot'
+
+declare global {
+    // Have to use var is this variable reassigned in the global scope
+    var repluggableAppDebug: RepluggableAppDebugInfo
+}
+
+export interface RepluggableAppDebugInfo {
+    host: AppHost
+    uniqueShellNames: Set<string>
+    extensionSlots: Map<AnySlotKey, AnyExtensionSlot>
+    addedShells: Map<string, PrivateShell>
+    lazyShells: Map<string, LazyEntryPointFactory>
+    readyAPIs: Set<AnySlotKey>
+    shellInstallers: WeakMap<PrivateShell, string[]>
+    utils: RepluggableDebugUtils
+    hmr: RepluggableHMR
+}
+
+export interface RepluggableDebugUtils {
+    apis(): APIDebugInfo[]
+    unReadyEntryPoints(): EntryPoint[]
+    getRootUnreadyAPI(): SlotKey<any>[]
+    whyEntryPointUnready(name: string): void
+    findAPI(name: string): APIDebugInfo[]
+}
+
+export interface RepluggableHMR {
+    hot: Hot
+}
+
+export interface APIDebugInfo {
+    key: AnySlotKey
+    impl(): any
+}

package/src/repluggableAppDebug/index.ts

@@ -0,0 +1 @@
+export { setupDebugInfo } from './repluggableAppDebug'

package/src/repluggableAppDebug/performanceDebugInfo.ts

@@ -0,0 +1,96 @@
+import _ from 'lodash'
+import { AppHostOptions, Trace, StatisticsMemoization } from '../API'
+
+export function getPerformanceDebug(options: AppHostOptions, trace: Trace[], memoized: StatisticsMemoization[]) {
+    const getMemoizedTable = () => {
+        return _.map(memoized, memoize => {
+            const { calls, hit, miss } = memoize.func
+            const hitRate = `${((hit / calls) * 100).toFixed(2)}%`
+            const { name } = memoize
+            return { name, hitRate, calls, hit, miss }
+        })
+    }
+
+    const getGroups = (apiName: string) => {
+        const api = _.groupBy(trace, 'name')[apiName]
+        try {
+            const groupedArgs = _.groupBy(api, a => JSON.stringify(a.args))
+            const groupedRes = _.groupBy(api, a => JSON.stringify(a.res))
+            const groupedArgsAndRes = _.groupBy(api, a => JSON.stringify(a.args) + JSON.stringify(a.res))
+            return { groupedArgs, groupedRes, groupedArgsAndRes }
+        } catch (err) {
+            return { groupedArgs: [], groupedRes: [], groupedArgsAndRes: [] }
+        }
+    }
+    const printMemoizeTable = () => {
+        console.table(getMemoizedTable())
+    }
+    return {
+        getSortedMeasurments: () => {
+            return _(trace)
+                .map(measurement => _.pick(measurement, ['name', 'duration']))
+                .sortBy('duration')
+                .reverse()
+                .value()
+        },
+        start: () => {
+            if (!options.monitoring.disableMonitoring) {
+                options.monitoring.enablePerformance = true
+            } else {
+                console.log('Remove "disableMonitoring" in order to use trace')
+            }
+        },
+        stop: () => {
+            options.monitoring.enablePerformance = false
+        },
+        clean: () => {
+            trace.length = 0
+        },
+        getTrace: () => {
+            return trace
+        },
+        getGroupedTrace: () => {
+            return _.groupBy(trace, 'name')
+        },
+        getGroupedSumTrace: () => {
+            const traceData = _(trace)
+                .groupBy('name')
+                .mapValues((arr, name) => {
+                    const totalDuration = Number(_.sumBy(arr, 'duration').toFixed(2))
+                    const times = arr.length
+                    const avgDuration = Number((totalDuration / times).toFixed(2))
+                    const groups = _(getGroups(name))
+                        .mapValues((obj, group) => {
+                            const keys = Object.keys(obj)
+                            const length = keys.length
+                            if (group !== 'groupedRes' || length === 0) {
+                                return length
+                            }
+                            const joined = keys.join(' ')
+                            return joined.length < 15 ? `${length}: ${joined}` : length
+                        })
+                        .value()
+
+                    return { name, times, totalDuration, avgDuration, ...groups }
+                })
+                .orderBy(x => x.totalDuration, 'desc')
+                .value()
+
+            _.forEach(getMemoizedTable(), memoizeData => {
+                _.assign(_.find(traceData, { name: memoizeData.name }), memoizeData)
+            })
+            console.table(traceData)
+        },
+        analyseAPI: (apiName: string) => {
+            const groups = getGroups(apiName)
+            if (groups) {
+                const { groupedArgs, groupedRes, groupedArgsAndRes } = groups
+                console.log(`groupedArgs: ${Object.keys(groupedArgs).length}`, groupedArgs)
+                console.log(`groupedRes: ${Object.keys(groupedRes).length}`, groupedRes)
+                console.log(`groupedArgsAndRes: ${Object.keys(groupedArgsAndRes).length}`, groupedArgsAndRes)
+            }
+        },
+        getMemoized: () => memoized,
+        printMemoizeTable
+    }
+}