@guihz/trading-vue-editor-tes 0.0.1

package/lib/components/editor/parseScript/buildInFuncNamespace/index.d.ts

@@ -0,0 +1,12 @@
+import BuildInArray, { PseudoArray } from "./array";
+import BuildInMath from "./math";
+import BuildInTa from "./ta";
+import BuildInInput, { VInputType } from "./input";
+import BuildInColor from "./color";
+import BuildInMatrix from "./matrix";
+import BuildInTimeframe from "./timeframe";
+import BuildInStr from "./string";
+import BuildInMap from "./map";
+export { TccErrorListener } from './errorListener';
+export type { IColorArgs } from './color';
+export { BuildInArray, BuildInMath, BuildInTa, BuildInInput, BuildInColor, BuildInMatrix, BuildInTimeframe, BuildInStr, BuildInMap, PseudoArray, VInputType };

package/lib/components/editor/parseScript/buildInFuncNamespace/input.d.ts

@@ -0,0 +1,70 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { VPlotDisplay } from "../enum";
+import { TccErrorListener } from "./errorListener";
+type TSimpleType = string | number | boolean;
+export declare enum VInputType {
+    INT = "int",
+    BOOL = "bool",
+    TIME = "time",
+    COLOR = "color",
+    FLOAT = "float",
+    PRICE = "price",
+    SOURCE = "source",
+    STRING = "string",
+    SYMBOL = "symbol",
+    SESSION = "session",
+    TEXT_AREA = "text_area",
+    TIMEFRAME = "timeframe"
+}
+interface IInputArgs {
+    id: string;
+    defval: TSimpleType;
+    title?: string;
+    tooltip?: string;
+    inline?: string;
+    group?: string;
+    display?: VPlotDisplay[];
+    sourceTypeName?: string;
+    isModify?: boolean;
+    options?: TSimpleType[];
+    confirm?: boolean;
+    minval?: number;
+    maxval?: number;
+    step?: number;
+    inputType?: VInputType;
+    index?: number;
+    modifyDefval?: TSimpleType;
+}
+interface IGruop {
+    name?: string;
+    inputs: IInputArgs[];
+}
+declare class Input {
+    private _cacheData;
+    private _variables;
+    private _errorListener;
+    private _count;
+    private _historyInputs;
+    private _name;
+    constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
+    update(vals: IInputArgs[]): void;
+    input(args: IInputArgs, posStr: string): TSimpleType;
+    int(args: IInputArgs, posStr: string): TSimpleType;
+    bool(args: IInputArgs, posStr: string): TSimpleType;
+    color(args: IInputArgs, posStr: string): TSimpleType;
+    time(args: IInputArgs, posStr: string): TSimpleType;
+    float(args: IInputArgs, posStr: string): TSimpleType;
+    price(args: IInputArgs, posStr: string): TSimpleType;
+    source(args: IInputArgs, posStr: string): TSimpleType;
+    string(args: IInputArgs, posStr: string): TSimpleType;
+    symbol(args: IInputArgs, posStr: string): TSimpleType;
+    session(args: IInputArgs, posStr: string): TSimpleType;
+    text_area(args: IInputArgs, posStr: string): TSimpleType;
+    timeframe(args: IInputArgs, posStr: string): TSimpleType;
+    private _cacheHandle;
+    private _judgeHistoryInputs;
+    private _displayVerify;
+    getInputs(): IGruop[];
+    private _getGroups;
+}
+export default Input;

package/lib/components/editor/parseScript/buildInFuncNamespace/map.d.ts

