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

package/dist/@types/entities/EntityDefinitionComponent.d.ts

@@ -0,0 +1,9 @@
+import { EntityDefinition } from './EntityDefinition';
+import { BaseListener, BaseObserver } from '@journeyapps-labs/lib-reactor-utils';
+export declare abstract class EntityDefinitionComponent<T extends BaseListener = BaseListener> extends BaseObserver<T> {
+    type: string;
+    definition: EntityDefinition;
+    constructor(type: string);
+    get system(): import("..").System;
+    setDefinition(definition: EntityDefinition): void;
+}

package/dist/@types/entities/components/encoder/EntityEncoderComponent.d.ts

@@ -0,0 +1,20 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+export interface EncodedEntity<T extends {} = {}> {
+    type: string;
+    version: number;
+    id: string;
+    encoded: T;
+}
+export interface EntityEncoderComponentOptions {
+    version: number;
+}
+export declare abstract class EntityEncoderComponent<Decoded extends any = any, Encoded extends {} = {}> extends EntityDefinitionComponent {
+    protected options: EntityEncoderComponentOptions;
+    static TYPE: string;
+    constructor(options?: EntityEncoderComponentOptions);
+    get version(): number;
+    encode(entity: Decoded): EncodedEntity<Encoded>;
+    decode(entity: EncodedEntity<Encoded>): Promise<Decoded>;
+    protected abstract doEncode(entity: Decoded): Encoded;
+    protected abstract doDecode(entity: Encoded): Promise<Decoded>;
+}

package/dist/@types/entities/components/encoder/InlineEntityEncoderComponent.d.ts

@@ -0,0 +1,11 @@
+import { EntityEncoderComponent, EntityEncoderComponentOptions } from './EntityEncoderComponent';
+export interface InlineEntityEncoderComponentOptions<Decoded, Encoded> extends EntityEncoderComponentOptions {
+    encode: (e: Decoded) => Encoded;
+    decode: (e: Encoded) => Promise<Decoded>;
+}
+export declare class InlineEntityEncoderComponent<Decoded extends any = any, Encoded extends {} = {}> extends EntityEncoderComponent<Decoded, Encoded> {
+    protected options2: InlineEntityEncoderComponentOptions<Decoded, Encoded>;
+    constructor(options2: InlineEntityEncoderComponentOptions<Decoded, Encoded>);
+    protected doDecode(entity: Encoded): Promise<Decoded>;
+    protected doEncode(entity: Decoded): Encoded;
+}

package/dist/@types/entities/components/exposer/DescendantEntityProviderComponent.d.ts

@@ -0,0 +1,37 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+import { ReactorTreeEntity, ReactorTreeNode, TreeWidgetProps } from '../../../widgets';
+import { ComboBoxStore2 } from '../../../stores/combo2/ComboBoxStore2';
+import { AbstractEntityTreePresenterContext } from '../presenter/types/tree/presenter-contexts/AbstractEntityTreePresenterContext';
+export type CategoryInfo = Omit<TreeWidgetProps, 'forwardRef' | 'children' | 'rightClick'> & {
+    sortKey?: string;
+};
+export interface DescendantEntityGeneratedOptions<Descendant> {
+    category?: CategoryInfo;
+    descendants: Descendant[];
+}
+export interface DescendantEntityProviderComponentOptions<Parent, Descendant> {
+    descendantType: string;
+    generateOptions: (parentEntity: Parent) => DescendantEntityGeneratedOptions<Descendant> | null;
+}
+export interface DoGetReactorTreeEntitiesOptions<Parent, Descendant> {
+    descendantOptions: DescendantEntityGeneratedOptions<Descendant>;
+    entity: Parent;
+    context: AbstractEntityTreePresenterContext<Descendant>;
+}
+export declare class DescendantEntityProviderComponent<Parent = any, Descendant = any> extends EntityDefinitionComponent {
+    protected options: DescendantEntityProviderComponentOptions<Parent, Descendant>;
+    static TYPE: string;
+    accessor comboBoxStore: ComboBoxStore2;
+    cache: Map<AbstractEntityTreePresenterContext<Descendant>, ReactorTreeNode>;
+    constructor(options: DescendantEntityProviderComponentOptions<Parent, Descendant>);
+    get descendantType(): string;
+    installParentNode(parent: ReactorTreeNode, descendantOptions: DescendantEntityGeneratedOptions<Descendant>): () => void;
+    generateTreeNode(descendantOptions: DescendantEntityGeneratedOptions<Descendant> & {
+        parent: Parent;
+    }): ReactorTreeNode<import("../../../widgets").ReactorTreeNodeListener>;
+    protected doGetReactorTreeEntities(options: DoGetReactorTreeEntitiesOptions<Parent, Descendant>): ReactorTreeEntity[];
+    getReactorTreeEntities(entity: Parent, context: AbstractEntityTreePresenterContext<Descendant>): {
+        entities: ReactorTreeEntity[];
+        options: DescendantEntityGeneratedOptions<Descendant>;
+    };
+}

