@journeyapps-labs/reactor-mod-data-browser 0.0.0-dev-20250825225306

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# @journeyapps-labs/reactor-mod-data-browser
+
+## 0.0.0-dev-20250825225306
+
+### Minor Changes
+
+- 8cc96ec: - displays media directly inside Sector
+  - add media input fields to form editing
+  - status bar for schema model editing
+  - make query reload button show load status
+  - Add support for Locations
+  - Pull in Reactor changes: Version Packages reactor#36
+
+## 2.0.2
+
+### Patch Changes
+
+- 375d338: Add support for Day and number type
+
+## 2.0.1
+
+### Patch Changes
+
+- 0f04f63: Fix an issue with text not showing correctly and also improve array items
+
+## 2.0.0
+
+### Major Changes
+
+- 3438cf4: Name of connection changed to an EntityDescription and also export shared db library
+
+## 1.1.0
+
+### Minor Changes
+
+- cd5ddb0: Export various classes and types
+
+## 1.0.0
+
+### Major Changes
+
+- 60d9391: First release

package/README.md

@@ -0,0 +1,3 @@
+# Reactor module Databrowser
+
+This module acts as the scaffolding and core for the databrowser experience.

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

@@ -0,0 +1,7 @@
+import { AbstractReactorModule } from '@journeyapps-labs/reactor-mod';
+import { Container } from '@journeyapps-labs/common-ioc';
+export declare class DataBrowserModule extends AbstractReactorModule {
+    constructor();
+    register(ioc: Container): void;
+    init(ioc: Container): Promise<any>;
+}

package/dist/@types/actions/connections/AddConnectionAction.d.ts

@@ -0,0 +1,10 @@
+import { EntityAction, EntityActionEvent } from '@journeyapps-labs/reactor-mod';
+import { AbstractConnectionFactory } from '../../core/AbstractConnectionFactory';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+export declare class AddConnectionAction extends EntityAction<AbstractConnectionFactory> {
+    static ID: string;
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<AbstractConnectionFactory>): Promise<any>;
+    static get(): AddConnectionAction;
+}

package/dist/@types/actions/connections/RemoveConnectionAction.d.ts

@@ -0,0 +1,10 @@
+import { EntityAction, EntityActionEvent } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { AbstractConnection } from '../../core/AbstractConnection';
+export declare class RemoveConnectionAction extends EntityAction<AbstractConnection> {
+    static ID: string;
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<AbstractConnection>): Promise<any>;
+    static get(): RemoveConnectionAction;
+}

package/dist/@types/actions/schema-definitions/CreateModelAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../../core/SchemaModelDefinition';
+export declare class CreateModelAction extends EntityAction<SchemaModelDefinition> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<SchemaModelDefinition>): Promise<any>;
+    static get(): CreateModelAction;
+}

package/dist/@types/actions/schema-definitions/QuerySchemaModelAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../../core/SchemaModelDefinition';
+export declare class QuerySchemaModelAction extends EntityAction<SchemaModelDefinition> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<SchemaModelDefinition>): Promise<any>;
+    static get(): QuerySchemaModelAction;
+}

package/dist/@types/actions/schema-model/EditSchemaModelAction.d.ts

@@ -0,0 +1,9 @@
+import { EntityAction, EntityActionEvent, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelObject } from '../../core/SchemaModelObject';
+export declare class EditSchemaModelAction extends EntityAction<SchemaModelObject> {
+    static ID: string;
+    accessor workspaceStore: WorkspaceStore;
+    constructor();
+    fireEvent(event: EntityActionEvent<SchemaModelObject>): Promise<any>;
+    static get(): EditSchemaModelAction;
+}

package/dist/@types/core/AbstractConnection.d.ts

