@journeyapps-labs/reactor-mod 1.0.0

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,266 @@
+import * as React from 'react';
+import { WorkspaceStore } from '../../../stores/workspace/WorkspaceStore';
+import { Action, ActionEvent } from '../../Action';
+export declare namespace S {
+    const Download: import("@emotion/styled").StyledComponent<{
+        theme?: import("../../..").ThemeColors<{
+            plan: {
+                label: string;
+                colors: {
+                    background: string;
+                    border: string;
+                    foreground: string;
+                };
+            };
+            canvas: {
+                label: string;
+                colors: {
+                    background: string;
+                    grid: string;
+                };
+            };
+            tooltips: {
+                label: string;
+                colors: {
+                    background: string;
+                    foreground: string;
+                };
+            };
+            workspace: {
+                label: string;
+                colors: {
+                    background: string;
+                    overlayBackground: string;
+                    overlayBackgroundHover: string;
+                    overlayBorder: string;
+                    overlayBorderHover: string;
+                    overlayDividerColor: string;
+                    overlayDividerHover: string;
+                };
+            };
+            panels: {
+                label: string;
+                colors: {
+                    trayBackground: string;
+                    trayButton: string;
+                    trayButtonSelected: string;
+                    background: string;
+                    titleBackground: string;
+                    titleForeground: string;
+                    iconBackground: string;
+                    divider: string;
+                    searchBackground: string;
+                    searchForeground: string;
+                    tabForeground: string;
+                    tabForegroundSelected: string;
+                    tabBackgroundSelected: string;
+                    itemIconColorSelected: string;
+                    scrollBar: string;
+                };
+            };
+            meta: {
+                label: string;
+                colors: {
+                    background: string;
+                    foreground: string;
+                };
+            };
+            dnd: {
+                label: string;
+                colors: {
+                    hintColor: string;
+                    hoverColor: string;
+                };
+            };
+            icons: {
+                label: string;
+                colors: {
+                    dualIconBackground: string;
+                    color: string;
+                };
+            };
+            trees: {
+                label: string;
+                colors: {
+                    labelColor: string;
+                    selectedBackground: string;
+                };
+            };
+            guide: {
+                label: string;
+                colors: {
+                    accent: string;
+                    tooltipBackground: string;
+                    accentText: string;
+                    startButton: string;
+                    startButtonText: string;
+                };
+            };
+            graphs: {
+                label: string;
+                colors: {
+                    grid: string;
+                    line: string;
+                    fillStop1: string;
+                    fillStop2: string;
+                    fillStop3: string;
+                    thresholdLine: string;
+                };
+            };
+            tabs: {
+                label: string;
+                colors: {
+                    selectedAccentSingle: string;
+                    selectedAccent: string;
+                    selectedBackground: string;
+                };
+            };
+            status: {
+                label: string;
+                colors: {
+                    cardBackground: string;
+                    success: string;
+                    failed: string;
+                    failedForeground: string;
+                    loading: string;
+                    successForeground: string;
+                };
+            };
+            cards: {
+                label: string;
+                colors: {
+                    background: string;
+                    foreground: string;
+                    border: string;
+                };
+            };
+            combobox: {
+                label: string;
+                colors: {
+                    background: string;
+                    backgroundSelected: string;
+                    textSelected: string;
+                    text: string;
+                    border: string;
+                    headerBackground: string;
+                    headerForeground: string;
+                    shadowColor: string;
+                };
+            };
+            forms: {
+                label: string;
+                colors: {
+                    description: string;
+                    inputBackground: string;
+                    inputForeground: string;
+                    checkbox: string;
+                    checkboxChecked: string;
+                    toggleOnColor: string;
+                    toggleHandleColor: string;
+                    groupBorder: string;
+                    groupLabelForeground: string;
+                };
+            };
+            footer: {
+                label: string;
+                colors: {
+                    background: string;
+                };
+            };
+            header: {
+                label: string;
+                colors: {
+                    background: string;
+                    backgroundLogo: string;
+                    backgroundLogoHover: string;
+                    primary: string;
+                    secondary: string;
+                    foreground: string;
+                };
+            };
+            visor: {
+                label: string;
+                colors: {
+                    background: string;
+                };
+            };
+            text: {
+                label: string;
+                colors: {
+                    primary: string;
+                    secondary: string;
+                };
+            };
+            buttonLink: {
+                label: string;
+                colors: {
+                    background: string;
+                    border: string;
+                    color: string;
+                    colorHover: string;
+                    icon: string;
+                };
+            };
+            button: {
+                label: string;
+                colors: {
+                    background: string;
+                    border: string;
+                    color: string;
+                    colorHover: string;
+                    icon: string;
+                };
+            };
+            buttonPrimary: {
+                label: string;
+                colors: {
+                    background: string;
+                    border: string;
+                    color: string;
+                    colorHover: string;
+                    icon: string;
+                };
+            };
+            changelog: {
+                label: string;
+                colors: {
+                    codeBackground: string;
+                    codeForeground: string;
+                };
+            };
+            table: {
+                label: string;
+                colors: {
+                    odd: string;
+                    pills: string;
+                    text: string;
+                    pillsSpecial: string;
+                    columnBackground: string;
+                    columnForeground: string;
+                };
+            };
+            floating: {
+                label: string;
+                colors: {
+                    background: string;
+                    backgroundInactive: string;
+                };
+            };
+        }> & {
+            light: boolean;
+        };
+        as?: React.ElementType;
+    }, React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, {}>;
+}
+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';