package/dist/@types/entities/components/exposer/DescendantLoadingEntityProviderComponent.d.ts

@@ -0,0 +1,20 @@
+import { ReactorTreeNode } from '../../../widgets/core-tree/reactor-tree/ReactorTreeNode';
+import { DescendantEntityGeneratedOptions, DescendantEntityProviderComponent, DescendantEntityProviderComponentOptions } from './DescendantEntityProviderComponent';
+export interface DescendantLoadingEntityGeneratedOptions<Descendant> extends DescendantEntityGeneratedOptions<Descendant> {
+    refreshDescendants?: (event: {
+        node?: ReactorTreeNode;
+    }) => any;
+    loading?: () => boolean;
+}
+export interface DescendantLoadingEntityProviderOptions<Parent, Descendant> extends DescendantEntityProviderComponentOptions<Parent, Descendant> {
+    generateOptions: (parentEntity: Parent) => DescendantLoadingEntityGeneratedOptions<Descendant> | null;
+}
+export declare class DescendantLoadingEntityProviderComponent<Parent, Descendant> extends DescendantEntityProviderComponent<Parent, Descendant> {
+    protected options: DescendantLoadingEntityProviderOptions<Parent, Descendant>;
+    constructor(options: DescendantLoadingEntityProviderOptions<Parent, Descendant>);
+    installParentNode(parent: ReactorTreeNode, descendantOptions: DescendantEntityGeneratedOptions<Descendant>): () => void;
+    installNode(node: ReactorTreeNode, descendantOptions: DescendantLoadingEntityGeneratedOptions<Descendant>): () => void;
+    generateTreeNode(descendantOptions: DescendantLoadingEntityGeneratedOptions<Descendant> & {
+        parent: Parent;
+    }): ReactorTreeNode;
+}

package/dist/@types/entities/components/handler/EntityActionHandlerComponent.d.ts

@@ -0,0 +1,10 @@
+import { EntityHandlerComponent } from './EntityHandlerComponent';
+import { ComboBoxItem } from '../../../stores';
+import { EntityAction } from '../../../actions';
+export declare class EntityActionHandlerComponent extends EntityHandlerComponent {
+    protected actionID: string;
+    constructor(actionID: string);
+    getDescription(): ComboBoxItem;
+    protected getAction(): EntityAction;
+    openEntity(event: any): Promise<boolean>;
+}

package/dist/@types/entities/components/handler/EntityHandlerComponent.d.ts

@@ -0,0 +1,16 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+import { ComboBoxItem } from '../../../stores';
+import { MousePosition } from '../../../widgets';
+import { ActionSource } from '../../../actions';
+export interface OpenEntityEvent<T> {
+    entity: T;
+    position: MousePosition;
+    source: ActionSource;
+}
+export declare abstract class EntityHandlerComponent<T extends any = any> extends EntityDefinitionComponent {
+    static TYPE: string;
+    uuid: string;
+    constructor();
+    abstract openEntity(event: OpenEntityEvent<T>): Promise<any>;
+    abstract getDescription(entity: T): Omit<ComboBoxItem, 'key'>;
+}

package/dist/@types/entities/components/handler/InlineEntityHandlerComponent.d.ts

@@ -0,0 +1,12 @@
+import { EntityHandlerComponent, OpenEntityEvent } from './EntityHandlerComponent';
+import { ComboBoxItem } from '../../../stores';
+export interface InlineEntityHandlerComponentOptions<T> {
+    cb: (event: OpenEntityEvent<T>) => any;
+    desc: ComboBoxItem;
+}
+export declare class InlineEntityHandlerComponent<T extends any> extends EntityHandlerComponent<T> {
+    protected options: InlineEntityHandlerComponentOptions<T>;
+    constructor(options: InlineEntityHandlerComponentOptions<T>);
+    getDescription(): ComboBoxItem;
+    openEntity(event: any): Promise<void>;
+}

package/dist/@types/entities/components/meta/EntityDescriberComponent.d.ts

