repluggable-core 1.302.66 → 1.302.68

package/__tests__/spec-setup.js

@@ -0,0 +1,3 @@
+global.console.error = (...args) => {
+  throw new Error(args.join('\n'));
+};

package/debug/index.ts

@@ -0,0 +1 @@
+export { RepluggableAppDebugInfo, APIDebugInfo } from '../src/repluggableAppDebug/debug'

package/dist/debug/debug/index.d.ts

@@ -0,0 +1 @@
+export { RepluggableAppDebugInfo, APIDebugInfo } from '../src/repluggableAppDebug/debug';

package/dist/{es → debug/src}/API.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="react" />
 /// <reference types="lodash" />
 import * as Redux from 'redux';
+import { ThrottledStore } from './throttledStore';
+import { INTERNAL_DONT_USE_SHELL_GET_APP_HOST } from './__internal';
 export interface AnySlotKey {
     readonly name: string;
     readonly public?: boolean;
@@ -31,6 +33,8 @@ export interface SlotKey<T> extends AnySlotKey {
      */
     readonly version?: number;
 }
+export { AppHostAPI } from './appHostServices';
+export type ScopedStore<S> = Pick<ThrottledStore<S>, 'dispatch' | 'getState' | 'subscribe' | 'flush' | 'hasPendingSubscribers' | 'deferSubscriberNotifications'>;
 export type ReactComponentContributor<TProps = {}> = (props?: TProps) => React.ReactNode;
 export type ReducersMapObjectContributor<TState = {}, TAction extends Redux.AnyAction = Redux.AnyAction> = () => Redux.ReducersMapObject<TState, TAction>;
 export type ContributionPredicate = () => boolean;
@@ -191,6 +195,12 @@ export interface ExtensionItem<T> {
  * @interface AppHost
  */
 export interface AppHost {
+    /**
+     * Get the root store of the application
+     *
+     * @return {ThrottledStore}
+     */
+    getStore(): ThrottledStore;
     /**
      * Get an implementation of API previously contributed to the {AppHost}
      *
@@ -199,6 +209,14 @@ export interface AppHost {
      * @return {*}  {TAPI}
      */
     getAPI<TAPI>(key: SlotKey<TAPI>): TAPI;
+    /**
+     * Check if an API implementation has been contributed to the {AppHost}
+     *
+     * @template TAPI
+     * @param {SlotKey<TAPI>} key API Key
+     * @return {*}  {boolean}
+     */
+    hasAPI<TAPI>(key: SlotKey<TAPI>): boolean;
     /**
      * Get an extension slot defined on the host
      *
@@ -207,6 +225,14 @@ export interface AppHost {
      * @return {ExtensionSlot<TItem>}
      */
     getSlot<TItem>(key: SlotKey<TItem>): ExtensionSlot<TItem>;
+    /**
+     * Check if an extension slot has been contributed to the {AppHost}
+     *
+     * @template TItem
+     * @param {SlotKey<TItem>} key
+     * @return {boolean}
+     */
+    hasSlot<TItem>(key: SlotKey<TItem>): boolean;
     /**
      * Get all the extension slots defined on the host
      *
@@ -242,13 +268,13 @@ export interface AppHost {
      */
     removeShells(names: string[]): Promise<void>;
     /**
- * Subscribe to changes in host declarations. This includes:
- * - API additions and removals
- * - Extension slot additions and removals
- *
- * @param {DeclarationsChangedCallback} callback Function to be called when host declarations change
- * @return {UnsubscribeFromDeclarationsChanged} Function to unsubscribe from host declarations changes
- */
+     * Subscribe to changes in host declarations. This includes:
+     * - API additions and removals
+     * - Extension slot additions and removals
+     *
+     * @param {DeclarationsChangedCallback} callback Function to be called when host declarations change
+     * @return {UnsubscribeFromDeclarationsChanged} Function to unsubscribe from host declarations changes
+     */
     onDeclarationsChanged(callback: DeclarationsChangedCallback): UnsubscribeFromDeclarationsChanged;
     onShellsChanged(callback: ShellsChangedCallback): string;
     removeShellsChangedCallback(callbackId: string): void;
@@ -321,6 +347,18 @@ export interface Lazy<T> {
  * @extends {(Pick<AppHost, Exclude<keyof AppHost, 'getStore' | 'log' | 'options'>>)}
  */
 export interface Shell extends Pick<AppHost, Exclude<keyof AppHost, 'getStore' | 'log' | 'options'>> {
+    /**
+     * Unique name of the matching {EntryPoint}
+     */
+    readonly name: string;
+    readonly log: ShellLogger;
+    /**
+     * Get store that is scoped for this {Shell}
+     *
+     * @template TState
+     * @return {ScopedStore<TState>} Scoped store for this {Shell}
+     */
+    getStore<TState>(): ScopedStore<TState>;
     /**
      * Are APIs ready to be requested
      *
@@ -432,7 +470,7 @@ export interface PrivateShell extends Shell {
     setLifecycleState(enableStore: boolean, enableAPIs: boolean, initCompleted: boolean): void;
     getBoundaryAspects(): ShellBoundaryAspect[];
     getHostOptions(): AppHostOptions;
-    wrapWithShellRenderer(component: JSX.Element): JSX.Element;
+    readonly [INTERNAL_DONT_USE_SHELL_GET_APP_HOST]: () => AppHost;
 }
 export interface EntryPointsInfo {
     readonly name: string;
@@ -468,4 +506,3 @@ export interface ShellLogger extends HostLogger {
 export interface ShellLoggerSpan {
     end(success: boolean, error?: Error, keyValuePairs?: Object): void;
 }
-//# sourceMappingURL=API.d.ts.map

package/dist/debug/src/__internal.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This symbol is only for internal use of repluggable mono-repo.
+ */
+export declare const INTERNAL_DONT_USE_SHELL_GET_APP_HOST: unique symbol;

package/dist/debug/src/appHostServices.d.ts

@@ -0,0 +1,11 @@
+import { AppHostOptions, EntryPoint, Shell, SlotKey } from './API';
+export interface AppHostAPI {
+    getAllEntryPoints(): EntryPoint[];
+    getAppHostOptions(): AppHostOptions;
+}
+export declare const AppHostServicesEntryPointName = "APP-HOST-SERVICES";
+export declare const AppHostAPI: SlotKey<AppHostAPI>;
+export interface AppHostServicesProvider {
+    getAppHostServicesShell(): Shell;
+}
+export declare function createAppHostServicesEntryPoint(apiFactory: () => AppHostAPI): EntryPoint & AppHostServicesProvider;

package/dist/debug/src/extensionSlot.d.ts

@@ -0,0 +1,7 @@
+import { AppHost, PrivateExtensionSlot, Shell, SlotKey, CustomExtensionSlot, CustomExtensionSlotHandler, PrivateAppHost } from './API';
+export interface AnyExtensionSlot {
+    readonly name: string;
+    readonly declaringShell?: Shell;
+}
+export declare function createExtensionSlot<T>(key: SlotKey<T>, host: PrivateAppHost, declaringShell?: Shell): PrivateExtensionSlot<T> & AnyExtensionSlot;
+export declare function createCustomExtensionSlot<T>(key: SlotKey<T>, handler: CustomExtensionSlotHandler<T>, host: AppHost, declaringShell?: Shell): CustomExtensionSlot<T> & AnyExtensionSlot;

package/dist/debug/src/hot.d.ts

@@ -0,0 +1,13 @@
+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 declare function hot(sourceModule: any, entryPoints: EntryPoint[], host?: AppHost): EntryPoint[];

package/dist/debug/src/installedShellsState.d.ts

@@ -0,0 +1,18 @@
+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;
+}
+export declare const contributeInstalledShellsState: () => ReducersMapObject;
+export declare const InstalledShellsSelectors: {
+    getInstalledShellsSet(state: any): ShellToggleSet;
+};
+export declare const InstalledShellsActions: {
+    updateInstalledShells: (updates: ShellToggleSet) => UpdateInstalledShellsAction;
+};
+export declare const installedShellsReducer: (state: InstalledShellsState | undefined, action: AnyAction) => InstalledShellsState;

package/dist/debug/src/interceptAnyObject.d.ts

@@ -0,0 +1,6 @@
+export type FunctionInterceptor = (name: string, original: Function) => Function;
+export type PropertyInterceptor = (name: string, original: any) => any;
+export interface AnyObject {
+    [key: string]: any;
+}
+export declare function interceptAnyObject<T>(inner: T, onFunction?: FunctionInterceptor, onProperty?: PropertyInterceptor, includeNestedLevels?: number): T;

package/dist/debug/src/invokeSlotCallbacks.d.ts

@@ -0,0 +1,2 @@
+import { ExtensionSlot } from './API';
+export declare function invokeSlotCallbacks<T extends any[]>(slot: ExtensionSlot<(...args: T) => void | Promise<void>>, ...args: T): void;

package/dist/debug/src/throttledStore.d.ts

@@ -0,0 +1,31 @@
+import { AnyAction, Dispatch, Store, Unsubscribe } from 'redux';
+import { AppHost, ExtensionSlot, ObservableState, ReducersMapObjectContributor, Shell } from './API';
+import { AppHostServicesProvider } from './appHostServices';
+type ReducerNotificationScope = 'broadcasting' | 'observable';
+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>;
+export declare const updateThrottledStore: (host: AppHost & AppHostServicesProvider, store: PrivateThrottledStore, contributedState: ExtensionSlot<StateContribution>) => void;
+export declare const createThrottledStore: (host: AppHost & AppHostServicesProvider, contributedState: ExtensionSlot<StateContribution>, updateIsSubscriptionNotifyInProgress: (isSubscriptionNotifyInProgress: boolean) => void, updateIsObserversNotifyInProgress: (isObserversNotifyInProgress: boolean) => void, updateShouldFlushMemoizationSync: (shouldFlushMemoizationSync: boolean) => void) => PrivateThrottledStore;
+export declare const createObservable: <TState, TSelector>(shell: Shell, uniqueName: string, selectorFactory: (state: TState) => TSelector) => PrivateObservableState<TState, TSelector>;
+export {};