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

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

@@ -299,5 +299,7 @@ export declare class BuildInConstants {
         belowbar: VYloc;
         price: VYloc;
     };
+    true: boolean;
+    false: boolean;
     updateData(): void;
 }

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

@@ -1,9 +1,9 @@
-import { VSortOrder } from "../enum";
+import { VInsType, VSortOrder } from "../enum";
 import { TccErrorListener } from ".";
 interface IArrayArgs {
-    id?: PseudoArray;
-    id1?: PseudoArray;
-    id2?: PseudoArray;
+    id?: IPseudoArray;
+    id1?: IPseudoArray;
+    id2?: IPseudoArray;
     size?: number;
     initial_value?: any;
     index_from?: number;
@@ -21,31 +21,31 @@ interface IArrayArgs {
 export default class BuildInArray {
     private _errorListener;
     constructor(errorListener: TccErrorListener);
-    new({ size, initial_value, type }?: IArrayArgs): PseudoArray;
-    new_float({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_int({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_color({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_bool({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_string({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_line({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_box({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_table({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_linefill({ size, initial_value }?: IArrayArgs): PseudoArray;
-    new_label({ size, initial_value }?: IArrayArgs): PseudoArray;
-    copy({ id }: IArrayArgs): PseudoArray | undefined;
-    slice({ id, index_from, index_to }: IArrayArgs): PseudoArray | undefined;
+    new({ size, initial_value, type }?: IArrayArgs): IPseudoArray;
+    new_float({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_int({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_color({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_bool({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_string({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_line({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_box({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_table({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_linefill({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    new_label({ size, initial_value }?: IArrayArgs): IPseudoArray;
+    copy({ id }: IArrayArgs): IPseudoArray | undefined;
+    slice({ id, index_from, index_to }: IArrayArgs): IPseudoArray | undefined;
     size({ id }: IArrayArgs): number | undefined;
     first({ id }: IArrayArgs): any;
-    abs({ id }: IArrayArgs, posStr: string): PseudoArray | undefined;
+    abs({ id }: IArrayArgs, posStr: string): IPseudoArray | undefined;
     avg({ id }: IArrayArgs, posStr: string): number | undefined;
     binary_search({ id, val }: IArrayArgs, posStr: string): number | undefined;
     binary_search_leftmost({ id, val }: IArrayArgs, posStr: string): number | undefined;
     binary_search_rightmost({ id, val }: IArrayArgs, posStr: string): number | undefined;
     clear({ id }: IArrayArgs): void;
-    concat({ id1, id2 }: IArrayArgs): PseudoArray | undefined;
+    concat({ id1, id2 }: IArrayArgs): IPseudoArray | undefined;
     covariance({ id1, id2, biased }: IArrayArgs, posStr: string): number | undefined;
     every({ id }: IArrayArgs, posStr: string): boolean | undefined;
-    from(_: any, arrVals: any[]): PseudoArray;
+    from(_: any, arrVals: any[]): IPseudoArray;
     fill({ id, value, index_from, index_to }: IArrayArgs): void;
     get({ id, index }: IArrayArgs): any;
     includes({ id, value }: IArrayArgs): boolean | undefined;
@@ -54,7 +54,7 @@ export default class BuildInArray {
     join({ id, separator }: IArrayArgs, posStr: string): string | undefined;
     last({ id }: IArrayArgs): any;
     lastindexof({ id, value }: IArrayArgs): number | undefined;
-    max({ id, nth }: IArrayArgs, posStr: string): number | undefined;
+    max(arg: IArrayArgs, posStr: string): number | undefined;
     median({ id }: IArrayArgs, posStr: string): number | undefined;
     min({ id, nth }: IArrayArgs, posStr: string): number | undefined;
     mode({ id }: IArrayArgs, posStr: string): number | undefined;
@@ -65,72 +65,17 @@ export default class BuildInArray {
     push({ id, value }: IArrayArgs): void;
     range({ id }: IArrayArgs, posStr: string): number | undefined;
     remove({ id, index }: IArrayArgs): any;
-    reverse({ id }: IArrayArgs): void | undefined;
+    reverse({ id }: IArrayArgs): void;
     set({ id, index, value }: IArrayArgs): void;
     shift({ id }: IArrayArgs): any;
     some({ id }: IArrayArgs, posStr: string): boolean | undefined;
     sort({ id, order }: IArrayArgs, posStr: string): void;
-    sort_indices({ id, order }: IArrayArgs, posStr: string): PseudoArray | undefined;
-    standardize({ id }: IArrayArgs, posStr: string): PseudoArray | undefined;
+    sort_indices({ id, order }: IArrayArgs, posStr: string): IPseudoArray | undefined;
+    standardize({ id }: IArrayArgs, posStr: string): IPseudoArray | undefined;
     stdev({ id, biased }: IArrayArgs, posStr: string): number | undefined;
     sum({ id }: IArrayArgs, posStr: string): any;
     unshift({ id, value }: IArrayArgs): void;
     variance({ id, biased }: IArrayArgs, posStr: string): number | undefined;
-}
-export declare class PseudoArray {
-    private _arrInstance;
-    private _errorListener?;
-    private _isNumber?;
-    private _thisType?;
-    constructor(size?: number, initialValue?: any, errorListener?: TccErrorListener, type?: string);
-    get isArray(): boolean;
-    get _value(): any[];
-    set _value(val: any[]);
-    private _deepCopyData;
-    private _copyData;
-    copy(): PseudoArray;
-    slice({ index_from, index_to }: IArrayArgs): PseudoArray;
-    size(): number;
-    first(): any;
-    abs(posStr: string): PseudoArray;
-    avg(posStr: string): number;
-    binary_search({ val }: IArrayArgs, posStr: string): number;
-    binary_search_leftmost({ val }: IArrayArgs, posStr: string): number;
-    binary_search_rightmost({ val }: IArrayArgs, posStr: string): number;
-    clear(): void;
-    concat({ id2 }: IArrayArgs): this;
-    covariance({ id2, biased }: IArrayArgs, posStr: string): number | undefined;
-    every(posStr: string): boolean;
-    fill({ value, index_from, index_to }: IArrayArgs): void;
-    get({ index }: IArrayArgs): any;
-    includes({ value }: IArrayArgs): boolean;
-    indexof({ value }: IArrayArgs): number;
-    insert({ index, value }: IArrayArgs): void;
-    join({ separator }: IArrayArgs | undefined, posStr: string): string;
-    last(): any;
-    lastindexof({ value }: IArrayArgs): number;
-    max(arg: IArrayArgs, posStr: string): number;
-    median(posStr: string): number;
-    min(arg: IArrayArgs, posStr: string): number;
-    mode(posStr: string): number;
-    percentile_linear_interpolation({ percentage }: IArrayArgs, posStr: string): number | undefined;
-    percentile_nearest_rank({ percentage }: IArrayArgs, posStr: string): number | undefined;
-    percentrank({ index }: IArrayArgs, posStr: string): number | undefined;
-    pop(): any;
-    push({ value }: IArrayArgs): void;
-    range(posStr: string): number | undefined;
-    remove({ index }: IArrayArgs): any;
-    reverse(): void;
-    set({ index, value }: IArrayArgs): void;
-    shift(): any;
-    some(posStr: string): boolean;
-    sort(arg: IArrayArgs, posStr: string): void;
-    sort_indices(arg: IArrayArgs, posStr: string): PseudoArray;
-    standardize(posStr: string): PseudoArray;
-    stdev(arg: IArrayArgs, posStr: string): number | undefined;
-    sum(posStr: string): any;
-    unshift({ value }: IArrayArgs): void;
-    variance(arg: IArrayArgs, posStr: string): number | undefined;
     private _calculateVariances;
     private _calculateStandardDeviations;
     private _standardizeArray;
@@ -148,4 +93,12 @@ export declare class PseudoArray {
     private _binarySearchLeftMost;
     private _binarySearchRightMost;
 }
+export interface IPseudoArray {
+    isArray: boolean;
+    typeName?: string;
+    type: VInsType;
+    _isNumber: boolean;
+    _value: any[];
+}
+export declare function createPseudoArray(size?: number, initialValue?: any, type?: string): IPseudoArray;
 export {};

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

@@ -1,7 +1,8 @@
 import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
 import { VExtend, VLineStyle, VSize, VText, VType, VXloc } from "../enum";
-import { Point, TccErrorListener } from "./index";
+import { IDrawComponent } from "../type";
+import { IPoint as Point, TccErrorListener } from "./index";
 export interface IBoxArgs {
     id?: string;
     top_left?: Point;
@@ -30,7 +31,7 @@ export interface IBoxArgs {
     bar_index?: number;
 }
 type VBoxArgs = Omit<IBoxArgs, 'id'> & {
-    id: Box;
+    id: IDrawComponent;
 };
 export default class BuildInBox {
     private _variables;
@@ -40,54 +41,59 @@ export default class BuildInBox {
     box({ x }: {
         x?: Box;
     }): Box | undefined;
-    new(args: IBoxArgs, posStr: string, paramNames: string[]): Box;
+    new(args: IBoxArgs, posStr: string, paramNames: string[]): IDrawComponent;
     private _parameterHandle;
     private _preVerfiyArgs;
     private _paramVerfiyHandle;
     private _verfiyArgs;
     private _paramVerfiy;
-    copy({ id }: VBoxArgs, posStr: string): Box;
+    updateId(box: Box): string;
+    copy({ id }: VBoxArgs, posStr: string): IDrawComponent | undefined;
     delete({ id }: VBoxArgs, posStr: string): void;
     get_top({ id }: VBoxArgs, posStr: string): any;
     get_bottom({ id }: VBoxArgs, posStr: string): any;
     get_left({ id }: VBoxArgs, posStr: string): any;
     get_right({ id }: VBoxArgs, posStr: string): any;
-    set_top({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_bottom({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_left({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_right({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_extend({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_bgcolor({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_border_color({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_border_width({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_border_style({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_lefttop({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_rightbottom({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text_size({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text_wrap({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text_color({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text_halign({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text_valign({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_top_left_point({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_bottom_right_point({ id, ...args }: VBoxArgs, posStr: string): void;
-    set_text_font_family({ id, ...args }: VBoxArgs, posStr: string): void;
+    set_top({ id, top }: VBoxArgs, posStr: string): void;
+    set_bottom({ id, bottom }: VBoxArgs, posStr: string): void;
+    set_text({ id, text }: VBoxArgs, posStr: string): void;
+    set_left({ id, left }: VBoxArgs, posStr: string): void;
+    set_right({ id, right }: VBoxArgs, posStr: string): void;
+    set_extend({ id, extend }: VBoxArgs, posStr: string): void;
+    set_bgcolor({ id, color }: VBoxArgs, posStr: string): void;
+    set_border_color({ id, color }: VBoxArgs, posStr: string): void;
+    set_border_width({ id, width }: VBoxArgs, posStr: string): void;
+    set_border_style({ id, style }: VBoxArgs, posStr: string): void;
+    set_lefttop({ id, left, top }: VBoxArgs, posStr: string): void;
+    set_rightbottom({ id, right, bottom }: VBoxArgs, posStr: string): void;
+    set_text_size({ id, text_size }: VBoxArgs, posStr: string): void;
+    set_text_wrap({ id, text_wrap }: VBoxArgs, posStr: string): void;
+    set_text_color({ id, text_color }: VBoxArgs, posStr: string): void;
+    set_text_halign({ id, text_halign }: VBoxArgs, posStr: string): void;
+    set_text_valign({ id, text_valign }: VBoxArgs, posStr: string): void;
+    set_top_left_point({ id, point }: VBoxArgs, posStr: string): void;
+    set_bottom_right_point({ id, point }: VBoxArgs, posStr: string): void;
+    set_text_font_family({ id, text_font_family }: VBoxArgs, posStr: string): void;
+    private _getBox;
 }
+export declare function createBox(key: string, data: IKeyObjectValue): IDrawComponent;
 export declare class Box {
     private _id;
     private _variables;
     private _errorListener;
-    private _suffix;
-    private _preId;
+    _suffix: string;
+    _preId: string;
     private _data;
     constructor(variables: BuiltInVariables, key: string, errorListener: TccErrorListener, data: IKeyObjectValue);
     get type(): VType;
     get id(): string;
+    set id(key: string);
     get preId(): string;
+    set preId(key: string);
     updateId(): string;
     set data(data: IKeyObjectValue);
     get data(): IKeyObjectValue;
-    copy(posStr: string): Box;
+    copy(posStr: string): IDrawComponent;
     delete(posStr: string): void;
     get_top(posStr: string): any;
     set_top({ top }: IBoxArgs, posStr: string): void;

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

@@ -1,4 +1,5 @@
 import { BuiltInVariables } from "../buildInVariables";
+import { VInsType } from "../enum";
 interface IChartPointArgs {
     id?: Point;
     price?: number;
@@ -10,11 +11,19 @@ export default class ChartPoint {
     constructor(variables: BuiltInVariables);
     new({ price, time, index }: IChartPointArgs): Point;
     now({ price }: IChartPointArgs): Point;
-    copy({ id }: IChartPointArgs): Point | undefined;
+    copy({ id }: IChartPointArgs): IPoint | undefined;
     from_index({ price, index }: IChartPointArgs): Point;
     from_time({ price, time }: IChartPointArgs): Point;
 }
-export declare class Point {
+export interface IPoint {
+    price?: number;
+    index?: number;
+    time?: number;
+    type: VInsType;
+    typeName: string;
+}
+export declare function createPoint(price?: number, index?: number, time?: number): IPoint;
+declare class Point {
     private _index?;
     private _price?;
     private _time?;

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

@@ -1,4 +1,4 @@
-import BuildInArray, { PseudoArray } from "./array";
+import BuildInArray, { createPseudoArray } from "./array";
 import BuildInMath from "./math";
 import BuildInTa from "./ta";
 import BuildInInput from "./input";
@@ -7,11 +7,11 @@ import BuildInMatrix from "./matrix";
 import BuildInTimeframe from "./timeframe";
 import BuildInStr from "./string";
 import BuildInMap from "./map";
-import ChartPoint, { Point } from "./chartPoint";
+import ChartPoint, { createPoint, IPoint } from "./chartPoint";
 import BuildInLabel, { PartialLabelArgs, Label } from "./label";
 import BuildInPolyline, { IPolyline, Polyline } from "./polyline";
-import BuildInLine, { ILineArgs, Line } from "./line";
-import BuildInLinefill, { TLinefill, Linefill } from "./linefill";
+import BuildInLine, { ILineArgs, Line, ILine } from "./line";
+import BuildInLinefill, { TLinefill, Linefill, ILinefill } from "./linefill";
 import BuildInBox, { IBoxArgs, Box } from "./box";
 import BuildInTable, { ITableArgs, Table } from "./table";
 import Strategy, { IOrder, IStrategy } from './strategy';
@@ -21,5 +21,5 @@ import { Log } from './log';
 import { Runtime } from './runtime';
 export { TccErrorListener } from './errorListener';
 export type { IColorArgs } from './color';
-export { BuildInArray, BuildInMath, BuildInTa, BuildInInput, BuildInColor, BuildInMatrix, ChartPoint, Point, BuildInTimeframe, BuildInStr, BuildInMap, PseudoArray, BuildInLabel, BuildInPolyline, BuildInLine, Label, Polyline, Line, BuildInLinefill, Linefill, BuildInBox, Box, BuildInTable, Table, Log, Runtime, Strategy, Request, Syminfo };
-export type { PartialLabelArgs, IPolyline, ILineArgs, TLinefill, IBoxArgs, ITableArgs, IOrder, IStrategy };
+export { BuildInArray, BuildInMath, BuildInTa, BuildInInput, BuildInColor, BuildInMatrix, ChartPoint, createPoint, BuildInTimeframe, BuildInStr, BuildInMap, createPseudoArray, BuildInLabel, BuildInPolyline, BuildInLine, Label, Polyline, Line, BuildInLinefill, Linefill, BuildInBox, Box, BuildInTable, Table, Log, Runtime, Strategy, Request, Syminfo };
+export type { PartialLabelArgs, IPolyline, ILineArgs, TLinefill, ILinefill, IBoxArgs, ITableArgs, IOrder, IStrategy, IPoint, ILine };

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

@@ -1,7 +1,8 @@
 import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
 import { VLabelStyle, VSize, VText, VType, VXloc, VYloc } from "../enum";
-import { Point, TccErrorListener } from "./index";
+import { IDrawComponent } from "../type";
+import { IPoint as Point, TccErrorListener } from "./index";
 interface ILabelArgs {
     id: string;
     point: Point;
@@ -21,42 +22,45 @@ interface ILabelArgs {
 }
 export type PartialLabelArgs = Partial<ILabelArgs>;
 type TLabelArgs = Omit<PartialLabelArgs, 'id'> & {
-    id: Label;
+    id: IDrawComponent;
 };
 export default class BuildInLabel {
     private _variables;
     private _errorListener;
     private _defaultLabel;
     constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
-    new(args: PartialLabelArgs, posStr: string, paramNames: string[]): Label;
+    new(args: PartialLabelArgs, posStr: string, paramNames: string[]): IDrawComponent;
     private _parameterHandle;
     private _preVerfiyArgs;
     private _paramVerfiyHandle;
     private _verfiyArgs;
     private _paramVerfiy;
+    updateId(id: IDrawComponent): string;
     label(args: {
         x?: Label;
     }): Label | undefined;
-    copy({ id }: TLabelArgs, posStr: string): Label;
+    copy({ id }: TLabelArgs, posStr: string): IDrawComponent | undefined;
     get_x({ id }: TLabelArgs, posStr: string): any;
     get_y({ id }: TLabelArgs, posStr: string): any;
-    set_x({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_y({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_x({ id, x }: TLabelArgs, posStr: string): void;
+    set_y({ id, y }: TLabelArgs, posStr: string): void;
     delete({ id }: TLabelArgs, posStr: string): void;
     get_text({ id }: TLabelArgs, posStr: string): any;
-    set_xy({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_size({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_xloc({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_yloc({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_style({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_xy({ id, x, y }: TLabelArgs, posStr: string): void;
+    set_size({ id, size }: TLabelArgs, posStr: string): void;
+    set_xloc({ id, x, xloc }: TLabelArgs, posStr: string): void;
+    set_yloc({ id, yloc }: TLabelArgs, posStr: string): void;
+    set_style({ id, style }: TLabelArgs, posStr: string): void;
     set_color({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_tooltip({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_point({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_text({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_tooltip({ id, tooltip }: TLabelArgs, posStr: string): void;
+    set_point({ id, point }: TLabelArgs, posStr: string): void;
+    set_text({ id, text }: TLabelArgs, posStr: string): void;
     set_textcolor({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_textalign({ id, ...args }: TLabelArgs, posStr: string): void;
-    set_text_font_family({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_textalign({ id, textalign }: TLabelArgs, posStr: string): void;
+    set_text_font_family({ id, text_font_family }: TLabelArgs, posStr: string): void;
+    private _getLabel;
 }
+export declare function createLabel(key: string, data: IKeyObjectValue): IDrawComponent;
 export declare class Label {
     private _id;
     private _variables;
@@ -71,7 +75,7 @@ export declare class Label {
     updateId(): string;
     set data(data: IKeyObjectValue);
     get data(): IKeyObjectValue;
-    copy(posStr: string): Label;
+    copy(posStr: string): IDrawComponent;
     get_x(posStr: string): any;
     get_y(posStr: string): any;
     set_x({ x }: PartialLabelArgs, posStr: string): void;

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

@@ -1,7 +1,8 @@
 import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
 import { VExtend, VLineStyle, VType, VXloc } from "../enum";
-import { Point, TccErrorListener } from "./index";
+import { IDrawComponent } from "../type";
+import { IPoint as Point, TccErrorListener } from "./index";
 export interface ILineArgs {
     id?: string;
     x?: number;
@@ -23,43 +24,51 @@ export interface ILineArgs {
     isVar?: boolean;
 }
 type LineArgs = Omit<ILineArgs, 'id'> & {
-    id: Line;
+    id: ILine;
 };
 export default class BuildInLine {
     private _variables;
     private _errorListener;
     private _defaultLine;
     constructor(variables: BuiltInVariables, errorListener: TccErrorListener);
-    new(args: ILineArgs, posStr: string, paramNames: string[]): Line;
+    new(args: ILineArgs, posStr: string, paramNames: string[]): ILine;
     private _parameterHandle;
     private _preVerfiyArgs;
     private _paramVerfiyHandle;
     private _verfiyArgs;
     private _paramVerfiy;
+    updateId(id: ILine): string;
+    static __setFillKeys(id: ILine, key: string): void;
+    static __updateFillKeys(id: ILine, oldKey: string, key: string): void;
     line(args: {
         x?: Line;
     }): Line | undefined;
-    copy({ id }: LineArgs, posStr: string): Line;
+    copy({ id }: LineArgs, posStr: string): ILine | undefined;
     delete({ id }: LineArgs, posStr: string): void;
     get_x1({ id }: LineArgs, posStr: string): any;
     get_x2({ id }: LineArgs, posStr: string): any;
     get_y1({ id }: LineArgs, posStr: string): any;
     get_y2({ id }: LineArgs, posStr: string): any;
-    set_x1({ id, ...args }: LineArgs, posStr: string): void;
-    set_x2({ id, ...args }: LineArgs, posStr: string): void;
-    set_y1({ id, ...args }: LineArgs, posStr: string): void;
-    set_y2({ id, ...args }: LineArgs, posStr: string): void;
-    set_xy1({ id, ...args }: LineArgs, posStr: string): void;
-    set_xy2({ id, ...args }: LineArgs, posStr: string): void;
-    set_xloc({ id, ...args }: LineArgs, posStr: string): void;
-    get_price({ id, ...args }: LineArgs, posStr: string): any;
+    set_x1({ id, x }: LineArgs, posStr: string): void;
+    set_x2({ id, x }: LineArgs, posStr: string): void;
+    set_y1({ id, y }: LineArgs, posStr: string): void;
+    set_y2({ id, y }: LineArgs, posStr: string): void;
+    set_xy1({ id, x, y }: LineArgs, posStr: string): void;
+    set_xy2({ id, x, y }: LineArgs, posStr: string): void;
+    set_xloc({ id, xloc, x1, x2 }: LineArgs, posStr: string): void;
+    get_price({ id, x }: LineArgs, posStr: string): any;
     set_color({ id, ...args }: LineArgs, posStr: string): void;
-    set_style({ id, ...args }: LineArgs, posStr: string): void;
-    set_width({ id, ...args }: LineArgs, posStr: string): void;
-    set_extend({ id, ...args }: LineArgs, posStr: string): void;
-    set_first_point({ id, ...args }: LineArgs, posStr: string): void;
-    set_second_point({ id, ...args }: LineArgs, posStr: string): void;
+    set_style({ id, style }: LineArgs, posStr: string): void;
+    set_width({ id, width }: LineArgs, posStr: string): void;
+    set_extend({ id, extend }: LineArgs, posStr: string): void;
+    set_first_point({ id, point }: LineArgs, posStr: string): void;
+    set_second_point({ id, point }: LineArgs, posStr: string): void;
+    private _getLine;
+}
+export interface ILine extends IDrawComponent {
+    fillKeys: string[];
 }
+export declare function createLine(key: string, data: IKeyObjectValue): ILine;
 export declare class Line {
     private _variables;
     private _id;
@@ -79,7 +88,7 @@ export declare class Line {
     set data(data: IKeyObjectValue);
     get data(): IKeyObjectValue;
     get originData(): IKeyObjectValue;
-    copy(posStr: string): Line;
+    copy(posStr: string): ILine;
     delete(posStr: string): void;
     get_price({ x }: ILineArgs, posStr: string): any;
     get_x1(posStr: string): any;

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

@@ -1,11 +1,12 @@
 import { IKeyObjectValue } from "../../type";
 import { BuiltInVariables } from "../buildInVariables";
 import { VType } from "../enum";
-import { Line, ILineArgs } from "./line";
+import { IDrawComponent } from "../type";
+import { Line, ILineArgs, ILine } from "./line";
 interface ILinefillArgs {
-    id?: Linefill;
-    line1?: Line;
-    line2?: Line;
+    id?: ILinefill;
+    line1?: ILine;
+    line2?: ILine;
     color?: string;
     bar_index?: number;
 }
@@ -17,12 +18,20 @@ export type TLinefill = Omit<ILinefillArgs, 'line1' | 'line2' | 'id'> & {
 export default class BuildInLinefill {
     private _variables;
     constructor(variables: BuiltInVariables);
-    new(args: ILinefillArgs, posStr: string): Linefill;
+    new(args: ILinefillArgs, posStr: string): ILinefill;
+    private _verifyLineKey;
+    updateId(id: ILinefill): string;
     delete({ id }: ILinefillArgs): void;
-    get_line1({ id }: ILinefillArgs): Line | undefined;
-    get_line2({ id }: ILinefillArgs): Line | undefined;
+    get_line1({ id }: ILinefillArgs): ILine | undefined;
+    get_line2({ id }: ILinefillArgs): ILine | undefined;
     set_color({ id, ...args }: ILinefillArgs): void;
 }
+export interface ILinefill extends IDrawComponent {
+    line1?: ILine;
+    line2?: ILine;
+    lineKey: string;
+}
+export declare function createLinefill(key: string, data: IKeyObjectValue, lineKey: string, line1?: ILine, line2?: ILine): ILinefill;
 export declare class Linefill {
     private _id;
     private _line1?;

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

@@ -1,6 +1,6 @@
 import { BuiltInVariables } from "../buildInVariables";
-import { PseudoArray } from "./array";
 import { BuildInStr } from ".";
+import { IKeyObjectValue } from "../../type";
 interface ILogArgs {
     message?: string;
     formatString?: string;
@@ -22,9 +22,9 @@ export declare class Log {
     get logs(): ILog[];
     clearLogForIndex(index: number): void;
     clearLogs(): void;
-    info(args: ILogArgs, replaces: (string | number | PseudoArray)[], posStr: string): void;
-    error(args: ILogArgs, replaces: (string | number | PseudoArray)[], posStr: string): void;
-    warning(args: ILogArgs, replaces: (string | number | PseudoArray)[], posStr: string): void;
+    info(args: ILogArgs, replaces: (string | number | IKeyObjectValue)[], posStr: string): void;
+    error(args: ILogArgs, replaces: (string | number | IKeyObjectValue)[], posStr: string): void;
+    warning(args: ILogArgs, replaces: (string | number | IKeyObjectValue)[], posStr: string): void;
     mergeLogs(logs: ILog[]): void;
     private _addLog;
 }

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 {};