@@ -0,0 +1,24 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+import { ReactorIcon } from '../../../widgets';
+import { BaseListener } from '@journeyapps-labs/lib-reactor-utils';
+export interface EntityDescription {
+    simpleName: string;
+    complexName?: string;
+    icon?: ReactorIcon;
+    iconColor?: string;
+}
+export interface EntityDescriberComponentOptions<T> {
+    label: string;
+    describe: (entity: T) => EntityDescription;
+}
+export interface EntityDescriberComponentListener extends BaseListener {
+    preferred: () => any;
+}
+export declare class EntityDescriberComponent<T> extends EntityDefinitionComponent<EntityDescriberComponentListener> {
+    protected options: EntityDescriberComponentOptions<T>;
+    static TYPE: string;
+    constructor(options: EntityDescriberComponentOptions<T>);
+    describeEntity(t: T): EntityDescription;
+    get label(): string;
+    setPreferred(): void;
+}

package/dist/@types/entities/components/meta/EntityDocsComponent.d.ts

@@ -0,0 +1,12 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+export interface EntityDocsComponentOptions<T> {
+    label: string;
+    getDocLink: (entity: T) => string | null;
+}
+export declare class EntityDocsComponent<T> extends EntityDefinitionComponent {
+    protected options: EntityDocsComponentOptions<T>;
+    static TYPE: string;
+    constructor(options: EntityDocsComponentOptions<T>);
+    get label(): string;
+    getDocs(entity: T): string;
+}

package/dist/@types/entities/components/presenter/AbstractPresenterContext.d.ts

@@ -0,0 +1,49 @@
+import { BaseObserver, BaseObserverInterface } from '@journeyapps-labs/lib-reactor-utils';
+import { SearchEvent } from '@journeyapps-labs/lib-reactor-search';
+import { EntityPresenterComponent, SelectEntityListener } from './EntityPresenterComponent';
+import { ReactorIcon } from '../../../widgets';
+import { AbstractValueControl } from '../../../controls/AbstractValueControl';
+import { ButtonControl } from '../../../controls/ButtonControl';
+export interface RenderCollectionOptions<T> {
+    entities: T[];
+    searchEvent?: SearchEvent;
+    events?: BaseObserverInterface<SelectEntityListener<T>>;
+}
+export interface PresenterContextListener {
+    stateChanged?: () => any;
+    disposed?: () => any;
+}
+export type SerializedPresenterContext<State extends {} = {}, Settings extends {} = {}> = {
+    state: State;
+    controlValues: Settings;
+};
+export interface PresenterSetting {
+    icon: ReactorIcon;
+    label: string;
+    key: string;
+    control: AbstractValueControl;
+}
+export interface ExposedPresenterSetting extends PresenterSetting {
+    component: EntityPresenterComponent;
+    context: AbstractPresenterContext;
+}
+export declare abstract class AbstractPresenterContext<T = any, State extends {} = {}, Settings extends {} = {}, Listener extends PresenterContextListener = PresenterContextListener> extends BaseObserver<Listener> {
+    presenter: EntityPresenterComponent;
+    state: State;
+    accessor settings: Map<string, PresenterSetting>;
+    accessor toolbarButtons: Set<ButtonControl>;
+    constructor(presenter: EntityPresenterComponent);
+    dispose(): void;
+    setState(state: State): void;
+    deserialize(data: SerializedPresenterContext<State, Settings>): void;
+    serialize(): SerializedPresenterContext<State, Settings>;
+    getControls(): AbstractValueControl[];
+    getControlValues(): Settings;
+    getDefaultSettings(): Settings;
+    addSetting(setting: PresenterSetting): void;
+    addToolbarButton(btn: ButtonControl): void;
+    removeSetting(key: string): void;
+    getSettings(): ExposedPresenterSetting[];
+    abstract render(entity: T): React.JSX.Element;
+    abstract renderCollection(event: RenderCollectionOptions<T>): React.JSX.Element;
+}

package/dist/@types/entities/components/presenter/EntityPresenterComponent.d.ts

