@journeyapps-labs/reactor-mod 0.0.0-dev-20250801180850

package/README.md

@@ -0,0 +1,6 @@
+# Reactor core module
+
+![](https://img.shields.io/npm/v/@journeyapps-labs/reactor-mod)
+
+The core Reactor module that provides the core functionality of the application. This includes the System, Kernel and core stores
+which provide functionality such as the cmd palette, action system and workspaces and all other critical sub systems.

package/dist/@types/ReactorModule.d.ts

@@ -0,0 +1,18 @@
+import './fonts';
+import { AbstractReactorModule } from './core/AbstractReactorModule';
+import './stores/themes/built-in-themes/reactor';
+import './stores/themes/built-in-themes/hexagon';
+import './stores/themes/built-in-themes/journey';
+import './stores/themes/built-in-themes/light';
+import './stores/themes/built-in-themes/scarlet';
+import './stores/themes/built-in-themes/oxide';
+import { Container } from '@journeyapps-labs/lib-ioc';
+export declare class ReactorModule extends AbstractReactorModule {
+    constructor();
+    /**
+     This is called automatically in the index.html
+     */
+    static preboot(modules: any[]): void;
+    register(ioc: Container): void;
+    init(ioc: Container): Promise<any>;
+}

package/dist/@types/actions/Action.d.ts

@@ -0,0 +1,147 @@
+import { MousePosition } from '../layers/combo/SmartPositionWidget';
+import { System } from '../core/System';
+import { ReactorIcon } from '../widgets/icons/IconWidget';
+import { VisorStore } from '../stores/visor/VisorStore';
+import { LoadingDirectiveState, VisorLoadingDirective } from '../stores/visor/VisorLoadingDirective';
+import { DialogStore } from '../stores/DialogStore';
+import { ActionValidator, PassiveActionValidationState, ValidationResult } from './validators/ActionValidator';
+import { Btn } from '../definitions/common';
+import * as React from 'react';
+import { ShortcutChord } from '../stores/shortcuts/Shortcut';
+import { ComboBoxItem } from '../stores/combo/ComboBoxDirectives';
+import { SystemInterface } from '../core/SystemInterface';
+import { BaseListener, BaseObserver, Logger } from '@journeyapps-labs/lib-reactor-utils';
+import { ActionValidatorContext } from './validators/ActionValidatorContext';
+import { ActionButtonControl } from '../controls/ActionButtonControl';
+export interface SerializedAction {
+    _action: string;
+}
+export declare enum ActionMacroBehavior {
+    /**
+     * Will remove
+     */
+    DELETE = "delete",
+    /**
+     * Will change
+     */
+    DESTRUCTIVE = "destructive",
+    COPY = "copy"
+}
+export declare enum ActionRollbackMechanic {
+    /**
+     * There is no way to rollback
+     */
+    NONE = "none",
+    SCM = "scm"
+}
+export interface ActionOptions {
+    id: string;
+    name: string;
+    category?: {
+        entityType?: string;
+        grouping?: string;
+    };
+    icon: ReactorIcon;
+    hotkeys?: ShortcutChord[];
+    validators?: ActionValidator[];
+    hideFromCmdPallet?: boolean;
+    exemptFromExclusiveExecutionLock?: boolean;
+    behavior?: ActionMacroBehavior;
+    rollbackMechanic?: ActionRollbackMechanic;
+}
+export declare enum ActionSource {
+    COMMAND_PALLET = "cmd-palette",
+    BUTTON = "button",
+    TREE_LEAF = "tree-leaf",
+    COMBO_BOX_CALLOUT = "combo-box-callout",
+    RIGHT_CLICK = "right-click",
+    ACTION = "action-chain",
+    DND = "dnd",
+    HOTKEY = "hotkey",
+    NETWORK_EVENT = "network-event",
+    VISOR = "visor",
+    GUIDE = "guide"
+}
+export interface ActionComboBoxItem<T extends Action = Action> extends ComboBoxItem {
+    actionObject: T;
+}
+export interface ActionEvent {
+    id: string;
+    source: ActionSource;
+    position?: MousePosition;
+    getStatus?: () => VisorLoadingDirective;
+    canceled?: boolean;
+    fireBehaviorChecks?: boolean;
+}
+export interface ActionListener<E extends ActionEvent = ActionEvent> extends BaseListener {
+    willFire: (event: {
+        payload: Partial<E>;
+    }) => Promise<void>;
+    didFire: (event: {
+        payload: Partial<E>;
+        status: LoadingDirectiveState;
+        success: boolean;
+    }) => void;
+    cancelled: (event: {
+        payload: Partial<E>;
+    }) => void;
+}
+export interface ActionGenerics {
+    OPTIONS: ActionOptions;
+    EVENT: ActionEvent;
+}
+export declare abstract class Action<P extends Partial<ActionGenerics> = Partial<ActionGenerics>, T extends ActionGenerics & P = ActionGenerics & P, L extends ActionListener<T['EVENT']> = ActionListener<T['EVENT']>> extends BaseObserver<L> {
+    options: T['OPTIONS'];
+    application: SystemInterface;
+    private singletonValidationContext;
+    protected logger: Logger;
+    accessor visorStore: VisorStore;
+    accessor dialogStore: DialogStore;
+    constructor(options: T['OPTIONS']);
+    get id(): string;
+    generateValidationContext(): ActionValidatorContext;
+    /**
+     * @deprecated rather use generateValidationContext and dispose afterwards
+     */
+    validatePassively(): PassiveActionValidationState;
+    getExclusiveExecutionLock(event?: {
+        allowed?: (e: Partial<T['EVENT']>) => boolean;
+    }): () => any;
+    get group(): string;
+    representAsComboBoxItem(options?: {
+        installAction: boolean;
+        eventData?: Partial<T['EVENT']>;
+    }): ActionComboBoxItem<this>;
+    representAsIcon(extraData?: Partial<T['EVENT']>): Btn;
+    representAsControl(options?: {
+        eventData?: Partial<T['EVENT']>;
+    }): ActionButtonControl<this>;
+    /**
+     * @deprecated use representAsControl
+     */
+    representAsButton(extraData?: Partial<T['EVENT']>, validate?: boolean): Btn;
+    renderAsButton(render: (btn: Btn, result: ValidationResult) => React.JSX.Element, extraData?: Partial<T['EVENT']>): React.JSX.Element;
+    getTypeDisplayName(): string;
+    setApplication(app: System): void;
+    serialize(): SerializedAction;
+    protected _generateActionEvent(event: Omit<T['EVENT'], 'id'>): T["EVENT"];
+    /**
+     * Action will-fire events and returns true if the action can fire
+     */
+    protected _preflightChecks(event: T['EVENT']): Promise<boolean>;
+    /**
+     * Run the action with error handling
+     */
+    protected _runAction(event: T['EVENT']): Promise<boolean | void>;
+    /**
+     * Runs the action, but with tracing
+     * // TODO this can actually be setup on the system
+     */
+    protected _runActionInTrace(event: T['EVENT']): Promise<boolean | void>;
+    /**
+     * Runs at the end of the action
+     */
+    protected _postFlightChecks(event: T['EVENT'], result: any): void;
+    fireAction(event: Omit<T['EVENT'], 'id'>): Promise<boolean | void>;
+    protected abstract fireEvent(event: T['EVENT']): Promise<true | false | void>;
+}

package/dist/@types/actions/ActionMetaWidget.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { Action } from './Action';
+export interface ActionMetaWidgetProps {
+    action: Action;
+}
+export declare const ActionMetaWidget: React.FC<ActionMetaWidgetProps>;

package/dist/@types/actions/CurriedAction.d.ts

@@ -0,0 +1,24 @@
+import { ParameterizedAction, ParameterizedActionEvent } from './parameterized/ParameterizedAction';
+import { System } from '../core/System';
+export interface CurriedActionOptions {
+    entities?: {
+        [key: string]: any;
+    };
+    params?: {
+        [key: string]: any;
+    };
+    action: ParameterizedAction;
+}
+export declare class CurriedAction extends ParameterizedAction {
+    action: ParameterizedAction;
+    entities: {
+        [key: string]: any;
+    };
+    params: {
+        [key: string]: any;
+    };
+    constructor(options: CurriedActionOptions);
+    setApplication(app: System): void;
+    protected fireEvent(event: ParameterizedActionEvent): Promise<any>;
+    fireAction(event: ParameterizedActionEvent): Promise<any>;
+}

package/dist/@types/actions/action-utils.d.ts

@@ -0,0 +1,7 @@
+import { Action } from './Action';
+export interface SetupDeleteConfirmationOptions {
+    action: Action;
+    title?: string;
+    message?: string;
+}
+export declare const setupDeleteConfirmation: (options: SetupDeleteConfirmationOptions) => void;

package/dist/@types/actions/builtin-actions/ChangeThemeAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent } from '../parameterized/EntityAction';
+import { Theme, ThemeStore } from '../../stores/themes/ThemeStore';
+export declare class ChangeThemeAction extends EntityAction<Theme> {
+    static NAME: string;
+    accessor themeStore: ThemeStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<Theme>): Promise<any>;
+    static get(): ChangeThemeAction;
+}

