@guihz/trading-vue-editor-tes 0.0.283 → 0.0.285

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

@@ -1,42 +1,51 @@
-import { TccErrorListener } from ".";
-import { PseudoArray } from "./array";
+import { IKeyObjectValue } from "../../type";
+import { VInsType } from "../enum";
 interface IMapArgs {
-    id?: PseudoMap;
+    id?: IPseudoMap;
     key?: any;
     value?: any;
-    id2?: PseudoMap;
+    id2?: IPseudoMap;
 }
 export default class BuildInMap {
-    private _errorListener;
-    constructor(errorListener: TccErrorListener);
-    new(): PseudoMap;
-    copy({ id }: IMapArgs): PseudoMap | undefined;
+    constructor();
+    new({ type }: {
+        type: string;
+    }): {
+        isMap: boolean;
+        keyTypeName: string;
+        typeName: string;
+        _value: any;
+        type: VInsType;
+    };
+    copy({ id }: IMapArgs): {
+        isMap: boolean;
+        keyTypeName: string;
+        typeName: string;
+        _value: any;
+        type: VInsType;
+    } | undefined;
     get({ id, key }: IMapArgs): any;
-    put({ id, key, value }: IMapArgs): Map<any, any> | undefined;
-    keys({ id }: IMapArgs): PseudoArray | undefined;
+    put({ id, key, value }: IMapArgs): any;
+    keys({ id }: IMapArgs): import("./array").IPseudoArray | 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;
+    values({ id }: IMapArgs): import("./array").IPseudoArray | undefined;
+    put_all({ id, id2 }: IMapArgs): IPseudoMap | undefined;
     contains({ id, key }: IMapArgs): boolean | undefined;
 }