@@ -0,0 +1,23 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+import { AbstractPresenterContext } from './AbstractPresenterContext';
+export declare enum EntityPresenterComponentRenderType {
+    TREE = "tree"
+}
+export interface EntityPresenterComponentOptions {
+    label: string;
+}
+export interface SelectEntityListener<T> {
+    selectEntity: (entity: T) => any;
+}
+export interface EntityPresenterListener<Context extends AbstractPresenterContext> {
+    contextGenerated?: (context: Context) => void;
+}
+export declare abstract class EntityPresenterComponent<T extends any = any, PresenterContext extends AbstractPresenterContext<T> = AbstractPresenterContext<T>> extends EntityDefinitionComponent<EntityPresenterListener<PresenterContext>> {
+    renderType: EntityPresenterComponentRenderType;
+    protected options: EntityPresenterComponentOptions;
+    static TYPE: string;
+    constructor(renderType: EntityPresenterComponentRenderType, options: EntityPresenterComponentOptions);
+    get label(): string;
+    protected abstract _generateContext(): PresenterContext;
+    generateContext(): PresenterContext;
+}

package/dist/@types/entities/components/presenter/types/tree/EntityReactorLeaf.d.ts

@@ -0,0 +1,9 @@
+import { CoreTreeWidgetProps, ReactorTreeLeaf } from '../../../../../widgets';
+import React from 'react';
+import { EntityReactorNodeOptions } from './EntityReactorNode';
+export declare class EntityReactorLeaf extends ReactorTreeLeaf {
+    protected options2: EntityReactorNodeOptions;
+    constructor(options2: EntityReactorNodeOptions);
+    get entity(): any;
+    renderWidget(event: CoreTreeWidgetProps): React.JSX.Element;
+}

package/dist/@types/entities/components/presenter/types/tree/EntityReactorNode.d.ts

@@ -0,0 +1,40 @@
+import { CoreTreeWidgetProps, ReactorTreeEntity, ReactorTreeNode } from '../../../../../widgets';
+import * as React from 'react';
+import { EntityDefinition } from '../../../../EntityDefinition';
+import { SelectEntityListener } from '../../EntityPresenterComponent';
+import { BaseObserverInterface } from '@journeyapps-labs/lib-reactor-utils';
+import { DescendantEntityProviderComponent } from '../../../exposer/DescendantEntityProviderComponent';
+import { AbstractEntityTreePresenterContext } from './presenter-contexts/AbstractEntityTreePresenterContext';
+import { IReactionDisposer } from 'mobx';
+import { EntityTreePresenterComponent } from './EntityTreePresenterComponent';
+import { System } from '../../../../../core/System';
+export declare class DescendentContext<E> {
+    protected presenter: EntityTreePresenterComponent<any>;
+    protected rootContext: AbstractEntityTreePresenterContext<any>;
+    protected descendant: DescendantEntityProviderComponent<E, any>;
+    protected node: EntityReactorNode<E>;
+    nodes: Set<ReactorTreeEntity>;
+    disposer1: IReactionDisposer;
+    disposer2: () => any;
+    context: AbstractEntityTreePresenterContext;
+    constructor(presenter: EntityTreePresenterComponent<any>, rootContext: AbstractEntityTreePresenterContext<any>, descendant: DescendantEntityProviderComponent<E, any>, node: EntityReactorNode<E>);
+    clear(): void;
+    dispose(): void;
+}
+export interface EntityReactorNodeOptions<E extends any = any> {
+    definition: EntityDefinition;
+    entity: E;
+    events?: BaseObserverInterface<SelectEntityListener<E>>;
+}
+export declare class EntityReactorNode<E extends any = any> extends ReactorTreeNode {
+    protected options2: EntityReactorNodeOptions<E>;
+    accessor system: System;
+    descendants: Set<DescendentContext<E>>;
+    context: AbstractEntityTreePresenterContext;
+    constructor(options2: EntityReactorNodeOptions<E>);
+    disposeDescendents(): void;
+    attachDescendents(): void;
+    setRootPresenterContext(context: AbstractEntityTreePresenterContext): void;
+    get entity(): E;
+    renderWidget(event: CoreTreeWidgetProps): React.JSX.Element;
+}

package/dist/@types/entities/components/presenter/types/tree/EntityTreeCollectionWidget.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { RenderCollectionOptions } from '../../AbstractPresenterContext';
+import { AbstractEntityTreePresenterContext } from './presenter-contexts/AbstractEntityTreePresenterContext';
+export interface EntityTreeCollectionWidgetProps<T extends any> {
+    event: RenderCollectionOptions<T>;
+    presenterContext: AbstractEntityTreePresenterContext<T>;
+}
+export declare const EntityTreeCollectionWidget: <T>(props: EntityTreeCollectionWidgetProps<T>) => React.JSX.Element;

package/dist/@types/entities/components/presenter/types/tree/EntityTreePresenterComponent.d.ts

