repluggable-core 1.302.77 → 1.302.79

package/test/extensionSlot.spec.ts

@@ -0,0 +1,176 @@
+import { createAppHost, SlotKey } from '../src'
+import { EntryPoint, ExtensionItem, PrivateAppHost, PrivateExtensionSlot, Shell } from '../src/API'
+import { createExtensionSlot } from '../src/extensionSlot'
+import { addMockShell } from '../testKit'
+import { createSignalItemsDataStructure } from './createSignalItemsDataStructure'
+
+describe('ExtensionSlot', () => {
+    describe('Subscribe', () => {
+        it('should be invoked on contribution', () => {
+            const slotKey: SlotKey<{}> = {
+                name: 'mock_key'
+            }
+            const host = createAppHost([])
+            const shell = addMockShell(host)
+            const spy = jest.fn()
+            const slot = shell.declareSlot(slotKey) as PrivateExtensionSlot<{}>
+
+            slot.subscribe(spy)
+
+            slot.contribute(shell, () => ({}))
+
+            expect(spy).toBeCalledTimes(1)
+
+            slot.contribute(shell, () => ({}))
+
+            expect(spy).toBeCalledTimes(2)
+        })
+        it('should be invoked once when contribution is during installation phase', () => {
+            interface SlotItem {
+                name: string
+            }
+            const slotKey: SlotKey<SlotItem> = {
+                name: 'MOCK_SLOT'
+            }
+            interface MockContributionAPI {
+                contributeItem(fromShell: Shell, item: SlotItem): void
+            }
+
+            const ContributionAPI: SlotKey<MockContributionAPI> = {
+                name: 'CONTRIBUTION_API'
+            }
+
+            const spy = jest.fn()
+
+            const contributionEntryPoint: EntryPoint = {
+                name: 'PRIVATE CONTRIBUTION ENTRY POINT',
+                declareAPIs() {
+                    return [ContributionAPI]
+                },
+                attach(shell) {
+                    const slot = shell.declareSlot(slotKey) as PrivateExtensionSlot<SlotItem>
+                    slot.subscribe(spy)
+                    shell.contributeAPI(ContributionAPI, () => ({
+                        contributeItem(fromShell, item) {
+                            shell.getSlot(slotKey).contribute(fromShell, item)
+                        }
+                    }))
+                }
+            }
+
+            const API_A: SlotKey<{}> = { name: 'API_A' }
+
+            const itemContributionEntryPointA: EntryPoint = {
+                name: 'ITEM CONTRIBUTION ENTRY POINT A',
+                getDependencyAPIs() {
+                    return [ContributionAPI]
+                },
+                declareAPIs(): SlotKey<{}>[] {
+                    return [API_A]
+                },
+                attach(shell: Shell) {
+                    shell.contributeAPI(API_A, () => ({}))
+                },
+                extend(shell: Shell) {
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'A.1' })
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'A.2' })
+                }
+            }
+
+            const itemContributionEntryPointB: EntryPoint = {
+                name: 'ITEM CONTRIBUTION ENTRY POINT B',
+                getDependencyAPIs() {
+                    return [ContributionAPI, API_A]
+                },
+                extend(shell: Shell) {
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'B.1' })
+                    shell.getAPI(ContributionAPI).contributeItem(shell, { name: 'B.2' })
+                }
+            }
+
+            createAppHost([contributionEntryPoint, itemContributionEntryPointA, itemContributionEntryPointB])
+
+            expect(spy).toBeCalledTimes(1)
+        })
+    })
+
+    describe('Custom Items Data Structure with Signals', () => {
+        it('should notify effect when items are added', () => {
+            const slotKey: SlotKey<{ value: string }> = { name: 'signal_slot' }
+            const host = createAppHost([]) as PrivateAppHost
+            const shell = addMockShell(host)
+
+            const { createDataStructure: dataStructure, getSignalToTrack, effect } = createSignalItemsDataStructure()
+            const effectSpy = jest.fn()
+
+            const slot = createExtensionSlot(slotKey, host, {
+                customCreateExtensionSlot: dataStructure
+            })
+
+            effect(() => {
+                getSignalToTrack().get()
+                effectSpy()
+            })
+
+            expect(effectSpy).toHaveBeenCalledTimes(1)
+
+            slot.contribute(shell, { value: 'item1' })
+            expect(effectSpy).toHaveBeenCalledTimes(2)
+
+            slot.contribute(shell, { value: 'item2' })
+            expect(effectSpy).toHaveBeenCalledTimes(3)
+        })
+
+        it('should notify effect when items are filtered/removed', () => {
+            const slotKey: SlotKey<{ id: number }> = { name: 'filter_signal_slot' }
+            const host = createAppHost([]) as PrivateAppHost
+            const shell = addMockShell(host)
+
+            const { createDataStructure: dataStructure, getSignalToTrack, effect } = createSignalItemsDataStructure()
+            const effectSpy = jest.fn()
+
+            const slot = createExtensionSlot(slotKey, host, {
+                customCreateExtensionSlot: dataStructure
+            })
+
+            effect(() => {
+                getSignalToTrack().get()
+                effectSpy()
+            })
+
+            expect(effectSpy).toHaveBeenCalledTimes(1)
+
+            slot.contribute(shell, { id: 1 })
+            slot.contribute(shell, { id: 2 })
+            expect(effectSpy).toHaveBeenCalledTimes(3)
+
+            slot.discardBy((item: ExtensionItem<{ id: number }>) => item.contribution.id === 1)
+            expect(effectSpy).toHaveBeenCalledTimes(4)
+        })
+
+        it('should track signal value correctly', () => {
+            const slotKey: SlotKey<{ name: string }> = { name: 'track_slot' }
+            const host = createAppHost([]) as PrivateAppHost
+            const shell = addMockShell(host)
+
+            const { createDataStructure: dataStructure, getSignalToTrack, effect } = createSignalItemsDataStructure()
+            let capturedItems: ExtensionItem<{ name: string }>[] = []
+
+            const slot = createExtensionSlot(slotKey, host, {
+                customCreateExtensionSlot: dataStructure
+            })
+
+            effect(() => {
+                capturedItems = getSignalToTrack().get()
+            })
+
+            slot.contribute(shell, { name: 'first' })
+            expect(capturedItems).toHaveLength(1)
+            expect(capturedItems[0].contribution.name).toBe('first')
+
+            slot.contribute(shell, { name: 'second' })
+            expect(capturedItems).toHaveLength(2)
+            expect(capturedItems[1].contribution.name).toBe('second')
+        })
+    })
+})