@@ -0,0 +1,37 @@
+import { PseudoArray } from "./array";
+interface IMapArgs {
+    id?: PseudoMap;
+    key?: any;
+    value?: any;
+    id2?: PseudoMap;
+}
+export default class BuildInMap {
+    new(): PseudoMap;
+    copy({ id }: IMapArgs): PseudoMap | undefined;
+    get({ id, key }: IMapArgs): any;
+    put({ id, key, value }: IMapArgs): Map<any, any> | undefined;
+    keys({ id }: IMapArgs): PseudoArray | undefined;
+    size({ id }: IMapArgs): number | undefined;
+    clear({ id }: IMapArgs): void;
+    remove({ id, key }: IMapArgs): any;
+    values({ id }: IMapArgs): PseudoArray | undefined;
+    put_all({ id, id2 }: IMapArgs): void;
+    contains({ id, key }: IMapArgs): boolean | undefined;
+}
+declare class PseudoMap {
+    private _mapInstance;
+    constructor();
+    get isMap(): boolean;
+    private _copyMap;
+    copy(): PseudoMap;
+    get({ key }: IMapArgs): any;
+    put({ key, value }: IMapArgs): Map<any, any>;
+    keys(): PseudoArray;
+    size(): number;
+    clear(): void;
+    remove({ key }: IMapArgs): any;
+    values(): PseudoArray;
+    put_all({ id2 }: IMapArgs): void;
+    contains({ key }: IMapArgs): boolean;
+}
+export {};

package/lib/components/editor/parseScript/buildInFuncNamespace/math.d.ts

@@ -0,0 +1,47 @@
+interface IMathArgs {
+    number?: number;
+    angle?: number;
+    base?: number;
+    exponent?: number;
+    min?: number;
+    max?: number;
+    seed?: number;
+    precision?: number;
+    source?: number;
+    length?: number;
+    radians?: number;
+    degrees?: number;
+}
+export default class BuildInMath {
+    private _randomNums;
+    private _mintick;
+    private _cacheData;
+    private _barIndex;
+    constructor(mintick: number);
+    update(barIndex: number): void;
+    abs({ number }: IMathArgs): number;
+    acos({ angle }: IMathArgs): number | undefined;
+    asin({ angle }: IMathArgs): number | undefined;
+    atan({ angle }: IMathArgs): number | undefined;
+    avg(_: IMathArgs, numbers: number[]): number;
+    ceil({ number }: IMathArgs): number;
+    floor({ number }: IMathArgs): number;
+    cos({ angle }: IMathArgs): number | undefined;
+    sin({ angle }: IMathArgs): number | undefined;
+    tan({ angle }: IMathArgs): number | undefined;
+    exp({ number }: IMathArgs): number;
+    log({ number }: IMathArgs): number;
+    log10({ number }: IMathArgs): number;
+    max(_: IMathArgs, numbers: number[]): number;
+    min(_: IMathArgs, numbers: number[]): number;
+    pow({ base, exponent }: IMathArgs): number;
+    random({ min, max, seed }: IMathArgs): string | number;
+    round({ number, precision }: IMathArgs): number;
+    round_to_mintick({ number }: IMathArgs): number;
+    sign({ number }: IMathArgs): number;
+    sqrt({ number }: IMathArgs): number;
+    sum({ source, length }: IMathArgs, posStr: string): number | undefined;
+    todegrees({ radians }: IMathArgs): number;
+    toradians({ degrees }: IMathArgs): number;
+}
+export {};

package/lib/components/editor/parseScript/buildInFuncNamespace/matrix.d.ts