@@ -0,0 +1,34 @@
+import { Database, ObjectType } from '@journeyapps/db';
+import { Schema } from '@journeyapps/parser-schema';
+import { AbstractConnectionFactory } from './AbstractConnectionFactory';
+import { SchemaModelDefinition } from './SchemaModelDefinition';
+import { BaseObserver } from '@journeyapps-labs/common-utils';
+import { Collection, LifecycleCollection } from '@journeyapps-labs/lib-reactor-data-layer';
+import { EntityDescription } from '@journeyapps-labs/reactor-mod';
+export interface AbstractConnectionSerialized {
+    factory: string;
+    id: string;
+    payload: any;
+}
+export interface AbstractConnectionListener {
+    removed: () => any;
+}
+export declare abstract class AbstractConnection extends BaseObserver<AbstractConnectionListener> {
+    factory: AbstractConnectionFactory;
+    id: string;
+    schema_models_collection: Collection<ObjectType>;
+    schema_models: LifecycleCollection<ObjectType, SchemaModelDefinition>;
+    constructor(factory: AbstractConnectionFactory);
+    getSchemaModelDefinitionByName(name: string): SchemaModelDefinition;
+    waitForSchemaModelDefinitionByName(name: string): Promise<SchemaModelDefinition>;
+    abstract getConnection(): Promise<Database>;
+    protected getSchema(): Promise<Schema>;
+    reload(): Promise<void>;
+    init(): Promise<void>;
+    protected getSchemaModelDefinitions(): Promise<SchemaModelDefinition[]>;
+    remove(): void;
+    serialize(): AbstractConnectionSerialized;
+    get name(): EntityDescription;
+    abstract _serialize(): any;
+    abstract _deSerialize(data: ReturnType<this['_serialize']>): Promise<any>;
+}

package/dist/@types/core/AbstractConnectionFactory.d.ts

@@ -0,0 +1,11 @@
+import { AbstractConnection } from './AbstractConnection';
+export interface ConnectionFactoryOptions {
+    label: string;
+    key: string;
+}
+export declare abstract class AbstractConnectionFactory<T extends AbstractConnection = AbstractConnection> {
+    options: ConnectionFactoryOptions;
+    constructor(options: ConnectionFactoryOptions);
+    abstract generateConnection(): T;
+    abstract generateConnectionFromUI(): Promise<T | null>;
+}

package/dist/@types/core/SchemaModelDefinition.d.ts

@@ -0,0 +1,20 @@
+import { AbstractConnection } from './AbstractConnection';
+import { ObjectType } from '@journeyapps/parser-schema';
+import { Collection } from '@journeyapps/db';
+import { SchemaModelObject } from './SchemaModelObject';
+import { LifecycleModel } from '@journeyapps-labs/lib-reactor-data-layer';
+export interface SchemaModelDefinitionOptions {
+    connection: AbstractConnection;
+    definition: ObjectType;
+}
+export declare class SchemaModelDefinition implements LifecycleModel<ObjectType> {
+    protected options: SchemaModelDefinitionOptions;
+    constructor(options: SchemaModelDefinitionOptions);
+    get key(): string;
+    dispose(): void;
+    patch(data: ObjectType): void;
+    get connection(): AbstractConnection;
+    get definition(): ObjectType;
+    getCollection(): Promise<Collection<import("@journeyapps/db").DatabaseObject>>;
+    generateNewModelObject(): Promise<SchemaModelObject>;
+}

package/dist/@types/core/SchemaModelObject.d.ts

@@ -0,0 +1,16 @@
+import { DatabaseObject } from '@journeyapps/db';
+import { SchemaModelDefinition } from './SchemaModelDefinition';
+import { AbstractMedia, MediaEngine } from '@journeyapps-labs/reactor-mod';
+export interface SchemaModelObjectOptions {
+    definition: SchemaModelDefinition;
+    model?: DatabaseObject;
+}
+export declare class SchemaModelObject {
+    options: SchemaModelObjectOptions;
+    accessor mediaEngine: MediaEngine;
+    private _mediaCache;
+    constructor(options: SchemaModelObjectOptions);
+    get definition(): SchemaModelDefinition;
+    get model(): DatabaseObject;
+    getMedia(field: string): Promise<AbstractMedia<import("@journeyapps-labs/reactor-mod").AbstractMediaOptions>>;
+}

package/dist/@types/core/query/AbstractQuery.d.ts