package/testKit/index.ts

@@ -4,13 +4,14 @@ import { AnySlotKey, AppHost, createAppHost as _createAppHost, EntryPointOrPacka
 import { createShellLogger } from '../src/loggers'
 import { emptyLoggerOptions } from './emptyLoggerOptions'
 
-export {createShellLogger}
+export { createShellLogger }
 export { emptyLoggerOptions }
 export { AppHost } from '../src/index'
 
 export { withConsoleErrors } from './withConsoleErrors'
 export { withThrowOnError } from './withThrowOnError'
 export * from './mockPackage'
+export { createSignalItemsDataStructure } from '../test/createSignalItemsDataStructure'
 
 export const createAppHost: typeof _createAppHost = (packages, options = emptyLoggerOptions) => {
     return _createAppHost(packages, options)
@@ -74,7 +75,10 @@ export function createAppHostWithPacts(packages: EntryPointOrPackage[], pacts: P
         }
     }
 
-    return createAppHost([...packages, pactsEntryPoint], { ...emptyLoggerOptions, disableLayersValidation: true })
+    return createAppHost([...packages, pactsEntryPoint], {
+        ...emptyLoggerOptions,
+        disableLayersValidation: true
+    })
 }
 
 export async function createAppHostAndWaitForLoading(packages: EntryPointOrPackage[], pacts: PactAPIBase[]): Promise<AppHost> {
@@ -88,7 +92,7 @@ export async function createAppHostAndWaitForLoading(packages: EntryPointOrPacka
         setTimeout(() => {
             const readyAPIs = Array.from(globalThis.repluggableAppDebug.readyAPIs)
             const unreadyAPIs = declaredAPIs.filter(api => !readyAPIs.some(readyAPI => readyAPI.name === api.name))
-            const rootUnreadyAPI = globalThis.repluggableAppDebug.utils.getRootUnreadyAPI();
+            const rootUnreadyAPI = globalThis.repluggableAppDebug.utils.getRootUnreadyAPI()
 
             reject(
                 new Error(
@@ -118,7 +122,6 @@ in addition here's the full list of declared APIs that have not been contributed
     return Promise.race([timeoutPromise, loadingPromise]).then(() => appHost)
 }
 
-
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 interface EntryPointOverrides extends Omit<EntryPoint, 'name'> {
     name?: EntryPoint['name']
@@ -159,8 +162,6 @@ export const addMockShell = (host: AppHost, entryPointOverrides: EntryPointOverr
     return shell
 }
 
-
-
 export function mockObservable<T>(value: T): ObservableState<T> {
     return {
         subscribe: () => {
@@ -171,4 +172,3 @@ export function mockObservable<T>(value: T): ObservableState<T> {
         }
     }
 }
-