@journeyapps-labs/reactor-mod-data-browser 3.0.2 → 3.1.1

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @journeyapps-labs/reactor-mod-data-browser
 
+## 3.1.1
+
+### Patch Changes
+
+- 4e3887d: Bump dependencies
+
+## 3.1.0
+
+### Minor Changes
+
+- 9422edc: Ship a major Query Controls upgrade focused on speed, clarity, and persistence.
+
+  Highlights:
+  - Add a full Sort Controls experience:
+    - Multi-column sorting with ASC/DESC directions.
+    - Clickable table headers to cycle sort states.
+    - Drag-and-drop reordering of sort priority (DnD3).
+    - Sort state persisted in saved queries.
+  - Add a Filter Controls group in table controls:
+    - `+` picker to add/edit filters by field.
+    - Metadata-based filter chips (reusing filter-provided metadata).
+    - Explicit filter removal via chip actions.
+  - Expand filter capabilities:
+    - Statement-based filters support multiple conditions and global AND/OR matching.
+    - Text filters now support `=`, `starts with`, and `contains`.
+    - Number and date filters support comparison operators via form-driven setup.
+  - Improve loading UX for query updates:
+    - Keep the current page rendered while new data loads.
+    - Hot-swap page data only when the next page is ready.
+    - Show a lightweight loading spinner in query controls instead of jarring content loaders.
+  - Add new user preferences under `Query Controls`:
+    - Show sort controls.
+    - Show filter controls.
+  - Add connection color coding across Data Browser:
+    - Persist a per-connection color with sensible defaults for new/existing connections.
+    - Add a `Set connection color` action using the new ComboBox2 flow.
+    - Add connection color selection to the manual connection form via a set input.
+    - Render connection color indicators in panel tabs and connection entity presentation.
+
+  Also includes internal refactors for cleaner handler-owned filter setup, filter serialization typing, and modularized table-control widgets.
+
+### Patch Changes
+
+- 660e4e8: Migrate Data Browser action registration and lookup to `ActionStore` for compatibility with the latest Reactor action wiring patterns.
+
 ## 3.0.2
 
 ### Patch Changes

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

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

package/dist/@types/actions/saved-queries/OpenSavedQueryAction.d.ts

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

package/dist/@types/actions/saved-queries/RemoveSavedQueryAction.d.ts

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

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