@@ -0,0 +1,22 @@
+import { Page } from './Page';
+import { AbstractConnection } from '../AbstractConnection';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { TableColumn } from '@journeyapps-labs/reactor-mod';
+export interface AbstractQueryEncoded {
+    type: string;
+    connection_id: string;
+    definition: string;
+}
+export declare abstract class AbstractQuery<T extends AbstractQueryEncoded = AbstractQueryEncoded> {
+    protected type: string;
+    protected connection: AbstractConnection;
+    id: string;
+    constructor(type: string, connection: AbstractConnection);
+    abstract getSimpleName(): string;
+    abstract load(): Promise<any>;
+    abstract getColumns(): TableColumn[];
+    abstract get totalPages(): number;
+    abstract getPage(number: number): Page;
+    serialize(): T;
+    deserialize(connectionStore: ConnectionStore, data: T): Promise<void>;
+}

package/dist/@types/core/query/Page.d.ts

@@ -0,0 +1,24 @@
+import { SchemaModelObject } from '../SchemaModelObject';
+import { TableRow } from '@journeyapps-labs/reactor-mod';
+import { Collection, DatabaseObject } from '@journeyapps/db';
+import { SchemaModelDefinition } from '../SchemaModelDefinition';
+export interface PageRow extends TableRow {
+    model: SchemaModelObject;
+    definition: SchemaModelDefinition;
+}
+export interface PageOptions {
+    collection: () => Promise<Collection<DatabaseObject>>;
+    offset: number;
+    limit: number;
+    definition: SchemaModelDefinition;
+    index: number;
+}
+export declare class Page {
+    protected options: PageOptions;
+    accessor models: SchemaModelObject[];
+    accessor loading: boolean;
+    constructor(options: PageOptions);
+    get index(): number;
+    load(): Promise<void>;
+    asRows(): PageRow[];
+}

package/dist/@types/core/query/SimpleQuery.d.ts

@@ -0,0 +1,37 @@
+import { AbstractQuery, AbstractQueryEncoded } from './AbstractQuery';
+import { TableColumn } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import * as db from '@journeyapps/db';
+import { Promise, Variable } from '@journeyapps/db';
+import { Page, PageRow } from './Page';
+import { SchemaModelDefinition } from '../SchemaModelDefinition';
+import * as React from 'react';
+export interface SimpleQueryOptions {
+    definition?: SchemaModelDefinition;
+    limit?: number;
+}
+export interface SimpleQueryEncoded extends AbstractQueryEncoded {
+    limit: number;
+    definition: string;
+}
+export declare class SimpleQuery extends AbstractQuery<SimpleQueryEncoded> {
+    options: SimpleQueryOptions;
+    accessor connStore: ConnectionStore;
+    accessor _totalPages: number;
+    accessor _pages: Page[];
+    constructor(options?: SimpleQueryOptions);
+    getCollection(): globalThis.Promise<db.database.Collection<db.database.DatabaseObject>>;
+    load(): globalThis.Promise<void>;
+    getPage(number: number): Page;
+    get totalPages(): number;
+    serialize(): SimpleQueryEncoded;
+    deserialize(connectionStore: ConnectionStore, data: SimpleQueryEncoded): Promise<void>;
+    getColumns(): TableColumn[];
+    getSimpleName(): string;
+}
+export interface CellDisplayWidgetProps {
+    row: PageRow;
+    cell: any;
+    variable: Variable;
+}
+export declare const CellDisplayWidget: React.FC<CellDisplayWidgetProps>;

package/dist/@types/core/types/ManualConnection.d.ts

@@ -0,0 +1,15 @@
+import { ApiCredentialOptions, Database } from '@journeyapps/db';
+import { AbstractConnection } from '../AbstractConnection';
+import { ManualConnectionFactory } from './ManualConnectionFactory';
+import { EntityDescription } from '@journeyapps-labs/reactor-mod';
+export interface ManualConnectionDetails extends ApiCredentialOptions {
+    name: string;
+}
+export declare class ManualConnection extends AbstractConnection {
+    protected options?: ManualConnectionDetails;
+    constructor(factory: ManualConnectionFactory, options?: ManualConnectionDetails);
+    getConnection(): Promise<Database>;
+    _serialize(): ManualConnectionDetails;
+    _deSerialize(data: ManualConnectionDetails): Promise<any>;
+    get name(): EntityDescription;
+}

