@discoveryjs/discovery/lib/main/model.d.ts

Frontend framework for rapid data (JSON) analysis, shareable serverless reports and dashboards

import type { ObjectMarker, ObjectMarkerConfig, ObjectMarkerDescriptor } from '../core/object-marker.js';
import type { Dataset, Encoding, LoadDataBaseOptions, LoadDataFetchOptions, LoadDataResult } from '../core/utils/load-data.js';
import type { ConsoleLike, LogLevel } from '../core/utils/logger.js';
import { TextViewRenderer } from '../core/text-view.js';
import { Emitter } from '../core/emitter.js';
import { ActionManager } from '../core/action.js';
import { ObjectMarkerManager } from '../core/object-marker.js';
import { Logger } from '../core/utils/logger.js';
export type LogOptions = {
    level: LogLevel;
    lazy?: () => any[];
    message?: string;
    collapsed?: null | Iterable<any> | (() => Iterable<any>);
};
export type ExtensionFunction<T> = (host: T) => void;
export type ExtensionArray<T> = Extension<T>[];
export type ExtensionObject<T> = {
    [key: string]: Extension<T>;
};
export type Extension<T> = ExtensionFunction<T> | ExtensionArray<T> | ExtensionObject<T>;
export type PageId = string;
export type PageRef = string | number | null;
export type PageParams = Record<string, unknown> | [key: string, value?: unknown][] | string;
export type PageAnchor = string | null;
export type PageHashStateWithAnchor = PageHashState & {
    anchor: PageAnchor;
};
export type PageHashState = {
    id: PageId;
    ref: PageRef;
    params: PageParams;
};
export type LinkResolver = (value: unknown) => null | ResolvedLink;
export type ResolvedLink = {
    type: string;
    text: string;
    href: string | null;
    entity: object;
};
export type Query = string | QueryFunction;
export type QueryFunction = ((data: unknown, context: unknown) => unknown) & {
    query?: string;
};
export type QueryFromStringOptions = {
    tolerant?: boolean;
    stat?: boolean;
};
export type RawDataDataset = {
    data: any;
};
export type ModelDataset = Dataset | RawDataDataset;
export type GetDecodeParams = (pageId: string) => (entries: [string, any][]) => object;
export interface SetDataOptions {
    setPrepareWorkTitle?: (title: string) => Promise<void>;
    dataset?: Dataset;
}
export type SetupMethods = {
    setPrepare(fn: PrepareFunction): void;
    defineObjectMarker<T extends object>(name: string, options: ObjectMarkerConfig<T>): ObjectMarker<T>['mark'];
    /** @deprecated use addQueryMethods() instead */
    addQueryHelpers(methods: SetupQueryMethodsExtension): void;
    addQueryMethods(methods: SetupQueryMethodsExtension): void;
    addQueryAssertions(assertions: SetupQueryMethodsExtension): void;
};
export type SetupQueryMethodsExtension = {
    [key: string]: string | ((...args: unknown[]) => any);
};
export type PrepareFunction = (input: any, prepareContext: PrepareContextApi | LegacyPrepareContextApi) => any;
export type PrepareContextApiWrapper = {
    before?(host: Model): void;
    after?(host: Model): void;
    contextApi: PrepareContextApi | LegacyPrepareContextApi;
};
export interface PrepareContextApi {
    setWorkTitle: (title: string) => Promise<void>;
    rejectData: (message: string, extra: any) => void;
    markers: Record<string, (value: unknown) => void>;
}
export interface LegacyPrepareContextApi {
    setWorkTitle: (title: string) => Promise<void>;
    rejectData: (message: string, extra: any) => void;
    defineObjectMarker<T extends object>(name: string, options: ObjectMarkerConfig<T>): ObjectMarker<T>['mark'];
    lookupObjectMarker(value: any, type?: string): ObjectMarkerDescriptor<object> | null;
    lookupObjectMarkerAll(value: any): ObjectMarkerDescriptor<object>[];
    addValueAnnotation(query: Query, options: object | boolean): void;
    /** @deprecated use addQueryMethods() instead */
    addQueryHelpers(methods: SetupQueryMethodsExtension): void;
    addQueryMethods(methods: SetupQueryMethodsExtension): void;
    addQueryAssertions(assertions: SetupQueryMethodsExtension): void;
    query(query: Query, ...args: unknown[]): any;
}
export type ModelEvents = {
    data: [];
    context: [prevContext: unknown, nextContext: unknown];
    unloadData: [];
};
export interface ModelOptions<T = Model> {
    name: string;
    version: string;
    description: string;
    icon: string;
    logger: ConsoleLike;
    logLevel: LogLevel;
    extensions: Extension<T>;
    encodings: Encoding[];
    context: any;
    setup(api: SetupMethods): void;
}
type ModelOptionsBind = ModelOptions<Model>;
export declare class Model<Options extends ModelOptions = ModelOptionsBind, Events extends ModelEvents = ModelEvents> extends Emitter<Events> {
    #private;
    options: Partial<Options>;
    info: {
        name: string;
        version: string | null;
        description: string | null;
        icon: string | null;
    };
    logger: Logger;
    action: ActionManager;
    objectMarkers: ObjectMarkerManager;
    linkResolvers: LinkResolver[];
    encodings: Encoding[];
    datasets: ModelDataset[];
    data: any;
    prepare: PrepareFunction;
    textView: TextViewRenderer;
    constructor(options?: Partial<Options>);
    apply(extensions?: Extension<this>): void;
    log(): void;
    get legacyPrepare(): boolean;
    setPrepare(fn: PrepareFunction): void;
    get context(): any;
    set context(context: unknown);
    setContext(context: unknown, replace?: boolean): void;
    getContext(): any;
    setData(data: unknown, options?: SetDataOptions): Promise<void>;
    trackLoadDataProgress(loadDataResult: LoadDataResult): Promise<void>;
    loadDataFromStream(stream: ReadableStream, options?: LoadDataBaseOptions): Promise<void>;
    loadDataFromEvent(event: DragEvent | ClipboardEvent | InputEvent, options?: LoadDataBaseOptions): Promise<void>;
    loadDataFromFile(file: File, options?: LoadDataBaseOptions): Promise<void>;
    loadDataFromUrl(url: string, options?: LoadDataFetchOptions): Promise<void>;
    unloadData(): void;
    hasDatasets(): boolean;
    getQueryEngineInfo(): {
        name: string;
        version: any;
        link: string;
    };
    queryFnFromString(query: string, options?: QueryFromStringOptions): QueryFunction;
    queryFn(query: Query): QueryFunction;
    query(query: any, data: unknown, context: unknown): unknown;
    queryBool(query: any, data: unknown, context: unknown): boolean;
    querySuggestions(query: string, offset: number, data: unknown, context: unknown): import("./query-suggestions.js").Suggestion[] | null;
    pathToQuery(path: (string | number)[]): string;
    stripAnchorFromHash(hash: string): string;
    encodePageHash(pageId?: string | null, pageRef?: PageRef, pageParams?: PageParams, pageAnchor?: PageAnchor): string;
    decodePageHash(hash: string, getDecodeParams?: GetDecodeParams): {
        pageId: string;
        pageRef: string | null;
        pageParams: Record<string, unknown>;
        pageAnchor: string | null;
    };
    resolveValueLinks(value: unknown): ResolvedLink[] | null;
}
export {};