@@ -0,0 +1,136 @@
+import { VSortOrder } from "../enum";
+import { PseudoArray } from "./array";
+interface IMatrixArgs {
+    rows?: number;
+    columns?: number;
+    initial_value?: any;
+    id?: Matrix;
+    column?: number;
+    row?: number;
+    power?: number;
+    value?: number;
+    id2?: any;
+    from_row?: number;
+    to_row?: number;
+    from_column?: number;
+    to_column?: number;
+    order?: VSortOrder;
+    array_id?: PseudoArray;
+    row1?: number;
+    row2?: number;
+    column1?: number;
+    column2?: number;
+}
+export default class BuildInMatrix {
+    new({ rows, columns, initial_value }?: IMatrixArgs): Matrix;
+    avg({ id }: IMatrixArgs): number | undefined;
+    col({ id, column }: IMatrixArgs): PseudoArray | undefined;
+    det({ id }: IMatrixArgs): number | undefined;
+    get({ id, row, column }: IMatrixArgs): any;
+    inv({ id }: IMatrixArgs): Matrix | undefined;
+    max({ id }: IMatrixArgs): any;
+    min({ id }: IMatrixArgs): any;
+    pow({ id, power }: IMatrixArgs): Matrix | undefined;
+    row({ id, row }: IMatrixArgs): PseudoArray | undefined;
+    set({ id, row, column, value }: IMatrixArgs): void;
+    sum({ id, id2 }: IMatrixArgs): Matrix | undefined;
+    copy({ id }: IMatrixArgs): Matrix | undefined;
+    diff({ id, id2 }: IMatrixArgs): Matrix | undefined;
+    rows({ id }: IMatrixArgs): number | undefined;
+    columns({ id }: IMatrixArgs): number | undefined;
+    fill({ id, value, from_row, to_row, from_column, to_column }: IMatrixArgs): void;
+    kron({ id, id2 }: IMatrixArgs): Matrix | undefined;
+    mode({ id }: IMatrixArgs): any;
+    mult({ id, id2 }: IMatrixArgs): Matrix | undefined;
+    pinv({ id }: IMatrixArgs): Matrix | undefined;
+    rank({ id }: IMatrixArgs): number | undefined;
+    sort({ id, column, order }: IMatrixArgs): void;
+    trace({ id }: IMatrixArgs): number | undefined;
+    concat({ id, id2 }: IMatrixArgs): Matrix | undefined;
+    median({ id }: IMatrixArgs): any;
+    add_col({ id, column, array_id }: IMatrixArgs): void;
+    add_row({ id, row, array_id }: IMatrixArgs): void;
+    is_zero({ id }: IMatrixArgs): boolean | undefined;
+    reshape({ id, rows, columns }: IMatrixArgs): void | undefined;
+    reverse({ id }: IMatrixArgs): void;
+    is_binary({ id }: IMatrixArgs): boolean | undefined;
+    is_square({ id }: IMatrixArgs): boolean | undefined;
+    submatrix({ id, from_row, to_row, from_column, to_column }: IMatrixArgs): Matrix | undefined;
+    swap_rows({ id, row1, row2 }: IMatrixArgs): void;
+    transpose({ id }: IMatrixArgs): Matrix | undefined;
+    remove_col({ id, column }: IMatrixArgs): PseudoArray | undefined;
+    remove_row({ id, row }: IMatrixArgs): PseudoArray | undefined;
+    eigenvalues({ id }: IMatrixArgs): PseudoArray | undefined;
+    is_diagonal({ id }: IMatrixArgs): boolean | undefined;
+    is_identity({ id }: IMatrixArgs): boolean | undefined;
+    eigenvectors({ id }: IMatrixArgs): Matrix | undefined;
+    is_symmetric({ id }: IMatrixArgs): boolean | undefined;
+    swap_columns({ id, column1, column2 }: IMatrixArgs): void;
+    is_stochastic({ id }: IMatrixArgs): boolean | undefined;
+    is_triangular({ id }: IMatrixArgs): boolean | undefined;
+    elements_count({ id }: IMatrixArgs): number | undefined;
+    is_antidiagonal({ id }: IMatrixArgs): boolean | undefined;
+    is_antisymmetric({ id }: IMatrixArgs): boolean | undefined;
+}
+declare class Matrix {
+    private _matrixInstance;
+    constructor(rows?: number, columns?: number, initial_value?: any);
+    get _matrixArray(): any[][];
+    get _value(): PseudoArray[];
+    set _value(matrix: PseudoArray[]);
+    get isMatrix(): boolean;
+    private _createMatrix;
+    avg(): number;
+    col({ column }: IMatrixArgs): PseudoArray;
+    det(): number;
+    get({ row, column }: IMatrixArgs): any;
+    inv(): Matrix;
+    max(): any;
+    min(): any;
+    pow({ power }: IMatrixArgs): Matrix;
+    row({ row }: IMatrixArgs): PseudoArray;
+    set({ row, column, value }: IMatrixArgs): void;
+    sum({ id2 }: IMatrixArgs): Matrix;
+    copy(): Matrix;
+    diff({ id2 }: IMatrixArgs): Matrix;
+    rows(): number;
+    columns(): number;
+    fill({ value, from_row, to_row, from_column, to_column }?: IMatrixArgs): void;
+    kron({ id2 }: IMatrixArgs): Matrix;
+    mode(): any;
+    mult({ id2 }: IMatrixArgs): Matrix;
+    pinv(): Matrix;
+    rank(): number;
+    sort({ column, order }?: IMatrixArgs): void;
+    trace(): number;
+    concat({ id2 }: IMatrixArgs): this;
+    median(): any;
+    add_col({ column, array_id }?: IMatrixArgs): void;
+    add_row({ row, array_id }: IMatrixArgs): void;
+    is_zero(): boolean;
+    reshape({ rows, columns }: IMatrixArgs): void;
+    reverse(): void;
+    is_binary(): boolean;
+    is_square(): boolean;
+    submatrix({ from_row, to_row, from_column, to_column }?: IMatrixArgs): Matrix;
+    swap_rows({ row1, row2 }: IMatrixArgs): void;
+    transpose(): Matrix;
+    remove_col({ column }?: IMatrixArgs): PseudoArray;
+    remove_row({ row }?: IMatrixArgs): PseudoArray;
+    eigenvalues(): PseudoArray;
+    is_diagonal(): boolean;
+    is_identity(): boolean;
+    eigenvectors(): Matrix;
+    is_symmetric(): boolean;
+    swap_columns({ column1, column2 }: IMatrixArgs): void;
+    is_stochastic(): boolean;
+    is_triangular(): boolean;
+    elements_count(): number;
+    is_antidiagonal(): boolean;
+    is_antisymmetric(): boolean;
+    private _isUpperTriangular;
+    private _isLowerTriangular;
+    private _newMatrix;
+    private _matrixRank;
+}
+export {};