package/dist/@types/core/types/ManualConnectionFactory.d.ts

@@ -0,0 +1,9 @@
+import { AbstractConnectionFactory } from '../AbstractConnectionFactory';
+import { ManualConnection } from './ManualConnection';
+import { DialogStore2 } from '@journeyapps-labs/reactor-mod';
+export declare class ManualConnectionFactory extends AbstractConnectionFactory<ManualConnection> {
+    accessor dialogStore: DialogStore2;
+    constructor();
+    generateConnectionFromUI(): Promise<ManualConnection | null>;
+    generateConnection(): ManualConnection;
+}

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

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { AbstractConnection } from '../core/AbstractConnection';
+export declare class ConnectionEntityDefinition extends EntityDefinition<AbstractConnection> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: AbstractConnection): string;
+}

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

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { AbstractConnectionFactory } from '../core/AbstractConnectionFactory';
+export declare class ConnectionFactoryEntityDefinition extends EntityDefinition<AbstractConnectionFactory> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: AbstractConnectionFactory): string;
+}

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

@@ -0,0 +1,9 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { AbstractQuery } from '../core/query/AbstractQuery';
+export declare class QueryEntityDefinition extends EntityDefinition<AbstractQuery> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: AbstractQuery): string;
+}

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

@@ -0,0 +1,13 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { SchemaModelDefinition } from '../core/SchemaModelDefinition';
+export interface SchemaModelDefinitionEntityDefinitionEncoded {
+    connection_id: string;
+    type: string;
+}
+export declare class SchemaModelDefinitionEntityDefinition extends EntityDefinition<SchemaModelDefinition> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: SchemaModelDefinition): string;
+}

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

@@ -0,0 +1,14 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../stores/ConnectionStore';
+import { SchemaModelObject } from '../core/SchemaModelObject';
+export interface SchemaModelObjectEntityDefinitionEncoded {
+    connection_id: string;
+    type: string;
+    id: string;
+}
+export declare class SchemaModelObjectEntityDefinition extends EntityDefinition<SchemaModelObject> {
+    accessor connectionStore: ConnectionStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: SchemaModelObject): string;
+}

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

@@ -0,0 +1,7 @@
+export declare enum DataBrowserEntities {
+    CONNECTION = "databrowser/connection",
+    CONNECTION_FACTORY = "databrowser/connection_factory",
+    SCHEMA_MODEL_DEFINITION = "databrowser/schema_model_definition",
+    SCHEMA_MODEL_OBJECT = "databrowser/schema_model_object",
+    QUERY = "databrowser/query"
+}

package/dist/@types/forms/APIConnectionForm.d.ts

@@ -0,0 +1,12 @@
+import { FormModel } from '@journeyapps-labs/reactor-mod';
+import { ManualConnection } from '../core/types/ManualConnection';
+import { ManualConnectionFactory } from '../core/types/ManualConnectionFactory';
+export interface APIConnectionFormValue {
+    name: string;
+    base_url: string;
+    api_token: string;
+}
+export declare class APIConnectionForm extends FormModel<APIConnectionFormValue> {
+    constructor(value?: APIConnectionFormValue);
+    generateConnection(factory: ManualConnectionFactory): ManualConnection;
+}

package/dist/@types/forms/SchemaModelForm.d.ts

@@ -0,0 +1,11 @@
+import { FormModel } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../core/SchemaModelDefinition';
+import { SchemaModelObject } from '../core/SchemaModelObject';
+export interface SchemaModelFormOptions {
+    definition: SchemaModelDefinition;
+    object?: SchemaModelObject;
+}
+export declare class SchemaModelForm extends FormModel {
+    protected options: SchemaModelFormOptions;
+    constructor(options: SchemaModelFormOptions);
+}

package/dist/@types/forms/inputs/LocationInput.d.ts

@@ -0,0 +1,13 @@
+import { FormInput, FormInputGenerics, FormInputOptions, FormInputRenderOptions, NumberInput } from '@journeyapps-labs/reactor-mod';
+import * as React from 'react';
+import { Location } from '@journeyapps/db';
+export declare class LocationInput extends FormInput<FormInputGenerics & {
+    VALUE: Location;
+}> {
+    latitude: NumberInput;
+    longitude: NumberInput;
+    constructor(options: FormInputOptions<Location>);
+    setValue(value: Location): void;
+    update(): void;
+    renderControl(options: FormInputRenderOptions): React.JSX.Element;
+}

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

