@discoveryjs/discovery/lib/core/text-view.d.ts

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

import type { Model } from '../main/model.js';
import { Dictionary } from './dict.js';
export type RenderContext = ReturnType<typeof createRenderContext>;
type TextRenderFunction = (node: RenderBox, props: RenderProps, data?: any, context?: any) => Promise<any> | void;
type NormalizedTextViewPropsFunction = (data: any, context: {
    props: RenderProps;
    context: any;
}) => any;
type DefineTextViewRender = TextRenderFunction | RawTextViewConfig;
type TextViewUsage = any;
export type RawTextViewConfig = SingleTextViewConfig | TextRenderFunction | string | RawTextViewConfig[];
export type NormalizedTextViewConfig = SingleTextViewConfig | SingleTextViewConfig[];
type queryFn = (data: any, context: any) => any;
type query = string | queryFn | boolean;
type ConfigTransitionTreeNode = {
    value: any;
    deps: ConfigTransitionTreeNode[];
};
type BorderLR = null | string | Parameters<typeof borderLR> | ((index: number, total: number) => string | undefined);
type BorderTB = null | string | Parameters<typeof borderTB> | ((len: number, left: number, right: number) => string | undefined);
type Span = {
    length: number;
    node: null | RenderNode;
};
export interface TextViewOptions {
    type: RenderBlockType;
    render: DefineTextViewRender;
    usage: TextViewUsage;
    props: NormalizedTextViewPropsFunction | string;
}
export type TextViewOptionsWithoutRender = Exclude<TextViewOptions, 'render'>;
export interface NormalizedTextViewOptions {
    type: RenderBlockType | undefined;
    border?: null | string | [
        top?: BorderTB,
        left?: BorderLR,
        bottom?: BorderTB,
        right?: BorderLR
    ] | Partial<{
        top: BorderTB;
        left: BorderLR;
        right: BorderLR;
        bottom: BorderTB;
    }>;
    usage?: TextViewUsage;
    props?: NormalizedTextViewPropsFunction;
}
interface TextView {
    name: string | false;
    options: NormalizedTextViewOptions;
    render: TextRenderFunction;
}
export interface SingleTextViewConfig {
    view: string | TextRenderFunction;
    when?: query;
    context?: query;
    data?: query;
    whenData?: query;
    [key: string]: any;
}
type RenderPropsForbiddenKeys = 'view' | 'when' | 'context' | 'data' | 'whenData' | 'postRender';
type RenderProps = {
    [K in string]: K extends RenderPropsForbiddenKeys ? never : any;
};
type PropsTransition = {
    props: any;
    fn: NormalizedTextViewPropsFunction & {
        query?: string;
    };
};
interface ViewInfo {
    config: NormalizedTextViewConfig;
    skipped?: 'when' | 'whenData';
    props?: any;
    inputData: any;
    inputDataIndex?: number;
    data: any;
    context: any;
}
export declare function isRawViewConfig(value: unknown): value is RawTextViewConfig;
type RenderNode = RenderBox | RenderText | RenderPlaceholder;
type RenderBlockType = 'inline' | 'inline-block' | 'block' | 'line';
declare class RenderBox {
    type: RenderBlockType;
    children: RenderNode[];
    border: Border | null;
    constructor(type?: RenderBlockType, nodes?: RenderNode[]);
    appendText(value: string): void;
    appendInlineBlock(): RenderBox;
    appendBlock(): RenderBox;
    appendLine(): RenderBox;
    append(node: RenderNode): this;
    setBorder(border?: NormalizedTextViewOptions['border']): void;
}
declare class RenderText {
    readonly value: string;
    constructor(value: string);
}
declare class RenderPlaceholder {
    node: RenderNode | null;
    constructor();
    setNode(node: RenderNode): void;
}
declare function borderLR(start: string, mid?: string, end?: string, single?: string): (idx: number, total: number) => string;
declare function borderTB(start: string, mid?: string, end?: string): (m: number, l: number, r: number) => string;
declare class Border {
    top: BorderTB;
    left: BorderLR;
    right: BorderLR;
    bottom: BorderTB;
    constructor(top?: BorderTB, right?: BorderLR, bottom?: BorderTB, left?: BorderLR);
    render(lines: string[], spans: Span[][], node: RenderNode): {
        spans: Span[][];
        lines: string[];
    };
}
declare function createRenderContext(viewRenderer: TextViewRenderer, name: string): {
    name: string;
    normalizeConfig: any;
    ensureValidConfig: any;
    composeConfig: any;
    propsFromConfig: any;
    render: any;
    listLimit: any;
    renderList: any;
};
export declare class TextViewRenderer extends Dictionary<TextView> {
    host: Model;
    defaultRenderErrorRenderer: TextView;
    viewEls: WeakMap<RenderNode, ViewInfo>;
    constructor(host: Model);
    define(name: string, render: DefineTextViewRender, options?: TextViewOptionsWithoutRender): Readonly<TextView>;
    define(name: string, options: TextViewOptions): Readonly<TextView>;
    normalizeConfig(config: RawTextViewConfig | TextRenderFunction): SingleTextViewConfig | SingleTextViewConfig[] | null;
    badConfig(config: any, error: Error): SingleTextViewConfig;
    ensureValidConfig(config: any): NormalizedTextViewConfig;
    composeConfig(config: any, extension: any): NormalizedTextViewConfig;
    propsFromConfig(config: SingleTextViewConfig, data: any, context: any, fn?: NormalizedTextViewPropsFunction | null | false | undefined): Record<string, any>;
    textWidth(node: RenderNode | null): any;
    cleanUpRenderTree(node: RenderNode | null): any;
    serialize(root: RenderNode | null): {
        text: string;
        ranges: {
            range: [number, number];
            view: ViewInfo | null;
        }[];
    };
    render(container: RenderBox | RenderBlockType | null, config: RawTextViewConfig, data?: any, context?: any, dataIndex?: number): Promise<RenderBox>;
    renderString(container: RenderBox | null, config: RawTextViewConfig, data?: any, context?: any, dataIndex?: number): Promise<{
        text: string;
        ranges: {
            range: [number, number];
            view: ViewInfo | null;
        }[];
    }>;
    listLimit(value: any, defaultValue: number): number | false;
    renderList(container: RenderBox, itemConfig: RawTextViewConfig, data: any[], context: any, opts: Partial<{
        offset: number;
        limit: number | false;
        beforeMore: string;
        afterMore: string;
        moreContainer: RenderBox;
        beforeItem: string;
        afterItem: string;
    }>): Promise<RenderBox[]>;
    maybeMore(container: RenderBox, beforeEl: RenderBox | null, count: number, offset: number, beforeMore?: string, afterMore?: string): void;
    getViewConfigTransitionTree(value: any): ConfigTransitionTreeNode;
    getViewPropsTransition(value: any): null | PropsTransition & {
        query: string | null;
    };
}
export {};