package/lib/components/editor/parseScript/buildInFuncNamespace/string.d.ts

@@ -0,0 +1,43 @@
+import { PseudoArray } from "./array";
+interface IStrArgs {
+    source?: string;
+    str?: string;
+    regex?: string;
+    string?: string;
+    separator?: string;
+    formatString?: string;
+    repeat?: number;
+    target?: string;
+    replacement?: string;
+    occurrence?: number;
+    value?: any;
+    format?: string;
+    begin_pos?: number;
+    end_pos?: number;
+    time?: number;
+    timezone?: string;
+}
+export default class BuildInStr {
+    pos({ source, str }: IStrArgs): number | undefined;
+    trim({ source }: IStrArgs): string | undefined;
+    lower({ source }: IStrArgs): string | undefined;
+    match({ source, regex }: IStrArgs): string;
+    split({ string, separator }: IStrArgs): PseudoArray;
+    upper({ source }: IStrArgs): string | undefined;
+    format({ formatString }: IStrArgs, args: any[]): string;
+    length({ string }: IStrArgs): number | undefined;
+    repeat({ source, repeat, separator }: IStrArgs): string;
+    replace({ source, target, replacement, occurrence }: IStrArgs): string | undefined;
+    contains({ source, str }: IStrArgs): boolean | undefined;
+    endswith({ source, str }: IStrArgs): boolean | undefined;
+    tonumber({ string }: IStrArgs): number | undefined;
+    tostring({ value, format }: IStrArgs): string | number | undefined;
+    private _arrToStr;
+    substring({ source, begin_pos, end_pos }: IStrArgs): string | undefined;
+    startswith({ source, str }: IStrArgs): boolean | undefined;
+    format_time({ time, format, timezone }: IStrArgs): string;
+    replace_all({ source, target, replacement }: IStrArgs): string | undefined;
+    private _formatNumber;
+    private _strFormat;
+}
+export {};

package/lib/components/editor/parseScript/buildInFuncNamespace/ta.d.ts

