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

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 : null | NodeJS.Timeout =  null 
+    return () => {
+        if (id === null) {
+            id = setTimeout(() => {
+                id = null
+                notify()
+            },0)
+        }
+        return () => {
+            if(id === null) {
+                return
+            }
+            clearTimeout(id)
+            id = null
+        }
+    }
+}
+
+function createAnimationFramePublisher ( notify: () => void)  {
+    let id : null | number =  null 
+    return () => {
+        if (id === null) {
+            id = requestAnimationFrame(() => {
+                id = null
+                notify()
+            })
+        }
+        return () => {
+            if(id === null) {
+                return
+            }
+            cancelAnimationFrame(id)
+            id = null
+        }
+    }
+}
+
+
+
+
+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
+    }
+}

package/test/IterableWeakMap.spec.ts

@@ -0,0 +1,284 @@
+import { IterableWeakMap } from "../src/IterableWeakMap";
+
+describe("IterableWeakMap", () => {
+  function runCommonTests() {
+    describe("#constructor", () => {
+      it("should add initial values to Map", function () {
+        const ref = {};
+        const value = {};
+        const iwm = new IterableWeakMap([[ref, value]]);
+
+        const entries = Array.from(iwm.entries());
+        expect(entries).toEqual([[ref, value]]);
+      });
+    });
+
+    describe("#set", () => {
+      it("should add new value", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+
+        iwm.set(ref, value);
+
+        const entries = Array.from(iwm.entries());
+        expect(entries).toEqual([[ref, value]]);
+      });
+    });
+
+    describe("#get", () => {
+      it("should return value if ref exists in Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+
+        iwm.set(ref, value);
+
+        const getValue = iwm.get(ref);
+        expect(getValue).toEqual(value);
+      });
+
+      it("should return undefined if ref doesn't exist in Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+
+        iwm.set(ref, value);
+
+        const getValue = iwm.get(ref2);
+        expect(getValue).toBeUndefined();
+      });
+    });
+
+    describe("#delete", () => {
+      it("should delete value from Map and return true", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+
+        iwm.set(ref, value);
+
+        const res = iwm.delete(ref);
+
+        expect(iwm.size).toBe(0);
+        expect(res).toBeTruthy();
+      });
+
+      it("should return false if there is no ref in Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const refToDelete = {};
+
+        iwm.set(ref, value);
+
+        const res = iwm.delete(refToDelete);
+
+        expect(iwm.size).toBe(1);
+        expect(res).toBeFalsy();
+      });
+    });
+
+    describe("#size", () => {
+      it("should return size of Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+        const value2 = {};
+
+        iwm.set(ref, value);
+        iwm.set(ref2, value2);
+
+        expect(iwm.size).toBe(2);
+      });
+    });
+
+    describe("#has", () => {
+      it("should return true if map has ref", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+
+        iwm.set(ref, value);
+
+        expect(iwm.has(ref)).toBe(true);
+      });
+
+      it("should return false if map doesn't have ref", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+
+        iwm.set(ref, value);
+
+        expect(iwm.has(ref2)).toBe(false);
+      });
+    });
+
+    describe("#clear", () => {
+      it("should delete all refs from Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+        const value2 = {};
+
+        iwm.set(ref, value);
+        iwm.set(ref2, value2);
+
+        expect(iwm.size).toBe(2);
+
+        iwm.clear();
+
+        expect(iwm.size).toBe(0);
+      });
+    });
+
+    describe("#forEach", () => {
+      it("should iterate over all entries in Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+        const value2 = {};
+
+        iwm.set(ref, value);
+        iwm.set(ref2, value2);
+
+        const res: [object, object, IterableWeakMap<any, any>][] = [];
+
+        iwm.forEach((v, k, map) => {
+          res.push([v, k, map]);
+        });
+
+        expect(res).toEqual([
+          [ref, value, iwm],
+          [ref2, value2, iwm],
+        ]);
+      });
+    });
+
+    describe("#keys", () => {
+      it("should return all keys in Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+        const value2 = {};
+
+        iwm.set(ref, value);
+        iwm.set(ref2, value2);
+
+        const res = Array.from(iwm.keys());
+
+        expect(res).toEqual([ref, ref2]);
+      });
+    });
+
+    describe("#valeus", () => {
+      it("should return all values in Map", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+        const value2 = {};
+
+        iwm.set(ref, value);
+        iwm.set(ref2, value2);
+
+        const res = Array.from(iwm.values());
+
+        expect(res).toEqual([value, value2]);
+      });
+    });
+  }
+
+  describe("environment supports WeakRef and FinalizationRegistry", () => {
+    runCommonTests();
+
+    describe("memory", () => {
+      let originalFinalizationRegistry: FinalizationRegistry<any>;
+      let cleanupMemory = (ref: any) => {};
+
+      beforeEach(() => {
+        originalFinalizationRegistry = FinalizationRegistry as any;
+        globalThis.FinalizationRegistry = function (
+          cleanupCb: (heldValue: any) => void
+        ) {
+          const heldValueSet = new Map();
+
+          cleanupMemory = (ref) => {
+            const heldValue = heldValueSet.get(ref);
+
+            cleanupCb(heldValue);
+          };
+
+          return {
+            register(target: object, heldValue: any, unregisterToken?: object) {
+              heldValueSet.set(target, heldValue);
+            },
+            unregister() {},
+          } as unknown as FinalizationRegistry<any>;
+        } as any;
+      });
+
+      afterEach(() => {
+        globalThis.FinalizationRegistry = originalFinalizationRegistry as any;
+      });
+
+      it("should be auto cleaned when ref in Map is freeing in program", function () {
+        const iwm = new IterableWeakMap();
+        const ref = {};
+        const value = {};
+        const ref2 = {};
+        const value2 = {};
+
+        iwm.set(ref, value);
+        iwm.set(ref2, value2);
+
+        expect(iwm.size).toBe(2);
+        expect(Array.from(iwm.entries())).toEqual([
+          [ref, value],
+          [ref2, value2],
+        ]);
+
+        // emulate freeing "ref" in memory
+        cleanupMemory(ref);
+
+        expect(iwm.size).toBe(1);
+        expect(Array.from(iwm.entries())).toEqual([[ref2, value2]]);
+      });
+    });
+  });
+
+  describe("environment doesn't support WeakRef and FinalizationRegistry", () => {
+    let originalWeakRef: WeakRefConstructor | undefined;
+    let originalFinalizationRegistry:
+      | FinalizationRegistryConstructor
+      | undefined;
+
+    beforeAll(() => {
+      originalWeakRef = global.WeakRef;
+      // @ts-ignore
+      delete global.WeakRef;
+      originalFinalizationRegistry = global.FinalizationRegistry;
+      // @ts-ignore
+      delete global.FinalizationRegistry;
+    });
+
+    afterAll(() => {
+      if (originalWeakRef && originalFinalizationRegistry) {
+        global.WeakRef = originalWeakRef;
+        originalWeakRef = undefined;
+
+        global.FinalizationRegistry = originalFinalizationRegistry;
+        originalFinalizationRegistry = undefined;
+      }
+    });
+
+    runCommonTests();
+  });
+});