@@ -0,0 +1,22 @@
+import { TreeSerialized } from '@journeyapps-labs/lib-reactor-tree';
+import { EntityPresenterComponent, EntityPresenterComponentOptions } from '../../EntityPresenterComponent';
+import { BatchStore } from '../../../../../stores/batch/BatchStore';
+import { AbstractEntityTreePresenterContext } from './presenter-contexts/AbstractEntityTreePresenterContext';
+export declare enum EntityTreePresenterSetting {
+    SORT = "sort"
+}
+export declare enum SortDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+export interface EntityTreePresenterSettings {
+    [EntityTreePresenterSetting.SORT]: SortDirection;
+}
+export interface EntityTreePresenterState {
+    trees: TreeSerialized;
+}
+export declare abstract class EntityTreePresenterComponent<T> extends EntityPresenterComponent<T, AbstractEntityTreePresenterContext<T>> {
+    static DEFAULT_LABEL: string;
+    accessor batchStore: BatchStore;
+    constructor(options?: EntityPresenterComponentOptions);
+}

package/dist/@types/entities/components/presenter/types/tree/InlineTreePresenterComponent.d.ts

@@ -0,0 +1,36 @@
+import { EntityTreePresenterComponent } from './EntityTreePresenterComponent';
+import { ReactorTreeEntity, ReactorTreeLeaf, ReactorTreeNode, TreeLeafWidgetProps, TreeWidgetProps } from '../../../../../widgets';
+import { EntityTreePresenterContext } from './presenter-contexts/EntityTreePresenterContext';
+import { AbstractEntityTreePresenterContext, GenerateTreeOptions } from './presenter-contexts/AbstractEntityTreePresenterContext';
+import { CachedEntityTreePresenterContext } from './presenter-contexts/CachedEntityTreePresenterContext';
+export interface BaseInlineTreePresenterComponentOptions<T> {
+    augmentTreeProps?: (entity: T, hover: boolean) => Partial<TreeLeafWidgetProps>;
+    augmentTreeNodeProps?: (entity: T, hover: boolean) => Partial<TreeWidgetProps>;
+}
+export interface InlineTreePresenterComponentOptions<T> extends BaseInlineTreePresenterComponentOptions<T> {
+    /**
+     * If true, will use the `CachedEntityTreePresenterContext` behind the scenes
+     */
+    cacheTreeEntities?: boolean;
+}
+export declare const patch_doGenerateTreeNode: (context: AbstractEntityTreePresenterContext, entity: any, events: any) => ReactorTreeNode | ReactorTreeLeaf;
+export declare const patch_generateTreeNode: (options: InlineTreePresenterComponentOptions<any>, treeEntity: ReactorTreeEntity, entity: any) => ReactorTreeNode | ReactorTreeLeaf;
+export declare class InlineTreePresenterContext<T> extends EntityTreePresenterContext<T> {
+    presenter: InlineTreePresenterComponent<T>;
+    protected options3: BaseInlineTreePresenterComponentOptions<T>;
+    constructor(presenter: InlineTreePresenterComponent<T>, options3?: BaseInlineTreePresenterComponentOptions<T>);
+    doGenerateTreeNode(entity: T, events: any): ReactorTreeNode | ReactorTreeLeaf;
+    generateTreeNode(entity: T, options?: GenerateTreeOptions<T>): ReactorTreeNode | ReactorTreeLeaf;
+}
+export declare class InlineCachedTreePresenterContext<T> extends CachedEntityTreePresenterContext<T> {
+    presenter: InlineTreePresenterComponent<T>;
+    protected options3: BaseInlineTreePresenterComponentOptions<T>;
+    constructor(presenter: InlineTreePresenterComponent<T>, options3?: BaseInlineTreePresenterComponentOptions<T>);
+    doGenerateTreeNode(entity: T, events: any): ReactorTreeNode | ReactorTreeLeaf;
+    generateTreeNode(entity: T, options?: GenerateTreeOptions<T>): ReactorTreeNode | ReactorTreeLeaf;
+}
+export declare class InlineTreePresenterComponent<T> extends EntityTreePresenterComponent<T> {
+    protected options3: InlineTreePresenterComponentOptions<T>;
+    constructor(options3?: InlineTreePresenterComponentOptions<T>);
+    protected _generateContext(): AbstractEntityTreePresenterContext<T>;
+}

package/dist/@types/entities/components/presenter/types/tree/presenter-contexts/AbstractEntityTreePresenterContext.d.ts

