repluggable-core 1.302.76 → 1.302.78

package/src/API.ts

@@ -1,7 +1,7 @@
 import * as Redux from 'redux'
 import { ThrottledStore } from './throttledStore'
 import { INTERNAL_DONT_USE_SHELL_GET_APP_HOST } from './__internal'
-
+import { CustomCreateExtensionSlot } from './extensionSlot'
 
 export interface AnySlotKey {
     readonly name: string
@@ -333,6 +333,12 @@ export interface APILayer {
     name: string
 }
 
+interface AppHostPlugins {
+    extensionSlot?: {
+        customCreateExtensionSlot: CustomCreateExtensionSlot
+    }
+}
+
 export interface AppHostOptions {
     readonly logger?: HostLogger
     readonly monitoring: MonitoringOptions
@@ -343,6 +349,7 @@ export interface AppHostOptions {
     readonly enableReduxDevtoolsExtension?: boolean
     readonly experimentalCyclicMode?: boolean
     readonly shouldScopeReducers?: boolean
+    readonly plugins?: AppHostPlugins
 }
 
 export interface MemoizeMissHit {
@@ -526,9 +533,8 @@ export interface PrivateShell extends Shell {
     setDependencyAPIs(APIs: AnySlotKey[]): void
     setLifecycleState(enableStore: boolean, enableAPIs: boolean, initCompleted: boolean): void
     getBoundaryAspects(): ShellBoundaryAspect[]
-    getHostOptions(): AppHostOptions,
-    readonly [INTERNAL_DONT_USE_SHELL_GET_APP_HOST]: () => AppHost
-  
+    getHostOptions(): AppHostOptions
+    [INTERNAL_DONT_USE_SHELL_GET_APP_HOST](): AppHost
 }
 
 export interface EntryPointsInfo {

package/src/IterableWeakMap.ts

@@ -81,7 +81,7 @@ export class IterableWeakMap<K extends object = object, V = any> implements Map<
 
     forEach(callbackfn: (value: V, key: K, map: this) => void, thisArg?: any): void {
         for (const [key, value] of this) {
-            callbackfn(value, key, this )
+            callbackfn(value, key, this)
         }
     }
 
@@ -107,17 +107,15 @@ export class IterableWeakMap<K extends object = object, V = any> implements Map<
         return this[Symbol.iterator]() as unknown as ReturnType<Map<K, V>['entries']>
     }
 
-    *keys(): ReturnType<Map<K, V>['keys']>  {
+    *keys(): ReturnType<Map<K, V>['keys']> {
         for (const [key] of this) {
             yield key
         }
     }
 
-    *values():  ReturnType<Map<K, V>['values']> {
+    *values(): ReturnType<Map<K, V>['values']> {
         for (const [_, value] of this) {
             yield value
         }
     }
 }
-
-

package/src/__internal.ts

@@ -1,4 +1,4 @@
 /**
  * This symbol is only for internal use of repluggable mono-repo.
  */
-export const INTERNAL_DONT_USE_SHELL_GET_APP_HOST: unique symbol = Symbol.for('SHELL_GET_APP_HOST')
+export const INTERNAL_DONT_USE_SHELL_GET_APP_HOST: unique symbol = Symbol.for('SHELL_GET_APP_HOST')

package/src/appHost.ts

@@ -251,7 +251,10 @@ export function createAppHost(initialEntryPointsOrPackages: EntryPointOrPackage[
         const memoized = _.memoize(func, resolver)
 
         if (options.monitoring.debugMemoization) {
-            Object.defineProperty(memoized, 'name', { value: `${func.name}_memoized`, writable: false })
+            Object.defineProperty(memoized, 'name', {
+                value: `${func.name}_memoized`,
+                writable: false
+            })
         }
 
         if (options.monitoring.disableMonitoring) {
@@ -560,7 +563,12 @@ miss: ${memoizedWithMissHit.miss}
     }
 
     function declareSlot<TItem>(key: SlotKey<TItem>, declaringShell?: Shell): ExtensionSlot<TItem> {
-        const newSlot = registerSlotOrThrow(key, () => createExtensionSlot(key, host, declaringShell))
+        const newSlot = registerSlotOrThrow(key, () =>
+            createExtensionSlot(key, host, {
+                declaringShell,
+                customCreateExtensionSlot: options.plugins?.extensionSlot?.customCreateExtensionSlot
+            })
+        )
         return newSlot
     }
 

package/src/extensionSlot.ts

@@ -21,18 +21,44 @@ const alwaysTrue = () => true
 
 type Unsubscribe = () => void
 
+interface ItemsDataStructure<T> {
+    get(): ExtensionItem<T>[]
+    add(item: ExtensionItem<T>): void
+    discardBy(predicate: (item: ExtensionItem<T>) => boolean): void
+}
+
+const itemsDataStructure = <T>(): ItemsDataStructure<T> => {
+    let items: ExtensionItem<T>[] = []
+    return {
+        get: () => items,
+        add: (item: ExtensionItem<T>) => {
+            items.push(item)
+        },
+        discardBy: (predicate: (item: ExtensionItem<T>) => boolean) => {
+            items = items.filter(predicate)
+        }
+    }
+}
+
+export type CustomCreateExtensionSlot = <T>() => ItemsDataStructure<T>
+
+export interface CreateExtensionSlotOptions {
+    declaringShell?: Shell
+    customCreateExtensionSlot?: CustomCreateExtensionSlot
+}
+
 export function createExtensionSlot<T>(
     key: SlotKey<T>,
     host: PrivateAppHost,
-    declaringShell?: Shell
+    options?: CreateExtensionSlotOptions
 ): PrivateExtensionSlot<T> & AnyExtensionSlot {
-    let items: ExtensionItem<T>[] = []
+    const items = options?.customCreateExtensionSlot ? options.customCreateExtensionSlot<T>() : itemsDataStructure<T>()
     let subscribers: (() => void)[] = []
     const slotUniqueId = _.uniqueId()
 
     return {
         host,
-        declaringShell,
+        declaringShell: options?.declaringShell,
         name: key.name,
         contribute,
         getItems,
@@ -43,7 +69,7 @@ export function createExtensionSlot<T>(
     }
 
     function contribute(fromShell: Shell, item: T, condition?: ContributionPredicate): void {
-        items.push({
+        items.add({
             shell: fromShell,
             contribution: item,
             condition: condition || alwaysTrue,
@@ -53,21 +79,21 @@ export function createExtensionSlot<T>(
     }
 
     function getItems(forceAll: boolean = false): ExtensionItem<T>[] {
-        return forceAll ? items : items.filter(item => item.condition())
+        return forceAll ? items.get() : items.get().filter(item => item.condition())
     }
 
     function getSingleItem(): ExtensionItem<T> | undefined {
-        return items.find(item => item.condition())
+        return items.get().find(item => item.condition())
     }
 
     function getItemByName(name: string): ExtensionItem<T> | undefined {
-        return items.find(item => item.name === name && item.condition())
+        return items.get().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) {
+        const originalContributionCount = items.get().length
+        items.discardBy(v => !predicate(v))
+        if (items.get().length !== originalContributionCount) {
             subscribers.forEach(func => func())
         }
     }

package/src/index.ts

@@ -26,13 +26,11 @@ export {
     ScopedStore
 } from './API'
 
-
-
 export { ConsoleHostLogger } from './loggers'
 
 export { createAppHost, makeLazyEntryPoint, mainViewSlotKey, stateSlotKey } from './appHost'
 
-export {AppHostServicesProvider} from './appHostServices'
+export { AppHostServicesProvider } from './appHostServices'
 
 export { InstalledShellsSelectors, ShellToggleSet } from './installedShellsState'
 
@@ -42,5 +40,4 @@ export { interceptAnyObject } from './interceptAnyObject'
 export { monitorAPI } from './monitorAPI'
 export { hot } from './hot'
 
-
-export {INTERNAL_DONT_USE_SHELL_GET_APP_HOST} from './__internal'
+export { INTERNAL_DONT_USE_SHELL_GET_APP_HOST } from './__internal'

package/src/throttledStore.ts

@@ -16,18 +16,17 @@ interface AnyShellAction extends AnyAction {
     __shellName?: string
 }
 
-
-function createTimeOutPublisher ( notify: () => void)  {
-    let id : undefined | NodeJS.Timeout =  undefined 
+function createTimeOutPublisher(notify: () => void) {
+    let id: undefined | NodeJS.Timeout = undefined
     return () => {
         if (id === undefined) {
             id = setTimeout(() => {
                 id = undefined
                 notify()
-            },0)
+            }, 0)
         }
         return () => {
-            if(id === undefined) {
+            if (id === undefined) {
                 return
             }
             clearTimeout(id)
@@ -36,8 +35,8 @@ function createTimeOutPublisher ( notify: () => void)  {
     }
 }
 
-function createAnimationFramePublisher ( notify: () => void)  {
-    let id : undefined | number =  undefined 
+function createAnimationFramePublisher(notify: () => void) {
+    let id: undefined | number = undefined
     return () => {
         if (id === undefined) {
             id = requestAnimationFrame(() => {
@@ -46,7 +45,7 @@ function createAnimationFramePublisher ( notify: () => void)  {
             })
         }
         return () => {
-            if(id === undefined) {
+            if (id === undefined) {
                 return
             }
             cancelAnimationFrame(id)
@@ -55,9 +54,6 @@ function createAnimationFramePublisher ( notify: () => void)  {
     }
 }
 
-
-
-
 type Subscriber = () => void
 
 export interface StateContribution<TState = {}, TAction extends AnyAction = AnyAction> {
@@ -252,10 +248,8 @@ export const createThrottledStore = (
         notifyAll()
     }
 
-
-   
-
-    const notifyAllOnPublish = typeof window === 'undefined' ? createTimeOutPublisher(scheduledNotifyAll) : createAnimationFramePublisher(scheduledNotifyAll)
+    const notifyAllOnPublish =
+        typeof window === 'undefined' ? createTimeOutPublisher(scheduledNotifyAll) : createAnimationFramePublisher(scheduledNotifyAll)
 
     let cancelRender = _.noop
 

package/test/appHost.spec.ts

@@ -32,6 +32,7 @@ import {
 import { AppHostAPI, AppHostServicesEntryPointName, AppHostServicesProvider } from '../src/appHostServices'
 import { ConsoleHostLogger } from '../src/loggers'
 import { createCircularEntryPoints, createDirectCircularEntryPoints } from './appHost.mock'
+import { createSignalItemsDataStructure } from './createSignalItemsDataStructure'
 
 const testHostOptions: AppHostOptions = {
     monitoring: { disableMonitoring: true }
@@ -1792,4 +1793,92 @@ If the API is intended to be public, it should be declared as "public: true" in
             )
         })
     })
+
+    describe('Custom Items Data Structure via AppHost Options (plugins)', () => {
+        it('should use customCreateExtensionSlot from appHostOptions when contributing and removing items', async () => {
+            interface SlotItem {
+                value: string
+            }
+            const slotKey: SlotKey<SlotItem> = { name: 'host_options_signal_slot' }
+
+            interface SlotContributionAPI {
+                contributeItem(fromShell: Shell, item: SlotItem): void
+                getItems(): SlotItem[]
+            }
+            const SlotContributionAPIKey: SlotKey<SlotContributionAPI> = {
+                name: 'SLOT_CONTRIBUTION_API'
+            }
+
+            const itemsSpy = jest.fn()
+
+            const { createDataStructure, effect } = createSignalItemsDataStructure()
+
+            const slotOwnerEntryPoint: EntryPoint = {
+                name: 'SLOT_OWNER_ENTRY_POINT',
+                declareAPIs() {
+                    return [SlotContributionAPIKey]
+                },
+                attach(shell: Shell) {
+                    const slot = shell.declareSlot(slotKey)
+                    shell.contributeAPI(SlotContributionAPIKey, () => ({
+                        contributeItem(fromShell: Shell, item: SlotItem) {
+                            slot.contribute(fromShell, item)
+                        },
+                        getItems() {
+                            return slot.getItems().map(item => item.contribution)
+                        }
+                    }))
+                }
+            }
+
+            const ContributorEntryPoint: EntryPoint = {
+                name: 'CONTRIBUTOR_ENTRY_POINT',
+                getDependencyAPIs() {
+                    return [SlotContributionAPIKey, ListenerAPI]
+                },
+                extend(shell: Shell) {
+                    const api = shell.getAPI(SlotContributionAPIKey)
+                    api.contributeItem(shell, { value: 'item1' })
+                    api.contributeItem(shell, { value: 'item2' })
+                }
+            }
+
+            const ListenerAPI: SlotKey<{}> = { name: 'LISTENER_API' }
+
+            const ListenerEntryPoint: EntryPoint = {
+                name: 'LISTENER_ENTRY_POINT',
+                declareAPIs() {
+                    return [ListenerAPI]
+                },
+                getDependencyAPIs() {
+                    return [SlotContributionAPIKey]
+                },
+                // move to attach to make sure
+                attach(shell: Shell) {
+                    const slotContributionAPI = shell.getAPI(SlotContributionAPIKey)
+                    effect(() => {
+                        slotContributionAPI.getItems()
+                        itemsSpy()
+                    })
+                    // contribute an api to make sure that the contribution depends on it and happens after.
+                    shell.contributeAPI(ListenerAPI, () => ({}))
+                }
+            }
+
+            const host = createAppHost([slotOwnerEntryPoint, ContributorEntryPoint, ListenerEntryPoint], {
+                monitoring: {},
+                plugins: {
+                    extensionSlot: {
+                        customCreateExtensionSlot: createDataStructure
+                    }
+                }
+            })
+
+            // first was created and then two time
+            expect(itemsSpy).toBeCalledTimes(3)
+
+            await host.removeShells([ContributorEntryPoint.name])
+            expect(itemsSpy).toBeCalledTimes(4)
+        })
+    })
 })

package/test/createSignalItemsDataStructure.ts

@@ -0,0 +1,65 @@
+import { ExtensionItem } from '../src/API'
+
+// Naive signals implementation
+interface Signal<T> {
+    get(): T
+    set(value: T): void
+}
+
+let currentEffect: (() => void) | null = null
+
+const signal = <T>(initialValue: T): Signal<T> => {
+    let value = initialValue
+    const subscribers = new Set<() => void>()
+
+    return {
+        get: () => {
+            if (currentEffect) {
+                subscribers.add(currentEffect)
+            }
+            return value
+        },
+        set: (newValue: T) => {
+            value = newValue
+            subscribers.forEach(fn => fn())
+        }
+    }
+}
+
+const effect = (fn: () => void): (() => void) => {
+    const execute = () => {
+        currentEffect = execute
+        fn()
+        currentEffect = null
+    }
+    execute()
+    return () => {
+        currentEffect = null
+    }
+}
+
+export const createSignalItemsDataStructure = () => {
+    let signalToTrack: Signal<ExtensionItem<any>[]> | null = null
+    return {
+        createDataStructure: <U>() => {
+            const itemsSignal = signal<ExtensionItem<U>[]>([])
+            signalToTrack = itemsSignal
+            return {
+                get: () => itemsSignal.get(),
+                add: (item: ExtensionItem<U>) => {
+                    itemsSignal.set([...itemsSignal.get(), item])
+                },
+                discardBy: (predicate: (item: ExtensionItem<U>) => boolean) => {
+                    itemsSignal.set(itemsSignal.get().filter(predicate))
+                }
+            }
+        },
+        getSignalToTrack: () => {
+            if (!signalToTrack) {
+                throw new Error('Signal to track is not set')
+            }
+            return signalToTrack
+        },
+        effect
+    }
+}

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> {
         }
     }
 }
-