package/test/appHost.mock.ts

@@ -0,0 +1,58 @@
+import { EntryPoint, SlotKey } from '../src/API'
+
+export const createCircularEntryPoints = (usePublicAPIKeys: boolean = false): EntryPoint[] => {
+    const MockAPI1: SlotKey<{}> = { name: 'Mock-API-1', public: usePublicAPIKeys }
+    const MockAPI2: SlotKey<{}> = { name: 'Mock-API-2', public: usePublicAPIKeys }
+    const MockAPI3: SlotKey<{}> = { name: 'Mock-API-3', public: usePublicAPIKeys }
+    const MockAPI4: SlotKey<{}> = { name: 'Mock-API-4', public: usePublicAPIKeys }
+
+    const ep1Deps = usePublicAPIKeys
+        ? [
+              { name: 'Mock-API-2', public: true },
+              { name: 'Mock-API-3', public: true }
+          ]
+        : [MockAPI2, MockAPI3]
+    const ep2Deps = usePublicAPIKeys ? [{ name: 'Mock-API-4', public: true }] : [MockAPI4]
+    const ep3Deps = usePublicAPIKeys ? [{ name: 'Mock-API-4', public: true }] : [MockAPI4]
+    const ep4Deps = usePublicAPIKeys ? [{ name: 'Mock-API-1', public: true }] : [MockAPI1]
+
+    return [
+        {
+            name: 'MOCK_ENTRY_POINT_1',
+            getDependencyAPIs: () => ep1Deps,
+            declareAPIs: () => [MockAPI1]
+        },
+        {
+            name: 'MOCK_ENTRY_POINT_2',
+            getDependencyAPIs: () => ep2Deps,
+            declareAPIs: () => [MockAPI2]
+        },
+        {
+            name: 'MOCK_ENTRY_POINT_3',
+            getDependencyAPIs: () => ep3Deps,
+            declareAPIs: () => [MockAPI3]
+        },
+        {
+            name: 'MOCK_ENTRY_POINT_4',
+            getDependencyAPIs: () => ep4Deps,
+            declareAPIs: () => [MockAPI4]
+        }
+    ]
+}
+
+export const createDirectCircularEntryPoints = (usePublicAPIKeys: boolean = false): EntryPoint[] => {
+    const MockAPI1: SlotKey<{}> = { name: 'Mock-API-1', public: usePublicAPIKeys }
+    const MockAPI2: SlotKey<{}> = { name: 'Mock-API-2', public: usePublicAPIKeys }
+    return [
+        {
+            name: 'MOCK_ENTRY_POINT_1',
+            getDependencyAPIs: () => [usePublicAPIKeys ? { name: 'Mock-API-2', public: true } : MockAPI2],
+            declareAPIs: () => [MockAPI1]
+        },
+        {
+            name: 'MOCK_ENTRY_POINT_2',
+            getDependencyAPIs: () => [usePublicAPIKeys ? { name: 'Mock-API-1', public: true } : MockAPI1],
+            declareAPIs: () => [MockAPI2]
+        }
+    ]
+}