@@ -0,0 +1,116 @@
+import { BuiltInVariables } from "../buildInVariables";
+import BuildInTimeframe from "./timeframe";
+import BuildInMath from "./math";
+interface ITaArgs {
+    series?: number;
+    length?: number;
+    offset?: number;
+    sigma?: number;
+    floor?: boolean;
+    source?: number;
+    condition?: boolean;
+    biased?: boolean;
+    mult?: number;
+    source1?: number;
+    source2?: number;
+    diLength?: number;
+    adxSmoothing?: number;
+    useTrueRange?: boolean;
+    fastlen?: number;
+    slowlen?: number;
+    siglen?: number;
+    percentage?: number;
+    type?: string;
+    anchor?: boolean;
+    developing?: boolean;
+    leftbars?: number;
+    rightbars?: number;
+    start?: number;
+    inc?: number;
+    max?: number;
+    high?: number;
+    low?: number;
+    factor?: number;
+    atrPeriod?: number;
+    handle_na?: boolean;
+    short_length?: number;
+    long_length?: number;
+    occurrence?: number;
+    stdev_mult?: number;
+}
+export default class BuildInTa {
+    private _cacheData;
+    private _variables;
+    private _math;
+    private _timeframe;
+    constructor(variables: BuiltInVariables, math: BuildInMath, timeframe: BuildInTimeframe);
+    alma({ series, length, offset, sigma, floor }: ITaArgs, posStr: string): number | undefined;
+    sma({ source, length }: ITaArgs, posStr: string): number | undefined;
+    rma({ source, length }: ITaArgs, posStr: string): number | undefined;
+    atr({ length }: ITaArgs, posStr: string): number | undefined;
+    barssince({ condition }: ITaArgs, posStr: string): any;
+    stdev({ source, length, biased }: ITaArgs, posStr: string): number | undefined;
+    private _sum;
+    bb({ series, length, mult }: ITaArgs, posStr: string): number[] | undefined;
+    bbw({ series, length, mult }: ITaArgs, posStr: string): number | undefined;
+    cci({ source, length }: ITaArgs, posStr: string): number | undefined;
+    change({ source, length }: ITaArgs, posStr: string): any;
+    cmo({ series, length }: ITaArgs, posStr: string): number | undefined;
+    cog({ source, length }: ITaArgs, posStr: string): number | undefined;
+    correlation({ source1, source2, length }: ITaArgs, posStr: string): number | undefined;
+    cross({ source1, source2 }: ITaArgs, posStr: string): boolean | undefined;
+    crossover({ source1, source2 }: ITaArgs, posStr: string): boolean | undefined;
+    crossunder({ source1, source2 }: ITaArgs, posStr: string): boolean | undefined;
+    cum({ source }: ITaArgs, posStr: string): any;
+    dev({ source, length }: ITaArgs, posStr: string): number | undefined;
+    dmi({ diLength, adxSmoothing }: ITaArgs, posStr: string): (number | undefined)[];
+    ema({ source, length }: ITaArgs, posStr: string): any;
+    falling({ source, length }: ITaArgs, posStr: string): any;
+    rising({ source, length }: ITaArgs, posStr: string): any;
+    highest({ source, length }: ITaArgs, posStr: string): number | undefined;
+    highestbars({ source, length }: ITaArgs, posStr: string): number | undefined;
+    wma({ source, length }: ITaArgs, posStr: string): number | undefined;
+    hma({ source, length }: ITaArgs, posStr: string): number | undefined;
+    kc({ series, length, mult, useTrueRange }: ITaArgs, posStr: string): any[];
+    kcw({ series, length, mult, useTrueRange }: ITaArgs, posStr: string): number | undefined;
+    linreg({ source, length, offset }: ITaArgs, posStr: string): number | undefined;
+    lowest({ source, length }: ITaArgs, posStr: string): number | undefined;
+    lowestbars({ source, length }: ITaArgs, posStr: string): number | undefined;
+    macd({ source, fastlen, slowlen, siglen }: ITaArgs, posStr: string): any[];
+    max({ source }: ITaArgs, posStr: string): any;
+    min({ source }: ITaArgs, posStr: string): any;
+    median({ source, length }: ITaArgs, posStr: string): any;
+    mfi({ series, length }: ITaArgs, posStr: string): number | undefined;
+    mode({ source, length }: ITaArgs, posStr: string): any;
+    mom({ source, length }: ITaArgs, posStr: string): any;
+    percentile_linear_interpolation({ source, length, percentage }: ITaArgs, posStr: string): number | undefined;
+    percentile_nearest_rank({ source, length, percentage }: ITaArgs, posStr: string): number | undefined;
+    percentrank({ source, length }: ITaArgs, posStr: string): number | undefined;
+    pivot_point_levels({ type, anchor, developing }: ITaArgs, posStr: string): number[];
+    private _traditional;
+    private _fibonacci;
+    private _woodie;
+    private _classic;
+    private _DM;
+    private _camarilla;
+    pivothigh({ source, leftbars, rightbars }: ITaArgs, posStr: string): any;
+    pivotlow({ source, leftbars, rightbars }: ITaArgs, posStr: string): any;
+    range({ source, length }: ITaArgs, posStr: string): number | undefined;
+    roc({ source, length }: ITaArgs, posStr: string): number | undefined;
+    rsi({ source, length }: ITaArgs, posStr: string): number | undefined;
+    sar({ start, inc, max }: ITaArgs, posStr: string): any;
+    stoch({ source, high, low, length }: ITaArgs, posStr: string): number | undefined;
+    supertrend({ factor, atrPeriod }: ITaArgs, posStr: string): number[] | undefined[];
+    swma({ source }: ITaArgs, posStr: string): number | undefined;
+    tr({ handle_na }: ITaArgs, posStr: string): number | undefined;
+    tsi({ source, short_length, long_length }: ITaArgs, posStr: string): number | undefined;
+    valuewhen({ condition, source, occurrence }: ITaArgs, posStr: string): any;
+    variance({ source, length, biased }: ITaArgs, posStr: string): number | undefined;
+    vwap({ source, anchor, stdev_mult }: ITaArgs, posStr: string): number | (number | undefined)[] | undefined;
+    vwma({ source, length }: ITaArgs, posStr: string): number | undefined;
+    wpr({ length }: ITaArgs, posStr: string): number | undefined;
+    private _sort;
+    private _cacheDataList;
+    private _cacheDataHandle;
+}
+export {};