package/dist/@types/actions/builtin-actions/CopyPanelURLAction.d.ts

@@ -0,0 +1,7 @@
+import { Action, ActionEvent } from '../Action';
+import { WorkspaceStore } from '../../stores/workspace/WorkspaceStore';
+export declare class CopyPanelURLAction extends Action {
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/ResetPreferencesAction.d.ts

@@ -0,0 +1,9 @@
+import { Action, ActionEvent } from '../Action';
+import { PrefsStore } from '../../stores/PrefsStore';
+import { WorkspaceStore } from '../../stores/workspace/WorkspaceStore';
+export declare class ResetPreferencesAction extends Action {
+    accessor prefsStore: PrefsStore;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/SwitchWorkspaceAction.d.ts

@@ -0,0 +1,9 @@
+import { IDEWorkspace, WorkspaceStore } from '../../stores/workspace/WorkspaceStore';
+import { EntityAction, EntityActionEvent } from '../parameterized/EntityAction';
+export declare class SwitchWorkspaceAction extends EntityAction<IDEWorkspace> {
+    accessor workspaceStore: WorkspaceStore;
+    static NAME: string;
+    constructor();
+    static get(): SwitchWorkspaceAction;
+    protected fireEvent(event: EntityActionEvent<IDEWorkspace>): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/TabAction.d.ts

@@ -0,0 +1,11 @@
+import { Action, ActionEvent } from '../Action';
+import { UXStore } from '../../stores/UXStore';
+export declare class TabAction extends Action {
+    accessor uxStore: UXStore;
+    left: boolean;
+    static NAME_LEFT: string;
+    static NAME_RIGHT: string;
+    constructor(left: boolean);
+    static get(left: boolean): TabAction;
+    protected fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/shortcuts/ExportShortcutsAction.d.ts

@@ -0,0 +1,10 @@
+import { ShortcutStore } from '../../../stores/shortcuts/ShortcutStore';
+import { Action, ActionEvent } from '../../Action';
+export declare class ExportShortcutsAction extends Action {
+    accessor shortcutStore: ShortcutStore;
+    static NAME: string;
+    static FILENAME: string;
+    constructor();
+    static get(): ExportShortcutsAction;
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/shortcuts/ImportShortcutsAction.d.ts

@@ -0,0 +1,11 @@
+import { Action, ActionEvent } from '../../Action';
+import { NotificationStore } from '../../../stores/NotificationStore';
+import { ShortcutStore } from '../../../stores/shortcuts/ShortcutStore';
+export declare class ImportShortcutsAction extends Action {
+    accessor shortcutStore: ShortcutStore;
+    accessor notificationStore: NotificationStore;
+    static NAME: string;
+    constructor();
+    static get(): ImportShortcutsAction;
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/shortcuts/ResetShortcutsAction.d.ts

@@ -0,0 +1,9 @@
+import { ShortcutStore } from '../../../stores/shortcuts/ShortcutStore';
+import { Action, ActionEvent } from '../../Action';
+export declare class ResetShortcutsAction extends Action {
+    accessor shortcutStore: ShortcutStore;
+    static NAME: string;
+    constructor();
+    static get(): ResetShortcutsAction;
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/AddPanelWorkspaceAction.d.ts

@@ -0,0 +1,10 @@
+import { WorkspaceStore } from '../../../stores/workspace/WorkspaceStore';
+import { EntityAction, EntityActionEvent } from '../../parameterized/EntityAction';
+import { ReactorPanelFactory } from '../../../stores/workspace/react-workspaces/ReactorPanelFactory';
+export declare class AddPanelWorkspaceAction extends EntityAction<ReactorPanelFactory> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    static get(): AddPanelWorkspaceAction;
+    fireEvent(event: EntityActionEvent<ReactorPanelFactory>): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/CreateWorkspaceAction.d.ts

@@ -0,0 +1,14 @@
+import { WorkspaceStore } from '../../../stores/workspace/WorkspaceStore';
+import { ParameterizedAction, ParameterizedActionEvent } from '../../parameterized/ParameterizedAction';
+export type CreateWorkspaceActionEvent = ParameterizedActionEvent<{
+    name: string;
+}>;
+export declare class CreateWorkspaceAction extends ParameterizedAction<{
+    EVENT: CreateWorkspaceActionEvent;
+}> {
+    accessor workspaceStore: WorkspaceStore;
+    static NAME: string;
+    constructor();
+    static get(): CreateWorkspaceAction;
+    fireEvent(event: CreateWorkspaceActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/CycleOpenTabsAction.d.ts

@@ -0,0 +1,8 @@
+import { Action, ActionEvent } from '../../Action';
+import { WorkspaceStore } from '../../../stores';
+export declare class CycleOpenTabsAction extends Action {
+    protected left: boolean;
+    accessor workspaceStore: WorkspaceStore;
+    constructor(left: boolean);
+    protected fireEvent(event: ActionEvent): Promise<boolean | void>;
+}

package/dist/@types/actions/builtin-actions/workspace/ExportWorkspaceAction.d.ts

@@ -0,0 +1,9 @@
+import { IDEWorkspace } from '../../../stores/workspace/WorkspaceStore';
+import { EntityAction, EntityActionEvent } from '../../parameterized/EntityAction';
+export declare class ExportWorkspaceAction extends EntityAction<IDEWorkspace> {
+    static NAME: string;
+    static FILENAME: string;
+    constructor();
+    static get(): ExportWorkspaceAction;
+    fireEvent(event: EntityActionEvent<IDEWorkspace>): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/ExportWorkspacesAction.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { WorkspaceStore } from '../../../stores/workspace/WorkspaceStore';
+import { Action, ActionEvent } from '../../Action';
+export declare const DownloadWorkspaceIcon: React.FC<{
+    url: string;
+    filename: string;
+}>;
+export declare class ExportWorkspacesAction extends Action {
+    accessor workspaceStore: WorkspaceStore;
+    static NAME: string;
+    static FILENAME: string;
+    constructor();
+    static get(): ExportWorkspacesAction;
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/ImportWorkspaceAction.d.ts

@@ -0,0 +1,11 @@
+import { Action, ActionEvent } from '../../Action';
+import { WorkspaceStore } from '../../../stores/workspace/WorkspaceStore';
+import { NotificationStore } from '../../../stores/NotificationStore';
+export declare class ImportWorkspaceAction extends Action {
+    accessor workspaceStore: WorkspaceStore;
+    accessor notificationStore: NotificationStore;
+    static NAME: string;
+    constructor();
+    static get(): ImportWorkspaceAction;
+    fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/ResetWorkspacesAction.d.ts

@@ -0,0 +1,7 @@
+import { Action, ActionEvent } from '../../Action';
+export declare class ResetWorkspacesAction extends Action {
+    static NAME: string;
+    constructor();
+    static get(): ResetWorkspacesAction;
+    protected fireEvent(event: ActionEvent): Promise<any>;
+}

package/dist/@types/actions/builtin-actions/workspace/WorkspaceActionValidator.d.ts

@@ -0,0 +1,4 @@
+import { ActionValidator, ValidationResult } from '../../validators/ActionValidator';
+export declare class WorkspaceActionValidator extends ActionValidator {
+    validate(): ValidationResult;
+}

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

@@ -0,0 +1,19 @@
+export * from './Action';
+export * from './CurriedAction';
+export * from './parameterized/ParameterizedAction';
+export * from './parameterized/CoupledAction';
+export * from './parameterized/EntityAction';
+export * from './parameterized/params/AbstractActionParameter';
+export * from './parameterized/params/ProviderActionParameter';
+export * from './parameterized/params/TextActionParameter';
+export * from './parameterized/params/SimpleComboActionParameter';
+export * from './validators/ActionValidator';
+export * from './validators/InlineActionValidator';
+export * from './validators/InlineActionValidator2';
+export * from './builtin-actions/ResetPreferencesAction';
+export * from './builtin-actions/ChangeThemeAction';
+export * from './builtin-actions/workspace/ResetWorkspacesAction';
+export * from './builtin-actions/workspace/CreateWorkspaceAction';
+export * from './builtin-actions/shortcuts/ExportShortcutsAction';
+export * from './builtin-actions/SwitchWorkspaceAction';
+export * from './action-utils';

package/dist/@types/actions/parameterized/CoupledAction.d.ts

@@ -0,0 +1,17 @@
+import { EntityAction, EntityActionEvent, EntityActionOptions } from './EntityAction';
+export declare enum CoupledActionFocusOption {
+    TARGET = "targetEntity",
+    SOURCE = "sourceEntity"
+}
+export interface CoupledActionEvent<TARGET = any, SOURCE = any> extends EntityActionEvent<TARGET> {
+    [CoupledActionFocusOption.SOURCE]: SOURCE;
+    [CoupledActionFocusOption.TARGET]: TARGET;
+}
+export interface CoupledActionOptions extends EntityActionOptions {
+    source: string;
+}
+export declare abstract class CoupledAction<TARGET = any, SOURCE = any, Event extends CoupledActionEvent<TARGET, SOURCE> = CoupledActionEvent<TARGET, SOURCE>> extends EntityAction<TARGET, Event, CoupledActionOptions> {
+    constructor(options: CoupledActionOptions);
+    collectParams(event: Event): Promise<boolean>;
+    getTypeDisplayName(): string;
+}

package/dist/@types/actions/parameterized/EntityAction.d.ts

@@ -0,0 +1,32 @@
+import { ParameterizedAction, ParameterizedActionEvent, ParameterizedActionGenerics, ParameterizedActionOptions } from './ParameterizedAction';
+export interface EntityActionOptions<T = any> extends ParameterizedActionOptions {
+    target: string;
+    initialTargetValue?: () => Promise<T>;
+    /**
+     * Allow the action to run with batch processing. When enabled, the action appears in the right click menu
+     * when multiple entities are selected
+     * @default false
+     */
+    batch?: boolean;
+    /**
+     * When running in batch mode, how many items to run concurrently
+     * @default 1
+     */
+    batch_concurrency?: number;
+    /**
+     * If the provider can return options immediately, select the first option
+     * if there is only one option in the immediate result set
+     */
+    autoSelectIsolatedTarget?: boolean;
+}
+export interface EntityActionEvent<Target = any, DecodedParameters = {}> extends ParameterizedActionEvent<DecodedParameters> {
+    targetEntity: Target;
+}
+export declare abstract class EntityAction<Target = any, Event extends EntityActionEvent<Target> = EntityActionEvent<Target>, Options extends EntityActionOptions<Target> = EntityActionOptions<Target>> extends ParameterizedAction<ParameterizedActionGenerics & {
+    EVENT: Event;
+    OPTIONS: Options;
+}> {
+    constructor(options: Options);
+    collectParams(event: Event): Promise<boolean>;
+    getTypeDisplayName(): string;
+}

package/dist/@types/actions/parameterized/ParameterizedAction.d.ts

@@ -0,0 +1,32 @@
+import { Action, ActionEvent, ActionOptions, ActionListener, ActionGenerics } from '../Action';
+import { AbstractActionParameter } from './params/AbstractActionParameter';
+export declare enum EntityActionParams {
+    TARGET = "target",
+    SOURCE = "source"
+}
+export interface ParameterizedActionEvent<Decoded extends {
+    [parameter: string]: any;
+} = {}> extends ActionEvent {
+    entities?: Decoded;
+    params?: {
+        [parameter: string]: any;
+    };
+}
+export interface ParameterizedActionOptions extends ActionOptions {
+    params?: AbstractActionParameter[];
+}
+export interface ParameterizedActionListener<E extends ParameterizedActionEvent = ParameterizedActionEvent> extends ActionListener<E> {
+    willCollectParams?: (event: {
+        payload: Partial<Omit<E, 'id'>>;
+    }) => any;
+}
+export interface ParameterizedActionGenerics extends ActionGenerics {
+    OPTIONS: ParameterizedActionOptions;
+    EVENT: ParameterizedActionEvent;
+}
+export declare abstract class ParameterizedAction<P extends Partial<ParameterizedActionGenerics> = Partial<ParameterizedActionGenerics>, T extends ParameterizedActionGenerics & P = ParameterizedActionGenerics & P> extends Action<P, T, ParameterizedActionListener<T['EVENT']>> {
+    constructor(options: P['OPTIONS']);
+    getTypeDisplayName(): string;
+    collectParams(event: Omit<T['EVENT'], 'id'>): Promise<boolean>;
+    fireAction(event: Omit<T['EVENT'], 'id'>): Promise<boolean>;
+}

package/dist/@types/actions/parameterized/params/AbstractActionParameter.d.ts

@@ -0,0 +1,17 @@
+import { ParameterizedAction, ParameterizedActionEvent } from '../ParameterizedAction';
+export interface AbstractActionParameterOptions {
+    name: string;
+    description?: string;
+    /**
+     * @default true
+     */
+    required?: boolean;
+    getDefault?: () => any;
+}
+export declare abstract class AbstractActionParameter<OPTIONS extends AbstractActionParameterOptions = AbstractActionParameterOptions, T extends any = any> {
+    options: OPTIONS;
+    action: ParameterizedAction;
+    constructor(options: OPTIONS);
+    abstract getValue(event: Omit<ParameterizedActionEvent, 'id'>): Promise<boolean>;
+    setAction(action: ParameterizedAction): void;
+}

package/dist/@types/actions/parameterized/params/ProviderActionParameter.d.ts

@@ -0,0 +1,22 @@
+import { AbstractActionParameter, AbstractActionParameterOptions } from './AbstractActionParameter';
+import { Provider } from '../../../providers/Provider';
+import { RenderCalloutFunction } from '../../../stores/combo/ComboBoxDirectives';
+import { ParameterizedActionEvent } from '../ParameterizedAction';
+import { EntityDefinition } from '../../../entities/EntityDefinition';
+export interface ProviderActionParameterOptions<T> extends AbstractActionParameterOptions {
+    type: string;
+    renderCallout?: RenderCalloutFunction;
+    getDefaultDecoded?: (event: ParameterizedActionEvent) => Promise<any>;
+    getInitialDecoded?: (event: ParameterizedActionEvent) => Promise<any>;
+    autoSelectIsolatedItem?: boolean;
+    filter?: (item: T) => boolean;
+}
+export declare class ProviderActionParameter<T> extends AbstractActionParameter<ProviderActionParameterOptions<T>> {
+    /**
+     * @deprecated
+     */
+    getProvider(): Provider;
+    getDefinition(): EntityDefinition<T>;
+    getProviderEntity(event: ParameterizedActionEvent): Promise<any>;
+    getValue(event: ParameterizedActionEvent): Promise<boolean>;
+}

package/dist/@types/actions/parameterized/params/SimpleComboActionParameter.d.ts

@@ -0,0 +1,12 @@
+import { ComboBoxItem } from '../../../stores';
+import { ComboBoxStore2 } from '../../../stores/combo2/ComboBoxStore2';
+import { SimpleComboBoxDirectiveOptions } from '../../../stores/combo2/directives/SimpleComboBoxDirective';
+import { ParameterizedActionEvent } from '../ParameterizedAction';
+import { AbstractActionParameter, AbstractActionParameterOptions } from './AbstractActionParameter';
+export interface SimpleComboParameterOptions<T extends ComboBoxItem> extends AbstractActionParameterOptions {
+    comboOptions: SimpleComboBoxDirectiveOptions<T>;
+}
+export declare class SimpleComboActionParameter<T extends ComboBoxItem> extends AbstractActionParameter<SimpleComboParameterOptions<T>, string> {
+    accessor comboBoxStore2: ComboBoxStore2;
+    getValue(event: Omit<ParameterizedActionEvent, 'id'>): Promise<boolean>;
+}

package/dist/@types/actions/parameterized/params/TextActionParameter.d.ts

@@ -0,0 +1,13 @@
+import { AbstractActionParameter, AbstractActionParameterOptions } from './AbstractActionParameter';
+import { ParameterizedActionEvent } from '../ParameterizedAction';
+import { DialogStore } from '../../../stores/DialogStore';
+export interface TextActionParameterOptions extends AbstractActionParameterOptions {
+    label: string;
+    desc?: string;
+}
+export declare class TextActionParameter extends AbstractActionParameter<TextActionParameterOptions, string> {
+    accessor dialogStore: DialogStore;
+    decode(value: any): Promise<string>;
+    encode(value: string): Promise<any>;
+    getValue(event: Omit<ParameterizedActionEvent, 'id'>): Promise<boolean>;
+}

package/dist/@types/actions/shortcuts/ActionShortcut.d.ts

@@ -0,0 +1,14 @@
+import { Shortcut, ShortcutChord } from '../../stores/shortcuts/Shortcut';
+import { ShortcutHandlerAction } from '../../stores/shortcuts/ShortcutHandler';
+import { ActionShortcutHandler } from './ActionShortcutHandler';
+export declare class ActionShortcut extends Shortcut {
+    private disposer;
+    private handler;
+    constructor(action: ShortcutHandlerAction, handler: ActionShortcutHandler);
+    dispose(): void;
+    getAction(): import("../Action").Action<Partial<import("../Action").ActionGenerics>, import("../Action").ActionGenerics & Partial<import("../Action").ActionGenerics>, import("../Action").ActionListener<import("../Action").ActionEvent>>;
+    enable(enabled: boolean): void;
+    fireAction(): void;
+    bind(): void;
+    setChord(keys: ShortcutChord): void;
+}

package/dist/@types/actions/shortcuts/ActionShortcutHandler.d.ts

@@ -0,0 +1,19 @@
+import { System } from '../../core/System';
+import { ActionShortcut } from './ActionShortcut';
+import { Action } from '../Action';
+import { ShortcutHandler, ShortcutHandlerAction } from '../../stores/shortcuts/ShortcutHandler';
+import { ShortcutKey } from '../../stores/shortcuts/Shortcut';
+import { Hotkeys } from './Hotkeys';
+export declare class ActionShortcutHandler extends ShortcutHandler<ActionShortcut> {
+    accessor system: System;
+    stack: ShortcutKey[][];
+    hotkeys: Hotkeys;
+    hotkeys2: Hotkeys;
+    constructor();
+    init(): Promise<void>;
+    generateShortcut(action: ShortcutHandlerAction): ActionShortcut;
+    generateActionShortcut(action: Action): ShortcutHandlerAction;
+    getShortcutsForReactorAction(action: Action): ActionShortcut[];
+    getPossibleActions(): ShortcutHandlerAction[];
+    getMetaForAction(id: string): ShortcutHandlerAction;
+}

package/dist/@types/actions/shortcuts/Hotkeys.d.ts

@@ -0,0 +1,30 @@
+import { ShortcutKey } from '../../stores/shortcuts/Shortcut';
+export interface HotkeyAction {
+    callback: () => any;
+    strokes: ShortcutKey[];
+}
+export interface KeyDownEvent {
+    key: ShortcutKey;
+    code: string;
+}
+export declare class Hotkeys {
+    keysDown: KeyDownEvent[];
+    stack: KeyDownEvent[];
+    actions: {
+        [id: string]: HotkeyAction;
+    };
+    listening: boolean;
+    constructor();
+    register(action: HotkeyAction): () => any;
+    normalizeKey(key: string): ShortcutKey;
+    normalizeEvent(event: KeyboardEvent, cb: (key: KeyDownEvent) => any): void;
+    checkChordActions(key: KeyDownEvent): boolean;
+    removePressedKey(key: KeyDownEvent): void;
+    checkSingleKeyActions(): void;
+    hasKey(key: KeyDownEvent, stack?: boolean): number;
+    keyDownEvent: (event: KeyboardEvent) => void;
+    keyUpEvent: (event: KeyboardEvent) => void;
+    focus: () => void;
+    listen(): void;
+    unListen(): void;
+}

package/dist/@types/actions/shortcuts/action-shortcut-common.d.ts

@@ -0,0 +1 @@
+export declare const ACTION_SHORTCUT_HANDLER = "action-keys";