@@ -0,0 +1,40 @@
+import React from 'react';
+import { BaseObserverInterface } from '@journeyapps-labs/lib-reactor-utils';
+import { ReactorTreeEntity } from '../../../../../../widgets';
+import { AbstractPresenterContext, PresenterContextListener, RenderCollectionOptions } from '../../../AbstractPresenterContext';
+import { EntityTreePresenterComponent, EntityTreePresenterSettings, EntityTreePresenterState } from '../EntityTreePresenterComponent';
+import { SelectEntityListener } from '../../../EntityPresenterComponent';
+import { BatchStore } from '../../../../../../stores/batch/BatchStore';
+import { System } from '../../../../../../core/System';
+import { TreeNode } from '@journeyapps-labs/lib-reactor-tree';
+export interface GenerateTreeOptions<T> {
+    events?: BaseObserverInterface<SelectEntityListener<T>>;
+    disableCache?: boolean;
+}
+export interface TreePresenterGenerationEvent<T> {
+    entity: T;
+    tree: ReactorTreeEntity;
+}
+export interface AbstractTreePresenterContextListener<T extends any = any> extends PresenterContextListener {
+    treeGenerated?: (event: TreePresenterGenerationEvent<T>) => any;
+}
+export declare abstract class AbstractEntityTreePresenterContext<T extends any = any, Settings extends EntityTreePresenterSettings = EntityTreePresenterSettings> extends AbstractPresenterContext<T, EntityTreePresenterState, Settings, AbstractTreePresenterContextListener<T>> {
+    presenter: EntityTreePresenterComponent<T>;
+    accessor batchStore: BatchStore;
+    accessor system: System;
+    nodeCache: Set<TreeNode>;
+    rootContext: AbstractEntityTreePresenterContext;
+    constructor(presenter: EntityTreePresenterComponent<T>);
+    saveState(): void;
+    setRootContext(rootContext: AbstractEntityTreePresenterContext): void;
+    get definition(): import("../../../../../EntityDefinition").EntityDefinition<any>;
+    getSortedEntities(entities: T[]): T[];
+    getRootContext(): AbstractEntityTreePresenterContext<any, EntityTreePresenterSettings>;
+    getTreeNodes(event: RenderCollectionOptions<T>): ReactorTreeEntity[];
+    protected abstract doGetTreeNodes(event: RenderCollectionOptions<T>): ReactorTreeEntity[];
+    protected abstract doGenerateTreeNode(entity: T, options?: GenerateTreeOptions<T>): ReactorTreeEntity;
+    generateTreeNode(entity: T, options?: GenerateTreeOptions<T>): ReactorTreeEntity;
+    protected patchTreeInteractions(tree: ReactorTreeEntity, entity: T): void;
+    renderCollection(event: RenderCollectionOptions<T>): React.JSX.Element;
+    render(entity: T): React.JSX.Element;
+}

package/dist/@types/entities/components/presenter/types/tree/presenter-contexts/CachedEntityTreePresenterContext.d.ts

@@ -0,0 +1,9 @@
+import { ReactorTreeEntity } from '../../../../../../widgets';
+import { RenderCollectionOptions } from '../../../AbstractPresenterContext';
+import { EntityTreePresenterComponent, EntityTreePresenterSettings } from '../EntityTreePresenterComponent';
+import { AbstractEntityTreePresenterContext } from './AbstractEntityTreePresenterContext';
+export declare abstract class CachedEntityTreePresenterContext<T extends any = any, Settings extends EntityTreePresenterSettings = EntityTreePresenterSettings> extends AbstractEntityTreePresenterContext<T, Settings> {
+    accessor cachedNodes: Map<T, ReactorTreeEntity>;
+    constructor(presenter: EntityTreePresenterComponent<T>);
+    protected doGetTreeNodes(event: RenderCollectionOptions<T>): ReactorTreeEntity[];
+}

package/dist/@types/entities/components/presenter/types/tree/presenter-contexts/EntityTreePresenterContext.d.ts

@@ -0,0 +1,7 @@
+import { ReactorTreeEntity } from '../../../../../../widgets';
+import { RenderCollectionOptions } from '../../../AbstractPresenterContext';
+import { EntityTreePresenterSettings } from '../EntityTreePresenterComponent';
+import { AbstractEntityTreePresenterContext } from './AbstractEntityTreePresenterContext';
+export declare abstract class EntityTreePresenterContext<T extends any = any, Settings extends EntityTreePresenterSettings = EntityTreePresenterSettings> extends AbstractEntityTreePresenterContext<T, Settings> {
+    protected doGetTreeNodes(event: RenderCollectionOptions<T>): ReactorTreeEntity[];
+}