package/lib/components/editor/parseScript/buildInFuncNamespace/timeframe.d.ts

@@ -0,0 +1,19 @@
+import { BuiltInVariables } from "../buildInVariables";
+interface ITimeArgs {
+    timeframe?: string;
+    session?: string;
+    timezone?: string;
+    bars_back?: number;
+    time?: number;
+    seconds?: number;
+}
+export default class BuildInTimeframe {
+    private _variables;
+    private _cacheData;
+    constructor(variables: BuiltInVariables);
+    change({ timeframe }: ITimeArgs, posStr: string): boolean;
+    in_seconds({ timeframe }?: ITimeArgs): number;
+    from_seconds({ seconds }: ITimeArgs): string;
+    private _calcTimeOffset;
+}
+export {};

package/lib/components/editor/parseScript/buildInVariables.d.ts

@@ -0,0 +1,122 @@
+import { IKeyObjectValue } from "../type";
+import UserTypeClass from "./userTypeClass";
+export declare class BuiltInVariables {
+    private _cacheData;
+    private _barIndex;
+    private _isRealTimeBar;
+    private _barstate;
+    private _priceVariables;
+    private _lastBarIndex;
+    private _currentBarTime;
+    private _lastBarTime;
+    private _period;
+    private _offsetTime;
+    private _timeframe;
+    private _ta;
+    constructor();
+    get ta(): Ta;
+    get na(): undefined;
+    get last_bar_index(): number;
+    get bar_index(): number;
+    get barstate(): Barstate;
+    get close(): number;
+    get low(): number;
+    get open(): number;
+    get high(): number;
+    get volume(): number;
+    get ohlc4(): number;
+    get hl2(): number;
+    get hlc3(): number;
+    get hlcc4(): number;
+    get hour(): number;
+    get minute(): number;
+    get second(): number;
+    get month(): number;
+    get year(): number;
+    get dayofweek(): number;
+    get dayofmonth(): number;
+    get weekofyear(): number;
+    get last_bar_time(): number;
+    get time(): number;
+    get time_close(): number | undefined;
+    get timenow(): number;
+    get time_tradingday(): number;
+    get timeframe(): Timeframe;
+    getTimeTradingday(time: number, period: string): number;
+    updateData(data: IKeyObjectValue): void;
+    getCacheData(key: string, preIndex: number, value: any, tokenIndex: string): any;
+    setCacheData(key: string, value: any): void;
+    getTypeInstance(fileds: IKeyObjectValue, varipKeys: string[]): UserTypeClass;
+    getVarValue(name: string, position: string, declare: string): any;
+    setVarValue(name: string, position: string, val: any, declare: string): any;
+    add(val1: any, val2: any): any;
+    sub(val1: any, val2: any): number | any[];
+}
+export declare class Barstate {
+    private _isMarketOpen;
+    private _currentBarIndex;
+    private _totalBarIndex;
+    private _isRealTimeBar;
+    private _preBarIndex;
+    constructor();
+    update(currentBarIndex: number, totalBarIndex: number, isRealTimeBar: boolean, isMarketOpen: boolean): void;
+    get isnew(): boolean;
+    get islast(): boolean;
+    get isfirst(): boolean;
+    get ishistory(): boolean;
+    get isrealtime(): boolean;
+    get isconfirmed(): boolean;
+    get islastconfirmedhistory(): boolean;
+}
+export declare class Timeframe {
+    private _period;
+    private _multiplier;
+    private _unit;
+    constructor();
+    update(period: string): void;
+    get isdaily(): boolean;
+    get isdwm(): boolean;
+    get isintraday(): boolean;
+    get isminutes(): boolean;
+    get ismonthly(): boolean;
+    get isseconds(): boolean;
+    get isweekly(): boolean;
+    get multiplier(): number;
+    get period(): string;
+}
+export declare class Ta {
+    private _variables;
+    private _preAccdist;
+    private _preNviObj;
+    private _prePviObj;
+    private _preTr;
+    private _preObv;
+    private _prePvt;
+    private _preWad;
+    private _preVwap;
+    constructor(variables: BuiltInVariables);
+    get isRealTime(): boolean;
+    get accdist(): number;
+    get iii(): number;
+    get nvi(): number;
+    get wvad(): number;
+    get obv(): any;
+    get pvi(): number;
+    get tr(): number | undefined;
+    get pvt(): any;
+    get wad(): any;
+    get vwap(): number;
+    private _getNvi;
+    private _getPvi;
+}
+export declare class Session {
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    get isfirstbar(): boolean;
+    get isfirstbar_regular(): boolean;
+    get islastbar(): boolean;
+    get islastbar_regular(): boolean;
+    get ismarket(): boolean;
+    get ispostmarket(): boolean;
+    get ispremarket(): boolean;
+}

