@journeyapps-labs/reactor-mod 1.0.0

package/dist/@types/preferences/DateFormatPreference.d.ts

@@ -0,0 +1,14 @@
+import { SetSetting } from '../settings/SetSetting';
+import { ReactorDateFormats } from '@journeyapps-labs/lib-reactor-utils';
+export declare const REACTOR_DATE_FORMAT_LABELS: {
+    local: string;
+    simple: string;
+    iso: string;
+};
+export declare class DateFormatPreference extends SetSetting {
+    static KEY: string;
+    constructor();
+    get asLabel(): any;
+    get asFormat(): ReactorDateFormats;
+    static get(): DateFormatPreference;
+}

package/dist/@types/preferences/DateLocalSetting.d.ts

@@ -0,0 +1,6 @@
+import { BooleanSetting } from '../settings/BooleanSetting';
+export declare class DateLocalSetting extends BooleanSetting {
+    static KEY: string;
+    constructor();
+    static get(): DateLocalSetting;
+}

package/dist/@types/preferences/DateShowZoneSetting.d.ts

@@ -0,0 +1,6 @@
+import { BooleanSetting } from '../settings/BooleanSetting';
+export declare class DateShowZoneSetting extends BooleanSetting {
+    static KEY: string;
+    constructor();
+    static get(): DateShowZoneSetting;
+}

package/dist/@types/preferences/LargerCMDPalletSetting.d.ts

@@ -0,0 +1,6 @@
+import { BooleanSetting } from '../settings/BooleanSetting';
+export declare class LargerCMDPalletSetting extends BooleanSetting {
+    static KEY: string;
+    constructor();
+    static get(): LargerCMDPalletSetting;
+}

package/dist/@types/preferences/ShowChangelogSetting.d.ts

@@ -0,0 +1,7 @@
+import { BooleanSetting } from '../settings/BooleanSetting';
+export declare class ShowChangelogSetting extends BooleanSetting {
+    static KEY: string;
+    constructor();
+    static enabled(): boolean;
+    static get(): ShowChangelogSetting;
+}

package/dist/@types/providers/Provider.d.ts