package/dist/@types/entities/components/presenter/types/tree/widgets/ReactorEntityDnDWrapperWidget.d.ts

@@ -0,0 +1,10 @@
+import { IBaseReactorTree } from '../../../../../../widgets';
+import * as React from 'react';
+import { EntityDefinition } from '../../../../../EntityDefinition';
+export interface ReactorEntityDnDWrapperProps {
+    entity: any;
+    node: IBaseReactorTree;
+    children: (ref: React.RefObject<HTMLDivElement>) => React.JSX.Element;
+    definition: EntityDefinition;
+}
+export declare const ReactorEntityDnDWrapper: React.FC<ReactorEntityDnDWrapperProps>;

package/dist/@types/entities/components/presenter/types/tree/widgets/ReactorEntityWrapperWidget.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { EntityReactorNode, EntityReactorNodeOptions } from '../EntityReactorNode';
+import { EntityReactorLeaf } from '../EntityReactorLeaf';
+export interface ReactorEntityWrapperWidgetProps {
+    options: EntityReactorNodeOptions;
+    node: EntityReactorNode | EntityReactorLeaf;
+    forwardRef: React.RefObject<HTMLDivElement>;
+}
+export declare const ReactorEntityWrapperWidget: React.FC<React.PropsWithChildren<ReactorEntityWrapperWidgetProps>>;

package/dist/@types/entities/components/search/EntitySearchEngineComponent.d.ts

@@ -0,0 +1,29 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+import { CMDPalletSearchEngine, CommandPalletSearchEngineOptions } from '../../../cmd-pallet/CMDPalletSearchEngine';
+import { SearchEngine } from '../../../search/SearchEngine';
+import { MousePosition } from '../../../layers/combo/SmartPositionWidget';
+import { SearchEngineComboBoxDirective } from '../../../stores/combo2/directives/SearchEngineComboBoxDirective';
+import { ComboBoxItem } from '../../../stores/combo/ComboBoxDirectives';
+import { SearchResult, SearchResultEntry } from '@journeyapps-labs/lib-reactor-search';
+export interface EntitySearchResultEntry<T = any> extends SearchResultEntry {
+    entity: T;
+}
+export interface EntitySearchEngineComponentOptions {
+    label: string;
+}
+export interface EntityComboBoxItem<T> extends ComboBoxItem {
+    entity: T;
+}
+export interface GetComboBoxDirectiveOptions<T> {
+    position: MousePosition;
+    filter?: (entity: T) => boolean;
+}
+export declare abstract class EntitySearchEngineComponent<T extends any = any> extends EntityDefinitionComponent {
+    protected options: EntitySearchEngineComponentOptions;
+    static TYPE: string;
+    constructor(options: EntitySearchEngineComponentOptions);
+    abstract getSearchEngine(): SearchEngine<SearchResult<EntitySearchResultEntry<T>>>;
+    getCmdPaletteSearchEngine(options?: Omit<CommandPalletSearchEngineOptions, 'displayName'>): CMDPalletSearchEngine;
+    getLabel(): string;
+    getComboBoxDirective(event: GetComboBoxDirectiveOptions<T>): SearchEngineComboBoxDirective<EntitySearchResultEntry<T>, EntityComboBoxItem<T>>;
+}

package/dist/@types/entities/components/search/SimpleEntitySearchEngineComponent.d.ts

@@ -0,0 +1,23 @@
+import { EntitySearchEngineComponent, EntitySearchEngineComponentOptions, EntitySearchResultEntry } from './EntitySearchEngineComponent';
+import { SearchEngine, SearchEngineSearchEvent } from '../../../search/SearchEngine';
+import { SearchResult } from '@journeyapps-labs/lib-reactor-search';
+export interface SimpleEntitySearchEngineComponentOptions<T> extends EntitySearchEngineComponentOptions {
+    getEntities: (event: SearchEngineSearchEvent) => Promise<T[]>;
+    /**
+     * Defaults to true
+     */
+    filterResultsWithMatcher?: boolean;
+}
+export declare class SimpleEntitySearchEngineComponent<T extends any = any> extends EntitySearchEngineComponent<T> {
+    options2: SimpleEntitySearchEngineComponentOptions<T>;
+    constructor(options2: SimpleEntitySearchEngineComponentOptions<T>);
+    getEntities(event: SearchEngineSearchEvent): Promise<T[]>;
+    getSearchEngine(): SearchEngine<SearchResult<EntitySearchResultEntry<T>>>;
+}
+export declare class SimpleEntitySearchEngine<T> extends SearchEngine<SearchResult<EntitySearchResultEntry<T>>> {
+    protected component: SimpleEntitySearchEngineComponent;
+    constructor(component: SimpleEntitySearchEngineComponent);
+    autoSelectIsolatedItem(event: SearchEngineSearchEvent): Promise<any>;
+    getFilteredEntities(event: SearchEngineSearchEvent): Promise<any[]>;
+    search(event: SearchEngineSearchEvent): SearchResult<EntitySearchResultEntry<T>>;
+}