@@ -0,0 +1,25 @@
+import { DataBrowserModule } from './DataBrowserModule';
+export * from './entities';
+export * from './core/SchemaModelDefinition';
+export * from './core/SchemaModelObject';
+export * from './core/AbstractConnection';
+export * from './core/AbstractConnectionFactory';
+export * from './core/query/SimpleQuery';
+export * from './core/query/AbstractQuery';
+export * from './core/query/Page';
+export * from './core/types/ManualConnectionFactory';
+export * from './core/types/ManualConnection';
+export * from './entities/QueryEntityDefinition';
+export * from './entities/ConnectionEntityDefinition';
+export * from './entities/ConnectionFactoryEntityDefinition';
+export * from './entities/SchemaModelDefinitionEntityDefinition';
+export * from './entities/SchemaModelObjectEntityDefinition';
+export * from './panels/query/QueryPanelFactory';
+export * from './panels/model/ModelPanelFactory';
+export * from './stores/ConnectionStore';
+export * from './actions/connections/AddConnectionAction';
+export * from './actions/connections/RemoveConnectionAction';
+export * from './actions/schema-definitions/CreateModelAction';
+export * from './actions/schema-definitions/QuerySchemaModelAction';
+export * from './actions/schema-model/EditSchemaModelAction';
+export default DataBrowserModule;

package/dist/@types/panels/model/ModelPanelFactory.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { ReactorPanelFactory, ReactorPanelModel } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { WorkspaceModelFactoryEvent } from '@projectstorm/react-workspaces-core';
+import { SchemaModelDefinition } from '../../core/SchemaModelDefinition';
+import { SchemaModelObject } from '../../core/SchemaModelObject';
+export interface ModelPanelModelOptions {
+    definition: SchemaModelDefinition;
+    model?: SchemaModelObject;
+}
+export declare class ModelPanelModel extends ReactorPanelModel {
+    accessor connStore: ConnectionStore;
+    accessor definition: SchemaModelDefinition;
+    accessor model: SchemaModelObject;
+    constructor(options?: ModelPanelModelOptions);
+    encodeEntities(): {
+        definition: SchemaModelDefinition;
+        model: SchemaModelObject;
+    };
+    decodeEntities(data: ReturnType<this['encodeEntities']>): void;
+}
+export declare class ModelPanelFactory extends ReactorPanelFactory<ModelPanelModel> {
+    static TYPE: string;
+    constructor();
+    getSimpleName(model: ModelPanelModel): string;
+    _generateModel(): ModelPanelModel;
+    generatePanelContent(event: WorkspaceModelFactoryEvent<ModelPanelModel>): React.JSX.Element;
+}

package/dist/@types/panels/model/ModelPanelWidget.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { ModelPanelModel } from './ModelPanelFactory';
+export interface QueryPanelWidgetProps {
+    model: ModelPanelModel;
+}
+export declare const ModelPanelWidget: React.FC<QueryPanelWidgetProps>;

package/dist/@types/panels/query/PageResultsWidget.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { Page } from '../../core/query/Page';
+import { AbstractQuery } from '../../core/query/AbstractQuery';
+export interface PageResultsWidgetProps {
+    page: Page;
+    query: AbstractQuery;
+}
+export declare const PageResultsWidget: React.FC<PageResultsWidgetProps>;