package/lib/components/editor/parseScript/constants.d.ts

@@ -0,0 +1,56 @@
+import { VType } from "./enum";
+export declare const ERRORS_TIPS: {
+    onlyInLoop: string;
+    invalidType: string;
+    typeUseError: string;
+    notTypeKeyword: string;
+    undeclared: string;
+    repeatVar: string;
+    typeMismatch: string;
+    assignTypeMismatch: string;
+    voidNotVar: string;
+    declareTypeErr: string;
+    mapKeyValErr: string;
+    inputSourceErr: string;
+    buildInUseErr: string;
+    argsLenErr: string;
+    requiredParamErr: string;
+    argsSyntaxErr: string;
+    requestArgsErr: string;
+    mapKeyErr: string;
+    templateErr: string;
+    templateNoSupportErr: string;
+    ifOrSwitchTypeErr: string;
+    argsNameErr: string;
+    noFiledErr: string;
+    methodNotExistErr: string;
+    tupleVarErr: string;
+    tupleLeftVarErr: string;
+    tupleRightVarErr: string;
+    tempateTypeErr: string;
+    qualifierErr: string;
+    notFindFuncErr: string;
+    naVarErr: string;
+    notHistoryErr: string;
+    defaultValueErr: string;
+    defaultValueTypeErr: string;
+    unaryErr: string;
+    funcArgAssignErr: string;
+    declaredErr: string;
+    globalFuncErr: string;
+    onlyStatementErr: string;
+};
+export declare const WARNING_TIPS: {
+    repeatVar: string;
+    typeMismatch: string;
+    moreSameArg: string;
+    localScopeGetHistory: string;
+    localScopeWarning: string;
+};
+export declare const QUALIFIERS: VType[];
+export declare const BASE_TYPE: VType[];
+export declare const PLOT_DISPLAY_TYPES: string[];
+export declare const ONLY_STATEMENTS: string[];
+export declare const GLOBAL_FUNCS: string[];
+export declare const NAMESPACE_CALL_SELF_FUNCS: string[];
+export declare const SOURCE_TYPE_BUILTIN: string[];