@@ -0,0 +1,51 @@
+import { ProviderSearchResult, ProviderSearchResultEntity, ProviderSearchResultSerialized } from './ProviderSearchResult';
+import { ReactorIcon } from '../widgets/icons/IconWidget';
+import { ProviderComboBoxOptions } from '../stores/combo/ComboBoxStore';
+import { System } from '../core/System';
+import { MousePosition } from '../layers/combo/SmartPositionWidget';
+import { SearchEngineInterface, SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface ProviderOptions {
+    displayName: string;
+    icon: ReactorIcon;
+    type: string;
+    cmdPallet?: boolean;
+    parentProvider?: string;
+}
+export interface SerializedEntity {
+    type: string;
+    display: string;
+    color?: string;
+    colorLight?: string;
+    icon?: ReactorIcon;
+}
+export interface ProviderSearchEvent<PARENT_ENTITY = any> extends SearchEvent {
+    param?: PARENT_ENTITY;
+}
+/**
+ * @deprecated
+ */
+export declare abstract class Provider<ENTITY = any, SERIALIZED extends SerializedEntity = SerializedEntity> implements SearchEngineInterface<ProviderSearchResultEntity<ENTITY>> {
+    options: ProviderOptions;
+    system: System;
+    constructor(options: ProviderOptions);
+    setApplication(system: System): void;
+    /**
+     * Given a serialized entity, get an icon representation.
+     */
+    getIcon(entity: SERIALIZED): ReactorIcon;
+    /**
+     * Takes in a serialized entity and decoded it back into its original form (and actual pointer reference)
+     */
+    abstract deserialize(entity: SERIALIZED): Promise<ENTITY>;
+    /**
+     * Takes in an entity and encodes it so it can be used for drag an drop,
+     * and actions when they are sent through IPC systems
+     */
+    serialize(entity: ENTITY): SERIALIZED;
+    selectEntity(options: {
+        event: MousePosition;
+    } & ProviderComboBoxOptions<ENTITY>): Promise<ENTITY | null>;
+    doSearchSerialized(event: ProviderSearchEvent): ProviderSearchResult<ProviderSearchResultSerialized<ENTITY, SERIALIZED>>;
+    openEntity(entity: ENTITY): void;
+    abstract doSearch(event: ProviderSearchEvent): ProviderSearchResult<ProviderSearchResultEntity<ENTITY>>;
+}

package/dist/@types/providers/ProviderSearchResult.d.ts

@@ -0,0 +1,13 @@
+import { SearchResult, SearchResultEntry } from '@journeyapps-labs/lib-reactor-search';
+import { SerializedEntity } from './Provider';
+export interface ProviderSearchResultEntity<ENTITY = any> extends SearchResultEntry {
+    entity: ENTITY;
+}
+export interface ProviderSearchResultSerialized<ENTITY = any, SERIALIZED extends SerializedEntity = SerializedEntity> extends ProviderSearchResultEntity<ENTITY> {
+    serialized: SERIALIZED;
+}
+export declare class ProviderSearchResult<T extends ProviderSearchResultEntity = ProviderSearchResultEntity> extends SearchResult<T> {
+    accessor footerHint: string;
+    constructor();
+    setFooterHint(hint: string): void;
+}

package/dist/@types/providers/SimpleProvider.d.ts

@@ -0,0 +1,9 @@
+import { Provider, SerializedEntity, ProviderSearchEvent } from './Provider';
+import { ProviderSearchResult, ProviderSearchResultEntity } from './ProviderSearchResult';
+/**
+ * @deprecated
+ */
+export declare abstract class SimpleProvider<ENTITY = any, SERIALIZED extends SerializedEntity = SerializedEntity> extends Provider<ENTITY, SERIALIZED> {
+    abstract getEntities(event: ProviderSearchEvent): Promise<ENTITY[]>;
+    doSearch(event: ProviderSearchEvent): ProviderSearchResult<ProviderSearchResultEntity<ENTITY>>;
+}

package/dist/@types/providers/ThemeProvider.d.ts

@@ -0,0 +1,16 @@
+import { SimpleProvider } from './SimpleProvider';
+import { SerializedEntity } from './Provider';
+import { Theme } from '../stores/themes/ThemeStore';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+import { ProviderSearchResult, ProviderSearchResultEntity } from './ProviderSearchResult';
+export interface SerializedTheme extends SerializedEntity {
+    key: string;
+}
+export declare class ThemeProvider extends SimpleProvider<Theme, SerializedTheme> {
+    constructor();
+    deserialize(entity: SerializedTheme): Promise<Theme>;
+    serialize(entity: Theme): SerializedTheme;
+    getEntities(event: SearchEvent): Promise<Theme[]>;
+    doSearch(event: SearchEvent): ProviderSearchResult<ProviderSearchResultEntity<Theme>>;
+    openEntity(entity: Theme): void;
+}

package/dist/@types/providers/WorkspaceProvider.d.ts

@@ -0,0 +1,16 @@
+import { SimpleProvider } from './SimpleProvider';
+import { SerializedEntity } from './Provider';
+import { IDEWorkspace, WorkspaceStore } from '../stores/workspace/WorkspaceStore';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+export interface WorkspaceNodeModelSerialized extends SerializedEntity {
+    id: string;
+}
+export declare class WorkspaceProvider extends SimpleProvider<IDEWorkspace, WorkspaceNodeModelSerialized> {
+    accessor workspaceStore: WorkspaceStore;
+    static NAME: string;
+    constructor();
+    deserialize(entity: WorkspaceNodeModelSerialized): Promise<IDEWorkspace>;
+    serialize(entity: IDEWorkspace): WorkspaceNodeModelSerialized;
+    getEntities(search: SearchEvent): Promise<IDEWorkspace[]>;
+    openEntity(entity: IDEWorkspace): void;
+}

package/dist/@types/providers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Provider';
+export * from './SimpleProvider';
+export * from './ProviderSearchResult';
+export * from './WorkspaceProvider';

package/dist/@types/search/SearchEngine.d.ts

@@ -0,0 +1,12 @@
+import { SearchResult } from '@journeyapps-labs/lib-reactor-search';
+import { SearchEngineParameter } from './params/SearchEngineParameter';
+export interface SearchEngineSearchEvent<T extends object = {}> {
+    value: string;
+    parameters?: T;
+}
+export declare abstract class SearchEngine<T extends SearchResult = SearchResult> {
+    parameters: Set<SearchEngineParameter>;
+    constructor();
+    addParameter(param: SearchEngineParameter): void;
+    abstract search(event: SearchEngineSearchEvent): T;
+}

package/dist/@types/search/params/EntitySearchEngineParameter.d.ts

@@ -0,0 +1,6 @@
+import { SearchEngineParameter, SearchEngineParameterOptions } from './SearchEngineParameter';
+export interface EntitySearchEngineParameterOptions extends SearchEngineParameterOptions {
+    entityType: string;
+}
+export declare class EntitySearchEngineParameter extends SearchEngineParameter<EntitySearchEngineParameterOptions> {
+}

package/dist/@types/search/params/SearchEngineParameter.d.ts

@@ -0,0 +1,9 @@
+export interface SearchEngineParameterOptions {
+    required?: boolean;
+    label: string;
+    key: string;
+}
+export declare class SearchEngineParameter<T extends SearchEngineParameterOptions = SearchEngineParameterOptions> {
+    options: T;
+    constructor(options: T);
+}

package/dist/@types/search/search-engine-trees.d.ts

@@ -0,0 +1,8 @@
+import { ReactorTreeLeaf, ReactorTreeNode } from '../widgets';
+import { SearchResult, SearchResultEntry } from '@journeyapps-labs/lib-reactor-search';
+export interface SetupNodeOptions<T extends SearchResultEntry> {
+    result: SearchResult<T>;
+    node: ReactorTreeNode;
+    getTreeEntity: (entity: T) => ReactorTreeLeaf | ReactorTreeNode;
+}
+export declare const setupNode: <T extends SearchResultEntry>(options: SetupNodeOptions<T>) => void;

package/dist/@types/search/widgets/SearchEngineFieldWidget.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { SearchEngine } from '../SearchEngine';
+import { SearchResult } from '@journeyapps-labs/lib-reactor-search';
+export interface SearchEngineFieldWidgetProps {
+    engine: SearchEngine;
+    gotSearchResult: (result: SearchResult | null) => any;
+    focusOnMount?: boolean;
+    className?: any;
+    parameters?: object;
+}
+export declare const SearchEngineFieldWidget: React.FC<SearchEngineFieldWidgetProps>;

package/dist/@types/search/widgets/useSearchEngine.d.ts

@@ -0,0 +1,8 @@
+import { SearchEngine } from '../SearchEngine';
+import { SearchResult } from '@journeyapps-labs/lib-reactor-search';
+export interface UseSearchEngineProps {
+    searchEngine: SearchEngine;
+    searchText: string;
+    parameters: object;
+}
+export declare const useSearchEngine: (props: UseSearchEngineProps) => SearchResult<import("@journeyapps-labs/lib-reactor-search").SearchResultEntry>;

package/dist/@types/settings/AbstractInteractiveSetting.d.ts

@@ -0,0 +1,12 @@
+import { AbstractSetting, AbstractSettingOptions } from './AbstractSetting';
+export interface AbstractInteractiveControlOptions extends AbstractSettingOptions {
+    name?: string;
+    description?: string;
+    category?: string;
+}
+/**
+ * @deprecated
+ */
+export declare abstract class AbstractInteractiveSetting<T extends AbstractInteractiveControlOptions = AbstractInteractiveControlOptions> extends AbstractSetting<T> {
+    abstract generateControl(): React.JSX.Element;
+}

package/dist/@types/settings/AbstractSetting.d.ts

@@ -0,0 +1,32 @@
+import { BaseListener, BaseObserver, Logger } from '@journeyapps-labs/lib-reactor-utils';
+export interface AbstractSettingOptions {
+    key: string;
+    /**
+     * used for busting the serialization if we have made fundamental changes
+     * that are not backwards compatible
+     */
+    serializeID?: string;
+}
+export interface AbstractSettingListener extends BaseListener {
+    updated(): any;
+}
+export declare abstract class AbstractSetting<T extends AbstractSettingOptions = AbstractSettingOptions> extends BaseObserver<AbstractSettingListener> {
+    options: T;
+    accessor initialized: boolean;
+    logger: Logger;
+    deserialized: boolean;
+    private promiseResolvers;
+    constructor(options: T);
+    updateOptions(options: Partial<T>): void;
+    save(): void;
+    init(): Promise<void>;
+    waitForReady(): Promise<this>;
+    doSerialize(): any;
+    /**
+     * FYI: This is called after init()
+     */
+    doDeserialize(data: ReturnType<this['doSerialize']>): void;
+    abstract reset(): any;
+    protected abstract serialize(): any;
+    protected abstract deserialize(data: any): any;
+}

package/dist/@types/settings/AbstractUserSetting.d.ts

@@ -0,0 +1,7 @@
+import { AbstractInteractiveControlOptions, AbstractInteractiveSetting } from './AbstractInteractiveSetting';
+import { AbstractValueControl } from '../controls/AbstractValueControl';
+export declare abstract class AbstractUserSetting<V extends AbstractValueControl = AbstractValueControl, T extends AbstractInteractiveControlOptions = AbstractInteractiveControlOptions> extends AbstractInteractiveSetting<T> {
+    protected control: V;
+    constructor(options: T, control: V);
+    generateControl(): React.JSX.Element;
+}

package/dist/@types/settings/BooleanSetting.d.ts

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import { AbstractInteractiveControlOptions } from './AbstractInteractiveSetting';
+import { ThemeStore } from '../stores/themes/ThemeStore';
+import { AbstractUserSetting } from './AbstractUserSetting';
+import { BooleanControl } from '../controls/BooleanControl';
+export interface BooleanControlOptions extends AbstractInteractiveControlOptions {
+    checked: boolean;
+    changed?: (checked: boolean) => any;
+}
+export declare class BooleanSetting extends AbstractUserSetting<BooleanControl, BooleanControlOptions> {
+    default: boolean;
+    accessor checked: boolean;
+    accessor themeStore: ThemeStore;
+    constructor(options: BooleanControlOptions);
+    setDefault(checked: boolean): void;
+    setChecked(checked: boolean): void;
+    reset(): void;
+    serialize(): {
+        checked: boolean;
+    };
+    deserialize(data: any): void;
+    renderAsCheckbox(label?: string): React.JSX.Element;
+    renderAsToggle(): React.JSX.Element;
+    generateControl(): React.JSX.Element;
+    toggle(): void;
+}

package/dist/@types/settings/EntitySetting.d.ts

@@ -0,0 +1,20 @@
+import { AbstractInteractiveControlOptions } from './AbstractInteractiveSetting';
+import { System } from '../core/System';
+import { AbstractUserSetting } from './AbstractUserSetting';
+import { EntityControl } from '../controls/EntityControl';
+export interface EntitySettingOptions<I> extends AbstractInteractiveControlOptions {
+    type: string;
+    defaultEntity: I;
+    changed?: (item: I) => any;
+}
+export declare class EntitySetting<I> extends AbstractUserSetting<EntityControl<I>, EntitySettingOptions<I>> {
+    accessor entity: I;
+    accessor system: System;
+    constructor(options: EntitySettingOptions<I>);
+    setItem(item: I): void;
+    deserialize(data: ReturnType<this['serialize']>): Promise<void>;
+    reset(): void;
+    serialize(): {
+        entity: import("..").EncodedEntity<{}>;
+    };
+}

package/dist/@types/settings/ProviderControl.d.ts

@@ -0,0 +1,25 @@
+import * as React from 'react';
+import { AbstractInteractiveSetting, AbstractInteractiveControlOptions } from './AbstractInteractiveSetting';
+import { Provider } from '../providers/Provider';
+export interface ProviderControlOptions<I> extends AbstractInteractiveControlOptions {
+    provider: Provider<I>;
+    defaultEntity: I;
+    changed?: (item: I) => any;
+}
+/**
+ * @deprecated use EntitySetting instead
+ */
+export declare class ProviderControl<I> extends AbstractInteractiveSetting<ProviderControlOptions<I>> {
+    accessor entity: I;
+    constructor(options: ProviderControlOptions<I>);
+    setItem(item: I): void;
+    init(): Promise<void>;
+    getComboBoxItems(): any[];
+    deserialize(data: ReturnType<this['serialize']>): Promise<void>;
+    generateControl(): React.JSX.Element;
+    reset(): void;
+    serialize(): {
+        entity: import("../providers/Provider").SerializedEntity;
+    };
+    toggle(): void;
+}

package/dist/@types/settings/SetSetting.d.ts

@@ -0,0 +1,19 @@
+import { SetControl, SetControlOption } from '../controls/SetControl';
+import { MousePosition } from '../widgets';
+import { AbstractInteractiveControlOptions } from './AbstractInteractiveSetting';
+import { AbstractUserSetting } from './AbstractUserSetting';
+export interface SetSettingOptions extends AbstractInteractiveControlOptions {
+    options: SetControlOption<string>[];
+    value: string;
+}
+export declare class SetSetting extends AbstractUserSetting<SetControl, SetSettingOptions> {
+    default: string;
+    constructor(options: SetSettingOptions);
+    showSelector(event: MousePosition): void;
+    get value(): string;
+    protected deserialize(data: any): void;
+    protected serialize(): {
+        value: string;
+    };
+    reset(): void;
+}

package/dist/@types/settings/ToolbarPreference.d.ts

@@ -0,0 +1,20 @@
+import { AbstractSetting } from './AbstractSetting';
+import { EncodedEntity } from '../entities/components/encoder/EntityEncoderComponent';
+export declare enum ToolbarPosition {
+    HEADER_RIGHT = "/toolbars/header-right/items",
+    LEFT = "/toolbars/left/items",
+    RIGHT = "/toolbars/right/items"
+}
+export declare class ToolbarPreference extends AbstractSetting {
+    accessor items: Set<EncodedEntity>;
+    defaults: EncodedEntity[];
+    constructor(key: ToolbarPosition, defaults?: EncodedEntity[]);
+    get buttons(): EncodedEntity[];
+    addButton(item: EncodedEntity): void;
+    removeButton(item: EncodedEntity): void;
+    reset(): void;
+    serialize(): {
+        items: EncodedEntity<{}>[];
+    };
+    deserialize(data: ReturnType<this['serialize']>): void;
+}

package/dist/@types/settings/VisorMetadataControl.d.ts

@@ -0,0 +1,17 @@
+import { AbstractSetting } from './AbstractSetting';
+import { VisorStore } from '../stores/visor/VisorStore';
+import { VisorMetadata } from '../stores/visor/VisorMetadata';
+export declare class VisorMetadataControl extends AbstractSetting {
+    accessor items: Set<string>;
+    accessor visorStore: VisorStore;
+    static KEY: string;
+    constructor();
+    getItems(): VisorMetadata[];
+    setItems(items: VisorMetadata[]): void;
+    reset(): void;
+    serialize(): {
+        items: string[];
+    };
+    deserialize(data: any): void;
+    static get(): VisorMetadataControl;
+}

package/dist/@types/setup/setup-preferences.d.ts

@@ -0,0 +1,5 @@
+export declare enum CorePreferences {
+    LEFT_TOOLBAR = "/toolbars/left",
+    RIGHT_TOOLBAR = "/toolbars/right"
+}
+export declare const setupPrefs: () => void;

package/dist/@types/stores/AbstractStore.d.ts

@@ -0,0 +1,30 @@
+import { BaseListener, BaseObserver, Logger } from '@journeyapps-labs/lib-reactor-utils';
+import { AbstractSerializer } from './serializers/AbstractSerializer';
+import { AbstractSetting } from '../settings/AbstractSetting';
+export interface AbstractStoreOptions<T> {
+    name: string;
+    serializer?: AbstractSerializer<T>;
+    listenToExternalChanges?: boolean;
+}
+export interface AbstractStoreListener extends BaseListener {
+    initialized: () => any;
+}
+export declare class AbstractStore<T = any, L extends AbstractStoreListener = AbstractStoreListener> extends BaseObserver<L> {
+    protected options: AbstractStoreOptions<T>;
+    private serializationListener;
+    private _controls;
+    protected logger: Logger;
+    accessor initialized: boolean;
+    constructor(options: AbstractStoreOptions<T>);
+    private bootstrapSerializer;
+    protected serialize(): T;
+    protected deserialize(data: T): void;
+    private runDeserialization;
+    waitForReady(): Promise<void>;
+    protected _init(): Promise<void>;
+    init(): Promise<boolean>;
+    protected addControl<T extends AbstractSetting>(control: T): T;
+    getControls(): AbstractSetting[];
+    updateOptions(options: Omit<AbstractStoreOptions<T>, 'name'>): void;
+    save(): Promise<void>;
+}

package/dist/@types/stores/CMDPalletStore.d.ts

@@ -0,0 +1,36 @@
+import { CMDPalletSearchEngine } from '../cmd-pallet/CMDPalletSearchEngine';
+import { Action, ActionEvent } from '../actions/Action';
+import { System } from '../core/System';
+import { ShortcutChord } from './shortcuts/Shortcut';
+export interface CMDPalletSearchEngineCategory {
+    engines: CMDPalletSearchEngine[];
+    name: string;
+    hotkeys: ShortcutChord[];
+}
+export declare class OpenCMDPalletAction extends Action {
+    store: CMDPalletStore;
+    category: CMDPalletSearchEngineCategory;
+    constructor(category: CMDPalletSearchEngineCategory, store: CMDPalletStore);
+    protected fireEvent(event: ActionEvent): Promise<any>;
+}
+/**
+ * Store for working with and managing the command palette
+ */
+export declare class CMDPalletStore {
+    protected categories: {
+        [key: string]: CMDPalletSearchEngineCategory;
+    };
+    accessor show: string;
+    static EVERYTHING: string;
+    accessor system: System;
+    constructor();
+    getDefaultCategory(): CMDPalletSearchEngineCategory;
+    getCategories(): CMDPalletSearchEngineCategory[];
+    getSearchEngines(category: string): CMDPalletSearchEngine[];
+    showPallet(show?: boolean): void;
+    showPalletCategory(show: string): void;
+    registerSearchEngine(engine: CMDPalletSearchEngine): void;
+    registerCategory(category: CMDPalletSearchEngineCategory): void;
+    generateActions(): Action[];
+    init(): void;
+}

package/dist/@types/stores/DialogStore.d.ts

@@ -0,0 +1,114 @@
+import { Btn } from '../definitions/common';
+import { ComboBoxItem } from './combo/ComboBoxDirectives';
+import { BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+import { FormModel } from '../forms';
+import { InputDialogType } from '../layers/dialog/InputDialogWidget';
+import * as React from 'react';
+export declare enum DialogType {
+    MESSAGE = "message",
+    ERROR = "error",
+    INPUT = "input",
+    CONFIRM = "confirm",
+    CUSTOM = "custom"
+}
+export interface DialogDirective {
+    id: string;
+    type: DialogType;
+    title: string;
+    message?: string;
+    markdown?: string;
+    disableDescriptionOpacity?: boolean;
+    /**
+     * Prevent dismissing dialog by clicking on the backdrop.
+     */
+    preventDismiss?: boolean;
+    menuItems?: ComboBoxItem[];
+    menuItemSelected?: (selected: ComboBoxItem) => any;
+    resolve: (val?: any) => any;
+}
+export interface InputDialogDirective extends DialogDirective {
+    value: string;
+    extraTopContent?: () => React.JSX.Element;
+    transformer?: (value: string) => string;
+    validator?: (value: string) => boolean;
+    submitBtn?: Partial<Btn>;
+    cancelBtn?: Partial<Btn>;
+    validationMessage?: string;
+    fieldType?: InputDialogType;
+}
+export interface ConfirmDialogDirective extends DialogDirective {
+    yesBtn?: Partial<Btn>;
+    noBtn?: Partial<Btn>;
+}
+export declare enum DialogButtonStyle {
+    MICRO = "micro",
+    PANEL = "panel"
+}
+export interface CustomDialogDirective extends DialogDirective {
+    btns: Omit<Btn, 'action'>[];
+    buttonStyle?: DialogButtonStyle;
+    generateUI: (options: CustomDialogOptionsEvent) => React.JSX.Element;
+}
+export type CommonDialogOptions = Omit<DialogDirective, 'type' | 'id' | 'resolve'>;
+export interface MessageDialogOptions extends CommonDialogOptions {
+}
+export interface InputDialogOptions extends CommonDialogOptions {
+    extraTopContent?: () => React.JSX.Element;
+    transformer?: (value: string) => string;
+    validator?: (value: string) => boolean;
+    initialValue?: string;
+    submitBtn?: Partial<Btn>;
+    cancelBtn?: Partial<Btn>;
+    validationMessage?: string;
+    fieldType?: InputDialogType;
+}
+export interface ConfirmDialogOptions extends MessageDialogOptions {
+    yesBtn?: Partial<Btn>;
+    noBtn?: Partial<Btn>;
+}
+export type ListenerCallback = (btn: Btn) => Promise<boolean>;
+export interface CustomDialogOptionsEvent {
+    registerListener: (cb: ListenerCallback, id?: string) => any;
+    close: () => void;
+}
+export interface CustomDialogOptions extends CommonDialogOptions {
+    btns?: Omit<Btn, 'action'>[];
+    buttonStyle?: DialogButtonStyle;
+    generateUI: (options: CustomDialogOptionsEvent) => React.JSX.Element;
+    preventDismiss?: boolean;
+}
+export interface NotificationDialogHandler {
+    close: () => any;
+}
+export interface DialogHideEvent {
+    directive: DialogDirective;
+    btn?: Btn;
+    preventDefault?: () => any;
+    val?: any;
+}
+export interface DialogListener {
+    dialogWillHide: (event: DialogHideEvent) => any;
+}
+export declare class DialogStore extends BaseObserver<DialogListener> {
+    accessor directives: DialogDirective[];
+    constructor();
+    closeDialog(directive: DialogDirective, val?: any, btn?: Btn): void;
+    showFormDialog<T extends FormModel>(options: {
+        model: T;
+    } & CommonDialogOptions): Promise<T | null>;
+    /**
+     * @deprecated use model instead
+     * @param options
+     */
+    showFormDialog<T = {}>(options: {
+        /**
+         * @deprecated use model instead
+         */ form: FormModel<T>;
+    } & CommonDialogOptions): Promise<FormModel<T> | null>;
+    showCustomDialog(options: CustomDialogOptions): Promise<unknown>;
+    showErrorDialog(options: CommonDialogOptions): Promise<unknown>;
+    showConfirmDialog(options: ConfirmDialogOptions): Promise<boolean | null>;
+    showNotificationDialog(options: MessageDialogOptions): NotificationDialogHandler;
+    showMessageDialog(options: MessageDialogOptions): Promise<void>;
+    showInputDialog(options: InputDialogOptions): Promise<string | null>;
+}

package/dist/@types/stores/KeyboardStore.d.ts

@@ -0,0 +1,32 @@
+import { AbstractStore } from './AbstractStore';
+import { BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+export declare enum CommonKeys {
+    ENTER = "Enter",
+    LEFT = "ArrowLeft",
+    RIGHT = "ArrowRight",
+    UP = "ArrowUp",
+    DOWN = "ArrowDown"
+}
+export interface KeyboardContextListener {
+    dispose: () => any;
+}
+export interface HandleKeyboardActionOptions {
+    key: CommonKeys;
+    action: (event: KeyboardEvent) => any;
+}
+export declare class KeyboardContext extends BaseObserver<KeyboardContextListener> {
+    handlers: Map<string, HandleKeyboardActionOptions>;
+    deactivateListener: () => any;
+    constructor();
+    handle(options: HandleKeyboardActionOptions): () => void;
+    setupListener(): () => void;
+    dispose(): void;
+    deactivate(): void;
+    activate(): void;
+}
+export declare class KeyboardStore extends AbstractStore {
+    contexts: Set<KeyboardContext>;
+    constructor();
+    getCurrentContext(): KeyboardContext;
+    pushContext(): KeyboardContext;
+}