package/dist/@types/panels/query/QueryPanelFactory.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { ReactorPanelFactory, ReactorPanelModel } from '@journeyapps-labs/reactor-mod';
+import { AbstractQuery } from '../../core/query/AbstractQuery';
+import { ConnectionStore } from '../../stores/ConnectionStore';
+import { WorkspaceModelFactoryEvent } from '@projectstorm/react-workspaces-core';
+export declare class QueryPanelModel extends ReactorPanelModel {
+    accessor connStore: ConnectionStore;
+    accessor query: AbstractQuery;
+    accessor current_page: number;
+    constructor(query: AbstractQuery);
+    toArray(): {
+        current_page: number;
+        _encoded: {};
+        id: string;
+        expandVertical: boolean;
+        expandHorizontal: boolean;
+        type: string;
+        width: number;
+        height: number;
+    };
+    fromArray(data: ReturnType<this['toArray']>, engine: any): void;
+    encodeEntities(): {
+        query: AbstractQuery<import("../../core/query/AbstractQuery").AbstractQueryEncoded>;
+    };
+    decodeEntities(data: ReturnType<this['encodeEntities']>): void;
+}
+export declare class QueryPanelFactory extends ReactorPanelFactory<QueryPanelModel> {
+    static TYPE: string;
+    constructor();
+    getSimpleName(model: QueryPanelModel): string;
+    _generateModel(): QueryPanelModel;
+    generatePanelContent(event: WorkspaceModelFactoryEvent<QueryPanelModel>): React.JSX.Element;
+}

package/dist/@types/panels/query/QueryPanelWidget.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { QueryPanelModel } from './QueryPanelFactory';
+export interface QueryPanelWidgetProps {
+    model: QueryPanelModel;
+}
+export declare const QueryPanelWidget: React.FC<QueryPanelWidgetProps>;

package/dist/@types/panels/query/TableControlsWidget.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { AbstractQuery } from '../../core/query/AbstractQuery';
+import { Page } from '../../core/query/Page';
+export interface TableControlsWidgetProps {
+    current_page: Page;
+    goToPage?: (index: number) => any;
+    className?: any;
+    query: AbstractQuery;
+}
+export declare const TableControlsWidget: React.FC<TableControlsWidgetProps>;

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

@@ -0,0 +1,20 @@
+import { AbstractStore } from '@journeyapps-labs/reactor-mod';
+import { AbstractConnection, AbstractConnectionSerialized } from '../core/AbstractConnection';
+import { AbstractConnectionFactory } from '../core/AbstractConnectionFactory';
+export interface ConnectionStoreSerialized {
+    connections: AbstractConnectionSerialized[];
+}
+export declare class ConnectionStore extends AbstractStore<ConnectionStoreSerialized> {
+    protected accessor _connections: Set<AbstractConnection>;
+    protected _connectionFactories: Map<string, AbstractConnectionFactory>;
+    constructor();
+    get connections(): AbstractConnection[];
+    get connectionFactories(): AbstractConnectionFactory<AbstractConnection>[];
+    protected serialize(): ConnectionStoreSerialized;
+    getConnectionByID(id: string): AbstractConnection;
+    waitForReadyForConnection(id: string): Promise<AbstractConnection>;
+    deserializeConnection(data: AbstractConnectionSerialized): Promise<AbstractConnection>;
+    protected deserialize(data: ConnectionStoreSerialized): Promise<void>;
+    registerConnectionFactory(factory: AbstractConnectionFactory): void;
+    addConnection(connection: AbstractConnection): void;
+}

package/dist/DataBrowserModule.js

