repluggable-core 0.0.0-pr280.413 → 0.0.0-pr282.418

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,4 +1,56 @@
 export {
-    AnySlotKey,
-    SlotKey
-} from './API'
+  EntryPointOrPackage,
+  EntryPointOrPackagesMap,
+  EntryPoint,
+  AppHost,
+  AppHostAPI,
+  AppHostOptions,
+  Shell,
+  ExtensionSlot,
+  ExtensionItem,
+  CustomExtensionSlot,
+  CustomExtensionSlotHandler,
+  AnySlotKey,
+  SlotKey,
+  ReactComponentContributor,
+  ReducersMapObjectContributor,
+  EntryPointInterceptor,
+  ShellLogger,
+  ShellLoggerSpan,
+  HostLogger,
+  LogSeverity,
+  APILayer,
+  StateObserverUnsubscribe,
+  StateObserver,
+  ObservableState,
+  ScopedStore,
+} from "./API";
+
+export {
+  createAppHost,
+  makeLazyEntryPoint,
+  mainViewSlotKey,
+  stateSlotKey,
+} from "./appHost";
+
+export { AppHostServicesProvider } from "./appHostServices";
+
+export { createShellLogger } from "./loggers";
+
+export { invokeSlotCallbacks } from "./invokeSlotCallbacks";
+
+export { interceptAnyObject } from "./interceptAnyObject";
+
+export { monitorAPI } from "./monitorAPI";
+
+export {
+  InstalledShellsSelectors,
+  ShellToggleSet,
+} from "./installedShellsState";
+
+export { hot } from "./hot";
+
+export {
+  interceptEntryPoints,
+  interceptEntryPointsMap,
+} from "./interceptEntryPoints";

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/interceptEntryPoints.ts

@@ -0,0 +1,25 @@
+import _ from 'lodash'
+import { EntryPoint, EntryPointOrPackage, EntryPointInterceptor, EntryPointOrPackagesMap } from './API'
+
+export function interceptEntryPoints(entryPoints: EntryPointOrPackage, interceptor: EntryPointInterceptor): EntryPoint[] {
+    return (_.flatten([entryPoints]) as EntryPoint[]).map(ep => applyInterceptor(ep, interceptor))
+}
+
+export function interceptEntryPointsMap(entryPointsMap: EntryPointOrPackagesMap, interceptor: EntryPointInterceptor) {
+    return _.mapValues(entryPointsMap, ep => interceptEntryPoints(ep, interceptor))
+}
+
+function applyInterceptor(inner: EntryPoint, interceptor: EntryPointInterceptor): EntryPoint {
+    return {
+        name: interceptor.interceptName ? interceptor.interceptName(inner.name) : inner.name,
+        layer: inner.layer,
+        tags: interceptor.interceptTags ? interceptor.interceptTags(inner.tags) : inner.tags,
+        getDependencyAPIs: interceptor.interceptGetDependencyAPIs
+            ? interceptor.interceptGetDependencyAPIs(inner.getDependencyAPIs)
+            : inner.getDependencyAPIs,
+        declareAPIs: interceptor.interceptDeclareAPIs ? interceptor.interceptDeclareAPIs(inner.declareAPIs) : inner.declareAPIs,
+        attach: interceptor.interceptAttach ? interceptor.interceptAttach(inner.attach) : inner.attach,
+        detach: interceptor.interceptDetach ? interceptor.interceptDetach(inner.detach) : inner.detach,
+        extend: interceptor.interceptExtend ? interceptor.interceptExtend(inner.extend) : inner.extend
+    }
+}

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'