package/dist/@types/entities/components/search/SimpleParentEntitySearchEngine.d.ts

@@ -0,0 +1,25 @@
+import { MousePosition } from '../../../layers/combo/SmartPositionWidget';
+import { SimpleEntitySearchEngineComponent, SimpleEntitySearchEngineComponentOptions } from './SimpleEntitySearchEngineComponent';
+import { EntityComboBoxItem, EntitySearchResultEntry, GetComboBoxDirectiveOptions } from './EntitySearchEngineComponent';
+import { SearchEngine, SearchEngineSearchEvent } from '../../../search/SearchEngine';
+import { CMDPalletSearchEngine } from '../../../cmd-pallet/CMDPalletSearchEngine';
+import { SearchResult } from '@journeyapps-labs/lib-reactor-search';
+import { ComboBoxDirective } from '../../../stores/combo2/ComboBoxDirective';
+export declare const PARENT_VARIABLE = "parent";
+export interface SimpleParentEntitySearchEngineOptions<Parent, Item> extends SimpleEntitySearchEngineComponentOptions<Item> {
+    type: string;
+    getEntities: (event: SearchEngineSearchEvent<{
+        [PARENT_VARIABLE]: Parent;
+    }>) => Promise<Item[]>;
+}
+export declare class SimpleParentEntitySearchEngine<P, E> extends SimpleEntitySearchEngineComponent<E> {
+    protected options3: SimpleParentEntitySearchEngineOptions<P, E>;
+    constructor(options3: SimpleParentEntitySearchEngineOptions<P, E>);
+    getParents(event: {
+        position: MousePosition;
+    }): ComboBoxDirective<any, import("../../../stores/combo2/ComboBoxDirective").ComboBoxDirectiveOptions<any>>[];
+    getCmdPaletteSearchEngine(): CMDPalletSearchEngine;
+    getSearchEngine(): SearchEngine<SearchResult<EntitySearchResultEntry<E>>>;
+    getFlattenedComboBoxDirective(event: GetComboBoxDirectiveOptions<E>): ComboBoxDirective<EntityComboBoxItem<any>>[];
+    getComboBoxDirective(event: GetComboBoxDirectiveOptions<E>): any;
+}

package/dist/@types/entities/components/ui/EntityPanelComponent.d.ts

@@ -0,0 +1,36 @@
+import { EntityDefinitionComponent } from '../../EntityDefinitionComponent';
+import { EntityPanelFactory, EntityPanelModel } from './widgets/EntityPanelFactory';
+import { ReactorIcon } from '../../../widgets';
+import { Action } from '../../../actions';
+import { EntityPresenterComponent } from '../presenter/EntityPresenterComponent';
+import * as _ from 'lodash';
+export interface GetEntityEvent<T> {
+    presenter: EntityPresenterComponent<T>;
+    model: EntityPanelModel;
+}
+export interface EntityPanelComponentOptions<T extends any> {
+    legacyType?: string;
+    label?: string;
+    /**
+     * The label of the default presenter, if null will select the first one
+     */
+    defaultPresenter?: string;
+    icon?: ReactorIcon;
+    iconColor?: string;
+    getEntities: (event: GetEntityEvent<T>) => T[];
+    isLoading?: () => boolean;
+    additionalActions?: string[];
+}
+export declare class EntityPanelComponent<T extends any = any> extends EntityDefinitionComponent {
+    options: EntityPanelComponentOptions<T>;
+    static TYPE: string;
+    additionalActions: string[];
+    constructor(options: EntityPanelComponentOptions<T>);
+    getEntities(event: GetEntityEvent<T>): T[];
+    registerAdditionalAction(action: Action): void;
+    generatePanelFactory: (() => EntityPanelFactory<unknown>) & _.MemoizedFunction;
+    get defaultPresenterLabel(): string;
+    get icon(): ReactorIcon;
+    get iconColor(): string | import("../../../widgets").ReactorCharIcon | import("../../../widgets").ReactorUrlIcon;
+    generateFactoryType(): string;
+}