@@ -0,0 +1,45 @@
+import { AbstractReactorModule, System, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { ConnectionStore } from './stores/ConnectionStore';
+import { ConnectionEntityDefinition } from './entities/ConnectionEntityDefinition';
+import { ManualConnectionFactory } from './core/types/ManualConnectionFactory';
+import { ConnectionFactoryEntityDefinition } from './entities/ConnectionFactoryEntityDefinition';
+import { AddConnectionAction } from './actions/connections/AddConnectionAction';
+import { RemoveConnectionAction } from './actions/connections/RemoveConnectionAction';
+import { SchemaModelDefinitionEntityDefinition } from './entities/SchemaModelDefinitionEntityDefinition';
+import { QueryPanelFactory } from './panels/query/QueryPanelFactory';
+import { QuerySchemaModelAction } from './actions/schema-definitions/QuerySchemaModelAction';
+import { QueryEntityDefinition } from './entities/QueryEntityDefinition';
+import { ModelPanelFactory } from './panels/model/ModelPanelFactory';
+import { CreateModelAction } from './actions/schema-definitions/CreateModelAction';
+import { SchemaModelObjectEntityDefinition } from './entities/SchemaModelObjectEntityDefinition';
+import { EditSchemaModelAction } from './actions/schema-model/EditSchemaModelAction';
+export class DataBrowserModule extends AbstractReactorModule {
+    constructor() {
+        super({
+            name: 'Data Browser'
+        });
+    }
+    register(ioc) {
+        const system = ioc.get(System);
+        const workspaceStore = ioc.get(WorkspaceStore);
+        let connectionStore = new ConnectionStore();
+        connectionStore.registerConnectionFactory(new ManualConnectionFactory());
+        system.registerAction(new AddConnectionAction());
+        system.registerAction(new RemoveConnectionAction());
+        system.registerAction(new QuerySchemaModelAction());
+        system.registerAction(new CreateModelAction());
+        system.registerAction(new EditSchemaModelAction());
+        system.addStore(ConnectionStore, connectionStore);
+        system.registerDefinition(new ConnectionEntityDefinition());
+        system.registerDefinition(new ConnectionFactoryEntityDefinition());
+        system.registerDefinition(new SchemaModelDefinitionEntityDefinition());
+        system.registerDefinition(new SchemaModelObjectEntityDefinition());
+        system.registerDefinition(new QueryEntityDefinition());
+        workspaceStore.registerFactory(new QueryPanelFactory());
+        workspaceStore.registerFactory(new ModelPanelFactory());
+    }
+    async init(ioc) {
+        await ioc.get(ConnectionStore).init();
+    }
+}
+//# sourceMappingURL=DataBrowserModule.js.map

package/dist/DataBrowserModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataBrowserModule.js","sourceRoot":"","sources":["../src/DataBrowserModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAE9F,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,iCAAiC,EAAE,MAAM,8CAA8C,CAAC;AACjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AACtF,OAAO,EAAE,qCAAqC,EAAE,MAAM,kDAAkD,CAAC;AACzG,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qDAAqD,CAAC;AAC7F,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,iCAAiC,EAAE,MAAM,8CAA8C,CAAC;AACjG,OAAO,EAAE,qBAAqB,EAAE,MAAM,8CAA8C,CAAC;AAErF,MAAM,OAAO,iBAAkB,SAAQ,qBAAqB;IAC1D;QACE,KAAK,CAAC;YACJ,IAAI,EAAE,cAAc;SACrB,CAAC,CAAC;IACL,CAAC;IAED,QAAQ,CAAC,GAAc;QACrB,MAAM,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAC/B,MAAM,cAAc,GAAG,GAAG,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QAE/C,IAAI,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;QAE5C,eAAe,CAAC,yBAAyB,CAAC,IAAI,uBAAuB,EAAE,CAAC,CAAC;QAEzE,MAAM,CAAC,cAAc,CAAC,IAAI,mBAAmB,EAAE,CAAC,CAAC;QACjD,MAAM,CAAC,cAAc,CAAC,IAAI,sBAAsB,EAAE,CAAC,CAAC;QACpD,MAAM,CAAC,cAAc,CAAC,IAAI,sBAAsB,EAAE,CAAC,CAAC;QACpD,MAAM,CAAC,cAAc,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;QAC/C,MAAM,CAAC,cAAc,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;QAEnD,MAAM,CAAC,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;QAElD,MAAM,CAAC,kBAAkB,CAAC,IAAI,0BAA0B,EAAE,CAAC,CAAC;QAC5D,MAAM,CAAC,kBAAkB,CAAC,IAAI,iCAAiC,EAAE,CAAC,CAAC;QACnE,MAAM,CAAC,kBAAkB,CAAC,IAAI,qCAAqC,EAAE,CAAC,CAAC;QACvE,MAAM,CAAC,kBAAkB,CAAC,IAAI,iCAAiC,EAAE,CAAC,CAAC;QACnE,MAAM,CAAC,kBAAkB,CAAC,IAAI,qBAAqB,EAAE,CAAC,CAAC;QAEvD,cAAc,CAAC,eAAe,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;QACxD,cAAc,CAAC,eAAe,CAAC,IAAI,iBAAiB,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,GAAc;QACvB,MAAM,GAAG,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,IAAI,EAAE,CAAC;IACxC,CAAC;CACF"}