-declare class PseudoMap {
-    private _errorListener;
-    private _mapInstance;
-    constructor(errorListener: TccErrorListener);
-    get isMap(): boolean;
-    get _value(): Map<any, any>;
-    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;
+interface IPseudoMap {
+    isMap: boolean;
+    keyTypeName: string;
+    typeName: string;
+    _value: IKeyObjectValue;
+    type: VInsType.MAP;
 }
+export declare function createMap(types: string[]): {
+    isMap: boolean;
+    keyTypeName: string;
+    typeName: string;
+    _value: any;
+    type: VInsType;
+};
 export {};

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

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

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

@@ -1,11 +1,11 @@
-import { VSortOrder } from "../enum";
-import { PseudoArray } from "./array";
+import { VInsType, VSortOrder } from "../enum";
+import { IPseudoArray } from "./array";
 import { TccErrorListener } from '.';
 interface IMatrixArgs {
     rows?: number;
     columns?: number;
     initial_value?: any;
-    id?: Matrix;
+    id?: IMatrix;
     column?: number;
     row?: number;
     power?: number;
@@ -17,7 +17,7 @@ interface IMatrixArgs {
     from_column?: number;
     to_column?: number;
     order?: VSortOrder;
-    array_id?: PseudoArray;
+    array_id?: IPseudoArray;
     row1?: number;
     row2?: number;
     column1?: number;
@@ -26,28 +26,29 @@ interface IMatrixArgs {
 }
 export default class BuildInMatrix {
     private _errorListener;
+    private _array;
     constructor(errorListener: TccErrorListener);
-    new({ rows, columns, initial_value, type }?: IMatrixArgs): Matrix;
+    new({ rows, columns, initial_value, type }?: IMatrixArgs): IMatrix;
     avg({ id }: IMatrixArgs): number | undefined;
-    col({ id, column }: IMatrixArgs): PseudoArray | undefined;
+    col({ id, column }: IMatrixArgs): IPseudoArray | undefined;
     det({ id }: IMatrixArgs): number | undefined;
     get({ id, row, column }: IMatrixArgs): any;
-    inv({ id }: IMatrixArgs): Matrix | undefined;
+    inv({ id }: IMatrixArgs): IMatrix | undefined;
     max({ id }: IMatrixArgs): any;
     min({ id }: IMatrixArgs): any;
-    pow({ id, power }: IMatrixArgs): Matrix | undefined;
-    row({ id, row }: IMatrixArgs): PseudoArray | undefined;
+    pow({ id, power }: IMatrixArgs): IMatrix | undefined;
+    row({ id, row }: IMatrixArgs): IPseudoArray | undefined;
     set({ id, row, column, value }: IMatrixArgs): void;
-    sum({ id1, id2 }: IMatrixArgs): any;
-    copy({ id }: IMatrixArgs): Matrix | undefined;
-    diff({ id1, id2 }: IMatrixArgs): any;
+    sum({ id1, id2 }: IMatrixArgs): IMatrix | undefined;
+    copy({ id }: IMatrixArgs): IMatrix | undefined;
+    diff({ id1, id2 }: IMatrixArgs): IMatrix | 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({ id1, id2 }: IMatrixArgs): any;
+    kron({ id1, id2 }: IMatrixArgs): IMatrix | undefined;
     mode({ id }: IMatrixArgs): any;
-    mult({ id1, id2 }: IMatrixArgs): any;
-    pinv({ id }: IMatrixArgs): Matrix | undefined;
+    mult({ id1, id2 }: IMatrixArgs): IPseudoArray | IMatrix | undefined;
+    pinv({ id }: IMatrixArgs): IMatrix | undefined;
     rank({ id }: IMatrixArgs): number | undefined;
     sort({ id, column, order }: IMatrixArgs): void;
     trace({ id }: IMatrixArgs): number | undefined;
@@ -56,19 +57,19 @@ export default class BuildInMatrix {
     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, posStr: string): void | undefined;
+    reshape({ id, rows, columns }: IMatrixArgs, posStr: string): void;
     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;
+    submatrix({ id, from_row, to_row, from_column, to_column }: IMatrixArgs): IMatrix | 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;
+    transpose({ id }: IMatrixArgs): IMatrix | undefined;
+    remove_col({ id, column }: IMatrixArgs): IPseudoArray | undefined;
+    remove_row({ id, row }: IMatrixArgs): IPseudoArray | undefined;
+    eigenvalues({ id }: IMatrixArgs): IPseudoArray | undefined;
     is_diagonal({ id }: IMatrixArgs): boolean | undefined;
     is_identity({ id }: IMatrixArgs): boolean | undefined;
-    eigenvectors({ id }: IMatrixArgs): Matrix | undefined;
+    eigenvectors({ id }: IMatrixArgs): IMatrix | undefined;
     is_symmetric({ id }: IMatrixArgs): boolean | undefined;
     swap_columns({ id, column1, column2 }: IMatrixArgs): void;
     is_stochastic({ id }: IMatrixArgs): boolean | undefined;
@@ -76,69 +77,18 @@ export default class BuildInMatrix {
     elements_count({ id }: IMatrixArgs): number | undefined;
     is_antidiagonal({ id }: IMatrixArgs): boolean | undefined;
     is_antisymmetric({ id }: IMatrixArgs): boolean | undefined;
-}
-declare class Matrix {
-    private _matrixInstance;
-    private _errorListener;
-    private _isNumber?;
-    private _thisType?;
-    constructor(rows: number | undefined, columns: number | undefined, initial_value: any, errorListener: TccErrorListener, type?: string);
-    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): PseudoArray | 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, posStr: string): 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;
+    private _getMatrixArray;
+}
+interface IMatrix {
+    isMatrix: boolean;
+    typeName?: string;
+    type: VInsType;
+    _isNumber: boolean;
+    _value: IPseudoArray[];
+    _matrixArray: any[][];
 }
 export {};

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

@@ -1,10 +1,11 @@
-import { PseudoArray, TccErrorListener } from "./index";
+import { TccErrorListener } from "./index";
 import { BuiltInVariables } from "../buildInVariables";
 import { VLineStyle, VType, VXloc } from "../enum";
+import { IDrawComponent } from "../type";
 import { IKeyObjectValue } from "../../type";
 export interface IPolyline {
     id?: string;
-    points?: PseudoArray;
+    points?: IKeyObjectValue;
     curved?: boolean;
     closed?: boolean;
     xloc?: VXloc;
@@ -21,11 +22,13 @@ export default class BuildInPolyline {
     private _errorListener;
     private _defaultPolyline;
     constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
-    new(args: IPolyline, posStr: string): Polyline;
+    new(args: IPolyline, posStr: string): IDrawComponent;
     private _verfiyArgs;
     private _paramVerfiy;
+    updateId(id: IDrawComponent): string;
     delete({ id }: TPolylineArgs): void;
 }
+export declare function createPolyline(key: string, data: IKeyObjectValue): IDrawComponent;
 export declare class Polyline {
     private _id;
     private _variables;

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

@@ -22,11 +22,12 @@ export default class Request {
     private _funcs;
     private _errorListener;
     constructor(variables: BuiltInVariables, id: string, funcs: BuildInFunctions, errorListener: TccErrorListener);
+    get _requestCacheData(): IKeyObjectValue;
+    set _requestCacheData(val: IKeyObjectValue);
     security(args: IRequestArgs, posStr: string): any;
     security_lower_tf(args: IRequestArgs, posStr: string): any;
     private _symbolTransform;
     private _runScriptHandle;
-    private _getCurrentData;
     private _parseExprCode;
     private _getRequestLowerTfData;
     private _getRequestData;

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

@@ -152,6 +152,8 @@ export default class Strategy {
     private _maxDrawdownVerifyIndex;
     calcOnOrderFillsData: IFillsData;
     constructor(variables: BuiltInVariables, options: IKeyObjectValue, mintick: number, errorListener: TccErrorListener, id: string);
+    get _strategyCacheData(): IKeyObjectValue;
+    set _strategyCacheData(val: IKeyObjectValue);
     get orders(): IOrder[];
     get historyOrders(): IOrder[];
     get _freezeCapital(): number;
@@ -219,6 +221,7 @@ export default class Strategy {
     private _pendingOrderHandle;
     private _pendingOrderSort;
     private _pendingCloseOrderHandle;
+    private _onCloseOrderHandle;
     private _entryOrderHandle;
     private _orderOrderHandle;
     private _getCloseOrders;

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

@@ -1,5 +1,4 @@
 import { TccErrorListener } from ".";
-import { PseudoArray } from "./array";
 interface IStrArgs {
     source?: string;
     str?: string;
@@ -28,7 +27,7 @@ export default class BuildInStr {
     trim({ source }: IStrArgs): string;
     lower({ source }: IStrArgs): string;
     match({ source, regex }: IStrArgs): string;
-    split({ string, separator }: IStrArgs): PseudoArray;
+    split({ string, separator }: IStrArgs): import("./array").IPseudoArray;
     upper({ source }: IStrArgs): string;
     format({ formatString }: IStrArgs, args: any[]): string;
     length({ string }: IStrArgs): number;
@@ -44,6 +43,7 @@ export default class BuildInStr {
     format_time({ time, format, timezone }: IStrArgs): string;
     replace_all({ source, target, replacement }: IStrArgs): string;
     private _toStringFormat;
+    private _numberDef;
     private _formatOthers;
     private _formatNumber;
     strformat({ formatString }: IStrArgs, args: any[], isFormat?: boolean): string;

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

@@ -1,5 +1,5 @@
+import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
-import { PseudoArray } from './array';
 import BuildInTimeframe from "./timeframe";
 import BuildInMath from "./math";
 interface ITaArgs {
@@ -46,6 +46,8 @@ export default class BuildInTa {
     private _math;
     private _timeframe;
     constructor(variables: BuiltInVariables, math: BuildInMath, timeframe: BuildInTimeframe);
+    get _taCacheData(): IKeyObjectValue;
+    set _taCacheData(data: IKeyObjectValue);
     alma({ series, length, offset, sigma, floor, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
     sma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
     rma({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
@@ -88,7 +90,7 @@ export default class BuildInTa {
     percentile_linear_interpolation({ source, length, percentage, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
     percentile_nearest_rank({ source, length, percentage, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
     percentrank({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
-    pivot_point_levels({ type, anchor, developing }: ITaArgs, posStr: string): PseudoArray;
+    pivot_point_levels({ type, anchor, developing }: ITaArgs, posStr: string): import("./array").IPseudoArray;
     private _getPivotPointLevels;
     private _traditional;
     private _fibonacci;

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

@@ -1,10 +1,11 @@
 import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
 import { VPosition, VSize, VText, VType } from "../enum";
+import { IDrawComponent } from "../type";
 import { TccErrorListener } from "./errorListener";
 export interface ITableArgs {
     id?: string;
-    table_id?: Table;
+    table_id?: IDrawComponent;
     position?: VPosition;
     columns?: number;
     rows?: number;
@@ -27,7 +28,7 @@ interface IMergeCell {
     end_row?: number;
 }
 interface ITableCellArgs {
-    table_id?: Table;
+    table_id?: IDrawComponent;
     column?: number;
     row?: number;
     text?: string;
@@ -47,34 +48,41 @@ interface ITableCellArgs {
 export default class BuildInTable {
     private _variables;
     private _errorListener;
+    private _defaultCell;
     private _defaultTable;
     constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
     table({ x }: {
         x?: Table;
     }): Table | undefined;
-    new(args: ITableArgs, posStr: string): Table;
+    new(args: ITableArgs, posStr: string): IDrawComponent;
     private _paramVerfiy;
+    updateId(id: IDrawComponent): string;
     cell({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_bgcolor({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_height({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_text({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_text_color({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_text_font_family({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_text_halign({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_text_valign({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_text_size({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_tooltip({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    cell_set_width({ table_id, ...args }: ITableCellArgs, posStr: string): void;
-    clear({ table_id, ...args }: ITableArgs, posStr: string): void;
+    cell_set_bgcolor({ table_id, column, row, bgcolor }: ITableCellArgs, posStr: string): void;
+    cell_set_height({ table_id, column, row, height }: ITableCellArgs, posStr: string): void;
+    cell_set_text({ table_id, column, row, text }: ITableCellArgs, posStr: string): void;
+    cell_set_text_color({ table_id, column, row, text_color }: ITableCellArgs, posStr: string): void;
+    cell_set_text_font_family({ table_id, column, row, text_font_family }: ITableCellArgs, posStr: string): void;
+    cell_set_text_halign({ table_id, column, row, text_halign }: ITableCellArgs, posStr: string): void;
+    cell_set_text_valign({ table_id, column, row, text_valign }: ITableCellArgs, posStr: string): void;
+    cell_set_text_size({ table_id, column, row, text_size }: ITableCellArgs, posStr: string): void;
+    cell_set_tooltip({ table_id, column, row, tooltip }: ITableCellArgs, posStr: string): void;
+    cell_set_width({ table_id, column, row, width }: ITableCellArgs, posStr: string): void;
+    clear({ table_id, start_column, start_row, end_column, end_row }: ITableArgs, posStr: string): void;
     delete({ table_id }: ITableArgs, posStr: string): void;
-    merge_cells({ table_id, ...args }: ITableArgs, posStr: string): void;
-    set_bgcolor({ table_id, ...args }: ITableArgs, posStr: string): void;
-    set_border_color({ table_id, ...args }: ITableArgs, posStr: string): void;
-    set_border_width({ table_id, ...args }: ITableArgs, posStr: string): void;
-    set_frame_color({ table_id, ...args }: ITableArgs, posStr: string): void;
-    set_frame_width({ table_id, ...args }: ITableArgs, posStr: string): void;
-    set_position({ table_id, ...args }: ITableArgs, posStr: string): void;
+    merge_cells({ table_id, start_column, start_row, end_column, end_row }: ITableArgs, posStr: string): void;
+    set_bgcolor({ table_id, bgcolor }: ITableArgs, posStr: string): void;
+    set_border_color({ table_id, border_color }: ITableArgs, posStr: string): void;
+    set_border_width({ table_id, border_width }: ITableArgs, posStr: string): void;
+    set_frame_color({ table_id, frame_color }: ITableArgs, posStr: string): void;
+    set_frame_width({ table_id, frame_width }: ITableArgs, posStr: string): void;
+    set_position({ table_id, position }: ITableArgs, posStr: string): void;
+    private _getTableItem;
+    private _getTable;
+    private _verfiyRequestFunc;
+    private _rowColToInt;
 }
+export declare function createTable(key: string, data: IKeyObjectValue): IDrawComponent;
 export declare class Table {
     private _id;
     private _variables;

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

@@ -1,3 +1,4 @@
+import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
 interface ITimeArgs {
     timeframe?: string;
@@ -11,6 +12,8 @@ export default class BuildInTimeframe {
     private _variables;
     private _cacheData;
     constructor(variables: BuiltInVariables);
+    get _timeframeCacheData(): IKeyObjectValue;
+    set _timeframeCacheData(data: IKeyObjectValue);
     change({ timeframe }: ITimeArgs, posStr: string): any;
     in_seconds({ timeframe }?: ITimeArgs): number;
     from_seconds({ seconds }: ITimeArgs): string;

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

@@ -12,6 +12,8 @@ export declare class Ta {
     private _preData;
     private _id;
     constructor(id: string);
+    get _varTaCacheData(): IKeyObjectValue;
+    set _varTaCacheData(data: IKeyObjectValue);
     update(currentData: IKeyObjectValue): void;
     get isRealTime(): boolean;
     get accdist(): any;

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

@@ -23,6 +23,19 @@ export declare enum VType {
     VOID = "void",
     ENUM = "enum"
 }
+export declare enum VInsType {
+    TYPE = "type",
+    ARRAY = "array",
+    BOX = "box",
+    CHART_POINT = "chart.point",
+    LABEL = "label",
+    LINE = "line",
+    LINEFILL = "linefill",
+    MAP = "map",
+    MATRIX = "matrix",
+    POLYLINE = "polyline",
+    TABLE = "table"
+}
 export declare enum VRuleType {
     FlowStmt = "FlowStmt",
     DeclareAssign = "DeclareAssign",

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

@@ -19,9 +19,7 @@ export default class ParseToJs {
     private _dependsObj;
     private _enums;
     private _preRunMembers;
-    private _isInConditionalStmt;
     private _preRunMembersFuncs;
-    private _preRunMemberFuncsCount;
     private __count;
     preParseCode: string;
     private _hasLeftVisibleBarTime;

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

@@ -1,3 +1,5 @@
+import { IKeyObjectValue } from "../type";
+import { VInsType } from "./enum";
 interface IBase {
     startColumn: number;
     startLineNumber: number;
@@ -26,4 +28,12 @@ export interface IError extends IBase {
     type?: VMarkerSeverity;
 }
 export type WithRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export interface IDrawComponent {
+    type: VInsType;
+    id: string;
+    data: IKeyObjectValue;
+    _suffix: string;
+    preId: string;
+    isDraw: boolean;
+}
 export {};

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

@@ -2,10 +2,11 @@ import { IKeyObjectValue } from "../type";
 declare class UserTypeClass {
     private _defaultParams;
     private _varipKeys;
-    constructor(params: IKeyObjectValue, keys: string[]);
-    copy(typeObject: IKeyObjectValue): IKeyObjectValue;
+    private _typeName;
+    constructor(params: IKeyObjectValue, keys: string[], typeName: string);
+    copy(typeObject: IKeyObjectValue): any;
     new(params?: IKeyObjectValue): IKeyObjectValue;
     private _createDynamicClass;
-    private _deepCopy;
+    static copy(typeObject: IKeyObjectValue): any;
 }
 export default UserTypeClass;

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

@@ -1,4 +1,4 @@
-import { IKeyValue } from "../type";
+import { IKeyObjectValue, IKeyValue } from "../type";
 import { TccErrorListener } from "./buildInFuncNamespace";
 import moment from 'moment-timezone';
 export declare function replaceTemplate(template: string, replacements: IKeyValue): string;
@@ -19,3 +19,4 @@ export declare function decimalFloor(num?: number, precision?: number): number |
 export declare function parsePeriodHandle(period?: string): string;
 export declare function transformPeriod(period: string): string;
 export declare function addRequestUseFuncError(errorListener: TccErrorListener, funcName: string, reqName: string, posStr: string): void;
+export declare function deepCopy(varData: IKeyObjectValue, newData: IKeyObjectValue): void;

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

@@ -258,6 +258,7 @@ export default class ParserVisitor extends ParserUtils {
     visitEnumElement: (ctx: IKeyObjectValue) => IKeyObjectValue;
     visitName: (ctx: IKeyObjectValue) => IKeyObjectValue;
     private _nameHandle;
+    private _getMethodFiledType;
     private _typeElementVerify;
     private _memberIndexVerify;
     private _setFuncParams;
@@ -306,6 +307,7 @@ export default class ParserVisitor extends ParserUtils {
     private _globalFuncVerify;
     private _hasMemberIndexVerify;
     private _tempFuncNameHandle;
+    private _getSelfType;
     private _getOtherNamesMethodType;
     private _expandMethodHandle;
     /**

package/lib/components/editor/type/index.d.ts

@@ -23,6 +23,7 @@ export interface IKeyObjectValue {
     [key: string]: any;
 }
 export interface IDocValue {
+    methodName?: string;
     hasAssigned?: boolean;
     name: string;
     title?: string;
@@ -58,6 +59,7 @@ export interface IDocValue {
     hasRequest?: boolean;
     isEnumMember?: boolean;
     value?: string;
+    selfArg?: IArg;
 }
 export interface IDetailedDesc {
     desc: string[];