@@ -11,6 +11,7 @@ export interface AbstractConnectionSerialized {
     factory: string;
     id: string;
     payload: any;
+    color?: string;
 }
 export interface AbstractConnectionListener {
     removed: () => any;
@@ -18,6 +19,7 @@ export interface AbstractConnectionListener {
 export declare abstract class AbstractConnection extends BaseObserver<AbstractConnectionListener> {
     factory: AbstractConnectionFactory;
     id: string;
+    accessor color: string;
     schema_models_collection: Collection<ObjectType>;
     schema_models: LifecycleCollection<ObjectType, SchemaModelDefinition>;
     private fetch_indexes_promise;

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

@@ -6,6 +6,7 @@ import { LifecycleModel } from '@journeyapps-labs/lib-reactor-data-layer';
 import { BaseObserver } from '@journeyapps-labs/common-utils';
 import { QueueObject } from 'async';
 import { IndexModel } from './IndexModel';
+import { TypeEngine } from '../forms/TypeEngine';
 export interface SchemaModelDefinitionListener {
     resolved: (event: {
         object: SchemaModelObject;
@@ -38,4 +39,8 @@ export declare class SchemaModelDefinition extends BaseObserver<SchemaModelDefin
     executeQuery(query: Query): Promise<SchemaModelObject[]>;
     getCollection(): Promise<Collection<import("@journeyapps/db").DatabaseObject>>;
     generateNewModelObject(): Promise<SchemaModelObject>;
+    getFilterableFields(typeEngine: TypeEngine): {
+        key: string;
+        label: string;
+    }[];
 }

package/dist/@types/core/connection-colors.d.ts

@@ -0,0 +1,10 @@
+import { ComboBoxItem } from '@journeyapps-labs/reactor-mod';
+export interface ConnectionColorOption {
+    key: string;
+    label: string;
+}
+export declare const CONNECTION_COLOR_OPTIONS: ConnectionColorOption[];
+export declare const DEFAULT_CONNECTION_COLOR: string;
+export declare function getConnectionColorComboBoxItems(): ComboBoxItem[];
+export declare function getConnectionColorSetOptions(): Record<string, string>;
+export declare function getDefaultConnectionColor(seed: string): string;

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

@@ -14,4 +14,5 @@ export declare abstract class AbstractQuery {
     abstract getColumns(): TableColumn[];
     abstract get totalPages(): number;
     abstract getPage(number: number): Page;
+    abstract matches(query: AbstractQuery): boolean;
 }

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

@@ -0,0 +1,5 @@
+export declare enum StandardModelFields {
+    ID = "id",
+    UPDATED_AT = "updated_at"
+}
+export declare const STANDARD_MODEL_FIELD_LABELS: Record<StandardModelFields, string>;

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

@@ -1,17 +1,58 @@
 import { Query, Variable } from '@journeyapps/db';
-export declare abstract class AbstractFilter {
+import { EntityLabel } from '@journeyapps-labs/reactor-mod';
+import { BaseObserver } from '@journeyapps-labs/common-utils';
+export interface AbstractFilterListener {
+    removeRequested: () => any;
+}
+export declare abstract class AbstractFilter extends BaseObserver<AbstractFilterListener> {
+    constructor();
+    delete(): void;
     abstract augment(query: Query): any;
 }
 export declare enum Condition {
-    EQUALS = "="
+    EQUALS = "=",
+    NOT_EQUALS = "!=",
+    GREATER_THAN = ">",
+    GREATER_THAN_OR_EQUAL = ">=",
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUAL = "<=",
+    STARTS_WITH = "starts with",
+    CONTAINS = "contains"
+}
+export declare enum StatementMatch {
+    ANY = "ANY",
+    ALL = "ALL"
+}
+export declare enum FilterType {
+    SIMPLE = "simple"
 }
-export interface Statement {
+export interface SerializedStatement {
     condition: Condition;
     arg: any;
 }
+export interface SerializedSimpleFilter {
+    type: FilterType;
+    variable: string;
+    match?: StatementMatch;
+    statements: SerializedStatement[];
+}
+export declare class Statement {
+    condition: Condition;
+    arg: any;
+    constructor(condition: Condition, arg: any);
+    serialize(): SerializedStatement;
+    static deserialize(data: SerializedStatement): Statement;
+    getMetadataLabel(): EntityLabel;
+}
 export declare class SimpleFilter extends AbstractFilter {
-    variable: Variable;
+    readonly type = FilterType.SIMPLE;
     statements: Statement[];
-    constructor(variable: Variable, statements: Statement[]);
+    match: StatementMatch;
+    constructor(variable: Variable, statements: (Statement | SerializedStatement)[], match?: StatementMatch);
+    variable: Variable;
     augment(query: Query): Query<import("@journeyapps/db").DatabaseObject>;
+    serialize(): SerializedSimpleFilter;
+    static deserialize(variable: Variable, data: SerializedSimpleFilter): SimpleFilter;
+    static canDeserialize(data: any): data is SerializedSimpleFilter;
+    getMetadata(): EntityLabel[];
 }

package/dist/@types/core/query/query-changed/ChangedModelQuery.d.ts

@@ -12,4 +12,5 @@ export declare class ChangedModelQuery extends AbstractQuery {
     getColumns(): TableColumn[];
     get totalPages(): number;
     getPage(number: number): Page;
+    matches(query: AbstractQuery): boolean;
 }

package/dist/@types/core/query/query-simple/SimplePage.d.ts

@@ -1,9 +1,11 @@
 import { Page, PageOptions } from '../Page';
 import { AbstractFilter } from '../filters';
+import { SimpleQuerySort } from './SimpleQueryTypes';
 export interface SimplePageOptions extends PageOptions {
     offset: number;
     limit: number;
     filters: AbstractFilter[];
+    sorts?: SimpleQuerySort[];
 }
 export declare class SimplePage extends Page {
     protected options2: SimplePageOptions;

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

@@ -1,26 +1,36 @@
 import { TableColumn } from '@journeyapps-labs/reactor-mod';
 import { ConnectionStore } from '../../../stores/ConnectionStore';
-import { Promise, Variable } from '@journeyapps/db';
+import { Promise } from '@journeyapps/db';
 import { Page } from '../Page';
 import { SchemaModelDefinition } from '../../SchemaModelDefinition';
-import { SimpleFilter } from '../filters';
 import { SchemaModelObject } from '../../SchemaModelObject';
 import { AbstractQueryEncoded, AbstractSerializableQuery } from '../AbstractSerializableQuery';
+import { SerializedSimpleFilter } from '../filters';
+import { SerializedSimpleQuerySort, SimpleQuerySort, SortDirection } from './SimpleQueryTypes';
+import { SimpleQuerySortState } from './SimpleQuerySortState';
+import { SimpleQueryFilterState } from './SimpleQueryFilterState';
+import { AbstractQuery } from '../AbstractQuery';
 export interface SimpleQueryOptions {
     definition?: SchemaModelDefinition;
     limit?: number;
 }
 export interface SimpleQueryEncoded extends AbstractQueryEncoded {
     limit: number;
-    definition: string;
+    filters?: SerializedSimpleFilter[];
+    sorts?: SerializedSimpleQuerySort[];
 }
+export { SortDirection, SimpleQuerySort, type SerializedSimpleQuerySort };
 export declare class SimpleQuery extends AbstractSerializableQuery<SimpleQueryEncoded> {
     options: SimpleQueryOptions;
     accessor connStore: ConnectionStore;
     accessor _totalPages: number;
     accessor _pages: Page[];
-    simple_filters: Map<Variable, SimpleFilter>;
+    readonly sortState: SimpleQuerySortState;
+    readonly filterState: SimpleQueryFilterState;
+    private suspendStateLoad;
+    private readonly scheduleLoad;
     constructor(options?: SimpleQueryOptions);
+    matches(query: AbstractQuery): boolean;
     load(): globalThis.Promise<void>;
     getPage(number: number): Page;
     get totalPages(): number;

package/dist/@types/core/query/query-simple/SimpleQueryColumns.d.ts

@@ -0,0 +1,12 @@
+import { TableColumn } from '@journeyapps-labs/reactor-mod';
+import { SchemaModelDefinition } from '../../SchemaModelDefinition';
+import { AbstractConnection } from '../../AbstractConnection';
+import { SimpleQuerySortState } from './SimpleQuerySortState';
+import { SimpleQueryFilterState } from './SimpleQueryFilterState';
+export interface BuildSimpleQueryColumnsOptions {
+    definition: SchemaModelDefinition;
+    connection: AbstractConnection;
+    sortState: SimpleQuerySortState;
+    filterState: SimpleQueryFilterState;
+}
+export declare const buildSimpleQueryColumns: (options: BuildSimpleQueryColumnsOptions) => TableColumn[];

package/dist/@types/core/query/query-simple/SimpleQueryFilterState.d.ts

@@ -0,0 +1,37 @@
+import { Variable } from '@journeyapps/db';
+import { BaseObserver } from '@journeyapps-labs/common-utils';
+import { SchemaModelDefinition } from '../../SchemaModelDefinition';
+import { SerializedSimpleFilter, SimpleFilter } from '../filters';
+import { TypeEngine } from '../../../forms/TypeEngine';
+export interface SimpleQueryFilterStateListener {
+    changed: () => any;
+}
+export interface SimpleQueryFilterStateOptions {
+    definition?: SchemaModelDefinition;
+    typeEngine: TypeEngine;
+}
+export interface ActiveFilterEntry {
+    variable: Variable;
+    filter: SimpleFilter;
+}
+export declare class SimpleQueryFilterState extends BaseObserver<SimpleQueryFilterStateListener> {
+    readonly simpleFilters: Map<Variable, SimpleFilter>;
+    accessor definition: SchemaModelDefinition | undefined;
+    readonly typeEngine: TypeEngine;
+    constructor(options: SimpleQueryFilterStateOptions);
+    get filters(): SimpleFilter[];
+    clear(): void;
+    setDefinition(definition: SchemaModelDefinition | undefined): boolean;
+    getFilterableFields(): {
+        key: string;
+        label: string;
+    }[];
+    getActiveFilters(): ActiveFilterEntry[];
+    getFilter(field: string): SimpleFilter | undefined;
+    getSerializedFilters(): SerializedSimpleFilter[];
+    hydrateFilters(filters: SerializedSimpleFilter[]): void;
+    setFilter(field: string, filter: SimpleFilter): boolean;
+    setupFilterForField(field: string, position?: MouseEvent): Promise<boolean>;
+    private addFilter;
+    private resolveAttribute;
+}

package/dist/@types/core/query/query-simple/SimpleQueryPlanner.d.ts

@@ -0,0 +1,4 @@
+import { Query } from '@journeyapps/db';
+import { AbstractFilter } from '../filters';
+import { SimpleQuerySort } from './SimpleQueryTypes';
+export declare const applyFiltersAndSorts: (query: Query, filters: AbstractFilter[], sorts?: SimpleQuerySort[]) => Query;

package/dist/@types/core/query/query-simple/SimpleQuerySortState.d.ts

@@ -0,0 +1,23 @@
+import { BaseObserver } from '@journeyapps-labs/common-utils';
+import { SchemaModelDefinition } from '../../SchemaModelDefinition';
+import { SerializedSimpleQuerySort, SimpleQuerySort } from './SimpleQueryTypes';
+export interface SimpleQuerySortStateListener {
+    changed: () => any;
+}
+export declare class SimpleQuerySortState extends BaseObserver<SimpleQuerySortStateListener> {
+    accessor sorts: SimpleQuerySort[];
+    accessor definition: SchemaModelDefinition | undefined;
+    constructor(definition?: SchemaModelDefinition);
+    setDefinition(definition: SchemaModelDefinition | undefined): boolean;
+    getSort(field: string): SimpleQuerySort | undefined;
+    addSort(sort: SimpleQuerySort): boolean;
+    moveSortBefore(sourceField: string, targetField: string): boolean;
+    setSorts(sorts: SimpleQuerySort[]): boolean;
+    hydrateSorts(serializedSorts?: SerializedSimpleQuerySort[]): boolean;
+    getSerializedSorts(): SerializedSimpleQuerySort[];
+    getSortableFields(): {
+        key: string;
+        label: string;
+    }[];
+    private normalizeSorts;
+}

package/dist/@types/core/query/query-simple/SimpleQueryTypes.d.ts

@@ -0,0 +1,24 @@
+import { BaseObserver } from '@journeyapps-labs/common-utils';
+export declare enum SortDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+export interface SerializedSimpleQuerySort {
+    field: string;
+    direction: SortDirection;
+}
+export interface SimpleQuerySortListener {
+    changed: () => any;
+    removeRequested: () => any;
+}
+export declare class SimpleQuerySort extends BaseObserver<SimpleQuerySortListener> {
+    field: string;
+    direction: SortDirection;
+    constructor(field: string, direction: SortDirection);
+    static deserialize(value: SerializedSimpleQuerySort): SimpleQuerySort;
+    static create(field: string, direction?: SortDirection): SimpleQuerySort;
+    serialize(): SerializedSimpleQuerySort;
+    setDirection(direction: SortDirection): boolean;
+    toggle(): void;
+    remove(): void;
+}

package/dist/@types/core/query/widgets/ColumnDisplayWidget.d.ts

@@ -2,5 +2,6 @@ import * as React from 'react';
 export interface ColumnDisplayWidgetProps {
     label: string;
     className?: any;
+    onClick?: () => any;
 }
 export declare const ColumnDisplayWidget: React.FC<ColumnDisplayWidgetProps>;

package/dist/@types/core/query/widgets/PeekRelationshipButton.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import { SchemaModelObject } from '../../SchemaModelObject';
+export interface PeekRelationshipButtonProps {
+    object: SchemaModelObject;
+    open: (object: SchemaModelObject) => any;
+}
+export declare const PeekRelationshipButton: React.FC<PeekRelationshipButtonProps>;

package/dist/@types/core/query/widgets/SmartColumnWidget.d.ts

@@ -1,10 +1,13 @@
 import * as React from 'react';
 import { ObjectType, Variable } from '@journeyapps/db';
 import { SimpleFilter } from '../filters';
+import type { SortDirection } from '../query-simple/SimpleQuery';
 export interface SmartColumnWidgetProps {
     variable: Variable;
     type?: ObjectType;
     filter?: SimpleFilter;
+    sortDirection?: SortDirection;
+    onToggleSort?: () => Promise<any> | any;
     filterChanged: (filter: SimpleFilter | null) => any;
 }
 export declare const SmartColumnWidget: React.FC<SmartColumnWidgetProps>;

package/dist/@types/core/query/widgets/SmartFilterWidget.d.ts

@@ -6,4 +6,10 @@ export interface SmartFilterWidgetProps {
     filter?: SimpleFilter;
     filterChanged: (filter: SimpleFilter | null) => any;
 }
+export interface SmartFilterMetadataWidgetProps {
+    variable: Variable;
+    filter?: SimpleFilter;
+    className?: any;
+}
+export declare const SmartFilterMetadataWidget: React.FC<SmartFilterMetadataWidgetProps>;
 export declare const SmartFilterWidget: React.FC<SmartFilterWidgetProps>;

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

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

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

@@ -0,0 +1,8 @@
+import { EntityDefinition } from '@journeyapps-labs/reactor-mod';
+import { SavedQueryEntity, SavedQueryStore } from '../stores/SavedQueryStore';
+export declare class SavedQueryEntityDefinition extends EntityDefinition<SavedQueryEntity> {
+    accessor savedQueryStore: SavedQueryStore;
+    constructor();
+    matchEntity(t: any): boolean;
+    getEntityUID(t: SavedQueryEntity): string;
+}

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

@@ -4,5 +4,6 @@ export declare enum DataBrowserEntities {
     SCHEMA_MODEL_DEFINITION = "databrowser/schema_model_definition",
     SCHEMA_MODEL_INDEX = "databrowser/schema_model_index",
     SCHEMA_MODEL_OBJECT = "databrowser/schema_model_object",
-    QUERY = "databrowser/query"
+    QUERY = "databrowser/query",
+    SAVED_QUERY = "databrowser/saved_query"
 }

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

@@ -5,6 +5,7 @@ export interface APIConnectionFormValue {
     name: string;
     base_url: string;
     api_token: string;
+    color: string;
 }
 export declare class APIConnectionForm extends FormModel<APIConnectionFormValue> {
     constructor(value?: APIConnectionFormValue);

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

@@ -1,31 +1,13 @@
 import { Type } from '@journeyapps/db';
-import { FormInput, MediaEngine, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
-import { JSX } from 'react';
-import { SchemaModelObject } from '../core/SchemaModelObject';
-export interface TypeHandler<T extends Type = Type, ENCODED = any, DECODED = any> {
-    matches: (type: Type) => boolean;
-    generateField: (event: {
-        label: string;
-        name: string;
-        type: T;
-    }) => FormInput;
-    generateDisplay: (event: {
-        label: string;
-        name: string;
-        type: T;
-        value: ENCODED;
-        model: SchemaModelObject;
-    }) => JSX.Element | string;
-    decode: (value: ENCODED) => Promise<DECODED>;
-    encode: (value: DECODED) => Promise<ENCODED>;
-}
+import { MediaEngine, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { TypeHandler } from './types/shared/type-handler';
+export type { TypeHandler };
 export declare class TypeEngine {
     handlers: Set<TypeHandler>;
     accessor mediaEngine: MediaEngine;
     accessor workspaceStore: WorkspaceStore;
     private _mediaCache;
     constructor();
-    displayArray(value: any[]): JSX.Element;
     getHandler(type: Type): TypeHandler<Type, any, any>;
     register<T extends Type = Type, ENCODED = any, DECODED = any>(handler: TypeHandler<T, ENCODED, DECODED>): void;
 }

package/dist/@types/forms/types/attachment-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler } from './shared/type-handler';
+export declare const attachmentHandler: TypeHandler;

package/dist/@types/forms/types/boolean-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler } from './shared/type-handler';
+export declare const booleanHandler: TypeHandler;

package/dist/@types/forms/types/date-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler } from './shared/type-handler';
+export declare const dateHandler: TypeHandler;

package/dist/@types/forms/types/filters/ClearableFilterFormDialogDirective.d.ts

@@ -0,0 +1,10 @@
+import { Btn, FormDialogDirective, FormDialogDirectiveOptions, FormModel } from '@journeyapps-labs/reactor-mod';
+import { AbstractFilter } from '../../../core/query/filters';
+export interface ClearableFilterFormDialogDirectiveOptions<T extends FormModel = FormModel> extends FormDialogDirectiveOptions<T> {
+    filter?: AbstractFilter;
+}
+export declare class ClearableFilterFormDialogDirective<T extends FormModel = FormModel> extends FormDialogDirective<T> {
+    private options3;
+    constructor(options3: ClearableFilterFormDialogDirectiveOptions<T>);
+    getButtons(): Btn[];
+}

package/dist/@types/forms/types/filters/ConditionalFilterForm.d.ts

@@ -0,0 +1,23 @@
+import { FormInput, FormModel } from '@journeyapps-labs/reactor-mod';
+import { Condition, StatementMatch } from '../../../core/query/filters';
+export interface ConditionalStatementValue<T = any> {
+    condition: Condition;
+    value: T;
+}
+export interface ConditionalFilterFormValue<T = any> {
+    match: StatementMatch;
+    statements: ConditionalStatementValue<T>[];
+}
+export interface ConditionalFilterFormOptions<T = any> {
+    match?: StatementMatch;
+    statements?: ConditionalStatementValue<T>[];
+}
+export declare abstract class ConditionalFilterForm<T = any> extends FormModel<ConditionalFilterFormValue<T>> {
+    protected options2?: ConditionalFilterFormOptions<T>;
+    constructor(options2?: ConditionalFilterFormOptions<T>);
+    private getInitialStatements;
+    protected getDefaultCondition(): Condition;
+    protected getConditionOptions(): Record<string, string>;
+    protected getDefaultValue(): T;
+    protected abstract generateValueInput(): FormInput;
+}

package/dist/@types/forms/types/image-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler, TypeHandlerContext } from './shared/type-handler';
+export declare const imageHandler: (context: TypeHandlerContext) => TypeHandler;

package/dist/@types/forms/types/location-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler } from './shared/type-handler';
+export declare const locationHandler: TypeHandler;

package/dist/@types/forms/types/multiple-choice-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler, TypeHandlerContext } from './shared/type-handler';
+export declare const multipleChoiceHandler: (context: TypeHandlerContext) => TypeHandler;

package/dist/@types/forms/types/multiple-choice-integer-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler, TypeHandlerContext } from './shared/type-handler';
+export declare const multipleChoiceIntegerHandler: (context: TypeHandlerContext) => TypeHandler;

package/dist/@types/forms/types/number-handler.d.ts

@@ -0,0 +1,2 @@
+import { TypeHandler } from './shared/type-handler';
+export declare const numberHandler: TypeHandler;

package/dist/@types/forms/types/shared/type-handler.d.ts

@@ -0,0 +1,37 @@
+import { Type, Variable } from '@journeyapps/db';
+import { FormInput } from '@journeyapps-labs/reactor-mod';
+import { JSX } from 'react';
+import { SchemaModelObject } from '../../../core/SchemaModelObject';
+import { AbstractMedia, MediaEngine, WorkspaceStore } from '@journeyapps-labs/reactor-mod';
+import { SimpleFilter } from '../../../core/query/filters';
+export type ScalarValue = string | number | boolean | null;
+export interface TypeHandler<T extends Type = Type, ENCODED = any, DECODED = any> {
+    matches: (type: Type) => boolean;
+    generateField: (event: {
+        label: string;
+        name: string;
+        type: T;
+    }) => FormInput;
+    generateDisplay: (event: {
+        label: string;
+        name: string;
+        type: T;
+        value: ENCODED;
+        model: SchemaModelObject;
+    }) => JSX.Element | string;
+    decode: (value: ENCODED) => Promise<DECODED>;
+    encode: (value: DECODED) => Promise<ENCODED>;
+    encodeToScalar?: (value: DECODED) => Promise<ScalarValue>;
+    decodeFromScalar?: (value: ScalarValue) => Promise<DECODED>;
+    setupFilter?: (event: {
+        variable: Variable;
+        filter?: SimpleFilter;
+        position?: MouseEvent;
+    }) => Promise<SimpleFilter | null>;
+}
+export interface TypeHandlerContext {
+    mediaEngine: MediaEngine;
+    workspaceStore: WorkspaceStore;
+    mediaCache: Map<string, AbstractMedia>;
+    displayArray: (value: any[]) => JSX.Element | string;
+}