@guihz/trading-vue-editor-tes 0.0.7 → 0.0.9

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

@@ -1,4 +1,55 @@
 import { VPlotDisplay, VExtend, VFormatType, VHlineStyle, VLabelStyle, VLineStyle, VLocation, VSortOrder, VPlotStyle, VPosition, VAdjustment, VAlert, VBarmergeGaps, VScale, VSession, VShape, VSize, VStrategy, VCommission, VDirection, VOca, VText, VXloc, VYloc, VEarnings } from './enum';
+export declare const COLOR_BUILD_IN: {
+    aqua: string;
+    black: string;
+    blue: string;
+    fuchsia: string;
+    gray: string;
+    green: string;
+    lime: string;
+    maroon: string;
+    navy: string;
+    olive: string;
+    orange: string;
+    purple: string;
+    red: string;
+    silver: string;
+    teal: string;
+    white: string;
+    yellow: string;
+};
+export declare const CURRENCY_BUILD_IN: {
+    AUD: string;
+    BTC: string;
+    CAD: string;
+    CHF: string;
+    ETH: string;
+    EUR: string;
+    GBP: string;
+    HKD: string;
+    INR: string;
+    JPY: string;
+    KRW: string;
+    MYR: string;
+    NOK: string;
+    NONE: string;
+    NZD: string;
+    RUB: string;
+    SEK: string;
+    SGD: string;
+    TRY: string;
+    USD: string;
+    USDT: string;
+    ZAR: string;
+};
+export declare const DISPLAY_BUILD_IN: {
+    all: VPlotDisplay[];
+    data_window: VPlotDisplay[];
+    none: never[];
+    pane: VPlotDisplay[];
+    price_scale: VPlotDisplay[];
+    status_line: VPlotDisplay[];
+};
 export declare class BuildInConstants {
     adjustment: {
         dividends: VAdjustment;

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

@@ -0,0 +1,99 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { VExtend, VLineStyle, VSize, VText, VXloc } from "../enum";
+import { Point } from "./index";
+export interface IBoxArgs {
+    id?: string;
+    top_left?: Point;
+    left?: number;
+    top?: number;
+    right?: number;
+    bottom?: number;
+    bottom_right?: Point;
+    border_color?: string;
+    border_width?: number;
+    border_style?: VLineStyle;
+    style?: VLineStyle;
+    xloc?: VXloc;
+    bgcolor?: string;
+    text?: string;
+    text_size?: VSize;
+    text_color?: string;
+    extend?: VExtend;
+    text_halign?: VText;
+    text_valign?: VText;
+    text_wrap?: VText;
+    text_font_family?: string;
+    color?: string;
+    point?: Point;
+    width?: number;
+}
+type VBoxArgs = Omit<IBoxArgs, 'id'> & {
+    id: Box;
+};
+export default class BuildInBox {
+    private _variables;
+    private _defaultBox;
+    constructor(variables: BuiltInVariables);
+    box({ x }: {
+        x?: Box;
+    }, posStr: string): Box;
+    new({ top_left, bottom_right, ...args }: IBoxArgs, posStr: string): Box;
+    copy({ id }: VBoxArgs, posStr: string): Box;
+    delete({ id }: VBoxArgs): void;
+    get_top({ id }: VBoxArgs): number | undefined;
+    get_bottom({ id }: VBoxArgs): number | undefined;
+    get_left({ id }: VBoxArgs): number | undefined;
+    get_right({ id }: VBoxArgs): number | undefined;
+    set_top({ id, ...args }: VBoxArgs): void;
+    set_bottom({ id, ...args }: VBoxArgs): void;
+    set_left({ id, ...args }: VBoxArgs): void;
+    set_right({ id, ...args }: VBoxArgs): void;
+    set_extend({ id, ...args }: VBoxArgs): void;
+    set_bgcolor({ id, ...args }: VBoxArgs): void;
+    set_border_color({ id, ...args }: VBoxArgs): void;
+    set_border_width({ id, ...args }: VBoxArgs): void;
+    set_border_style({ id, ...args }: VBoxArgs): void;
+    set_lefttop({ id, ...args }: VBoxArgs): void;
+    set_rightbottom({ id, ...args }: VBoxArgs): void;
+    set_text_size({ id, ...args }: VBoxArgs): void;
+    set_text_wrap({ id, ...args }: VBoxArgs): void;
+    set_text_color({ id, ...args }: VBoxArgs): void;
+    set_text_halign({ id, ...args }: VBoxArgs): void;
+    set_text_valign({ id, ...args }: VBoxArgs): void;
+    set_top_left_point({ id, ...args }: VBoxArgs): void;
+    set_bottom_right_point({ id, ...args }: VBoxArgs): void;
+    set_text_font_family({ id, ...args }: VBoxArgs): void;
+}
+export declare class Box {
+    private _id;
+    private _variables;
+    constructor(variables: BuiltInVariables, key: string);
+    copy(posStr: string): Box;
+    delete(): void;
+    get_top(): number | undefined;
+    set_top({ top }: IBoxArgs): void;
+    get_left(): number | undefined;
+    set_left({ left }: IBoxArgs): void;
+    set_text({ text }: IBoxArgs): void;
+    get_right(): number | undefined;
+    set_right({ right }: IBoxArgs): void;
+    get_bottom(): number | undefined;
+    set_bottom({ bottom }: IBoxArgs): void;
+    set_extend({ extend }: IBoxArgs): void;
+    set_bgcolor({ color }: IBoxArgs): void;
+    set_lefttop({ left, top }: IBoxArgs): void;
+    set_text_size({ text_size }: IBoxArgs): void;
+    set_text_wrap({ text_wrap }: IBoxArgs): void;
+    set_text_color({ text_color }: IBoxArgs): void;
+    set_rightbottom({ right, bottom }: IBoxArgs): void;
+    set_text_halign({ text_halign }: IBoxArgs): void;
+    set_text_valign({ text_valign }: IBoxArgs): void;
+    set_top_left_point({ point }: IBoxArgs): void;
+    set_border_color({ color }: IBoxArgs): void;
+    set_border_style({ style }: IBoxArgs): void;
+    set_border_width({ width }: IBoxArgs): void;
+    set_bottom_right_point({ point }: IBoxArgs): void;
+    set_text_font_family({ text_font_family }: IBoxArgs): void;
+    private _getBox;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import { BuiltInVariables } from "../buildInVariables";
+interface IChartPointArgs {
+    id?: Point;
+    price?: number;
+    time?: number;
+    index?: number;
+}
+export default class ChartPoint {
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    new({ price, time, index }: IChartPointArgs): Point;
+    now({ price }: IChartPointArgs): Point;
+    copy({ id }: IChartPointArgs): Point;
+    from_index({ price, index }: IChartPointArgs): Point;
+    from_time({ price, time }: IChartPointArgs): Point;
+}
+export declare class Point {
+    private _index?;
+    private _price?;
+    private _time?;
+    constructor(price?: number, index?: number, time?: number);
+    get index(): number | undefined;
+    get price(): number | undefined;
+    get time(): number | undefined;
+    copy(): Point;
+}
+export {};

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

@@ -7,6 +7,14 @@ import BuildInMatrix from "./matrix";
 import BuildInTimeframe from "./timeframe";
 import BuildInStr from "./string";
 import BuildInMap from "./map";
+import ChartPoint, { Point } 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 BuildInBox, { IBoxArgs, Box } from "./box";
+import BuildInTable, { ITableArgs, Table } from "./table";
 export { TccErrorListener } from './errorListener';
 export type { IColorArgs } from './color';
-export { BuildInArray, BuildInMath, BuildInTa, BuildInInput, BuildInColor, BuildInMatrix, BuildInTimeframe, BuildInStr, BuildInMap, PseudoArray, VInputType };
+export { BuildInArray, BuildInMath, BuildInTa, BuildInInput, BuildInColor, BuildInMatrix, ChartPoint, Point, BuildInTimeframe, BuildInStr, BuildInMap, PseudoArray, VInputType, BuildInLabel, BuildInPolyline, BuildInLine, Label, Polyline, Line, BuildInLinefill, Linefill, BuildInBox, Box, BuildInTable, Table };
+export type { PartialLabelArgs, IPolyline, ILineArgs, TLinefill, IBoxArgs, ITableArgs };

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

@@ -0,0 +1,77 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { VLabelStyle, VSize, VText, VXloc, VYloc } from "../enum";
+import { Point } from "./index";
+interface ILabelArgs {
+    id: string;
+    point: Point;
+    text: string;
+    x: number;
+    y: number;
+    xloc: VXloc;
+    yloc: VYloc;
+    color: string;
+    size: VSize;
+    style: VLabelStyle;
+    textalign: VText;
+    textcolor: string;
+    tooltip: string;
+    text_font_family: string;
+}
+export type PartialLabelArgs = Partial<ILabelArgs>;
+type TLabelArgs = Omit<PartialLabelArgs, 'id'> & {
+    id: Label;
+};
+export default class BuildInLabel {
+    private _variables;
+    private _defaultLabel;
+    constructor(variables: BuiltInVariables);
+    new(args: PartialLabelArgs, posStr: string): Label;
+    label(args: {
+        x?: Label;
+    }, posStr: string): Label;
+    copy({ id }: TLabelArgs, posStr: string): Label;
+    get_x({ id }: TLabelArgs, posStr: string): number | undefined;
+    get_y({ id }: TLabelArgs, posStr: string): number | undefined;
+    set_x({ id, ...args }: TLabelArgs, posStr: string): void;
+    set_y({ id, ...args }: TLabelArgs, posStr: string): void;
+    delete({ id }: TLabelArgs): void;
+    get_text({ id }: TLabelArgs, posStr: string): string | undefined;
+    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_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_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;
+}
+export declare class Label {
+    private _id;
+    private _variables;
+    constructor(key: string, variables: BuiltInVariables);
+    copy(posStr: string): Label;
+    get_x(posStr: string): number | undefined;
+    get_y(posStr: string): number | undefined;
+    set_x({ x }: PartialLabelArgs, posStr: string): void;
+    set_y({ y }: PartialLabelArgs, posStr: string): void;
+    delete(): void;
+    set_xy({ x, y }: PartialLabelArgs, posStr: string): void;
+    get_text(posStr: string): string | undefined;
+    set_size({ size }: PartialLabelArgs, posStr: string): void;
+    set_text({ text }: PartialLabelArgs, posStr: string): void;
+    set_xloc({ x, xloc }: PartialLabelArgs, posStr: string): void;
+    set_yloc({ yloc }: PartialLabelArgs, posStr: string): void;
+    set_color({ color }: PartialLabelArgs, posStr: string): void;
+    set_point({ point }: PartialLabelArgs, posStr: string): void;
+    set_style({ style }: PartialLabelArgs, posStr: string): void;
+    set_tooltip({ tooltip }: PartialLabelArgs, posStr: string): void;
+    set_textalign({ textalign }: PartialLabelArgs, posStr: string): void;
+    set_textcolor({ textcolor }: PartialLabelArgs, posStr: string): void;
+    set_text_font_family({ text_font_family }: PartialLabelArgs, posStr: string): void;
+    private _getLabel;
+}
+export {};

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

@@ -0,0 +1,81 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { VExtend, VLineStyle, VXloc } from "../enum";
+import { Point } from "./index";
+export interface ILineArgs {
+    id?: string;
+    x?: number;
+    y?: number;
+    x1?: number;
+    y1?: number;
+    x2?: number;
+    y2?: number;
+    point?: Point;
+    first_point?: Point;
+    second_point?: Point;
+    xloc?: VXloc;
+    extend?: VExtend;
+    color?: string;
+    style?: VLineStyle;
+    width?: number;
+    linefills?: string[];
+}
+type LineArgs = Omit<ILineArgs, 'id'> & {
+    id: Line;
+};
+export default class BuildInLine {
+    private _variables;
+    private _defaultLine;
+    constructor(variables: BuiltInVariables);
+    new({ first_point, second_point, ...args }: ILineArgs, posStr: string): Line;
+    line(args: {
+        x?: Line;
+    }, posStr: string): Line;
+    copy({ id }: LineArgs, posStr: string): Line;
+    delete({ id }: LineArgs): void;
+    get_x1({ id }: LineArgs, posStr: string): number | undefined;
+    get_x2({ id }: LineArgs, posStr: string): number | undefined;
+    get_y1({ id }: LineArgs, posStr: string): number | undefined;
+    get_y2({ id }: LineArgs, posStr: string): number | undefined;
+    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): number | undefined;
+    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;
+}
+export declare class Line {
+    private _variables;
+    private _id;
+    constructor(key: string, variables: BuiltInVariables);
+    get data(): ILineArgs | undefined;
+    copy(posStr: string): Line;
+    delete(): void;
+    get_price({ x }: ILineArgs, posStr: string): number | undefined;
+    get_x1(posStr: string): number | undefined;
+    get_x2(posStr: string): number | undefined;
+    get_y1(posStr: string): number | undefined;
+    get_y2(posStr: string): number | undefined;
+    set_x1({ x }: ILineArgs, posStr: string): void;
+    set_x2({ x }: ILineArgs, posStr: string): void;
+    set_y1({ y }: ILineArgs, posStr: string): void;
+    set_y2({ y }: ILineArgs, posStr: string): void;
+    set_xy1({ x, y }: ILineArgs, posStr: string): void;
+    set_xy2({ x, y }: ILineArgs, posStr: string): void;
+    set_xloc({ xloc, x1, x2 }: ILineArgs, posStr: string): void;
+    set_color({ color }: ILineArgs, posStr: string): void;
+    set_style({ style }: ILineArgs, posStr: string): void;
+    set_width({ width }: ILineArgs, posStr: string): void;
+    set_extend({ extend }: ILineArgs, posStr: string): void;
+    set_first_point({ point }: ILineArgs, posStr: string): void;
+    set_second_point({ point }: ILineArgs, posStr: string): void;
+    private _getLine;
+}
+export {};

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

@@ -0,0 +1,37 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { Line, ILineArgs } from "./line";
+interface ILinefillArgs {
+    id?: Linefill;
+    line1?: Line;
+    line2?: Line;
+    color?: string;
+}
+export type TLinefill = Omit<ILinefillArgs, 'line1' | 'line2' | 'id'> & {
+    id: string;
+    line1?: ILineArgs;
+    line2?: ILineArgs;
+};
+export default class BuildInLinefill {
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    new({ line1, line2, color }: ILinefillArgs, posStr: string): Linefill;
+    delete({ id }: ILinefillArgs): void;
+    get_line1({ id }: ILinefillArgs): Line | undefined;
+    get_line2({ id }: ILinefillArgs): Line | undefined;
+    set_color({ id, ...args }: ILinefillArgs): void;
+}
+export declare class Linefill {
+    private _id;
+    private _line1?;
+    private _line2?;
+    private _variables;
+    constructor(variables: BuiltInVariables, key: string, line1?: Line, line2?: Line);
+    linefill(args: {
+        x?: Linefill;
+    }, posStr: string): Linefill;
+    delete(): void;
+    get_line1(): Line | undefined;
+    get_line2(): Line | undefined;
+    set_color({ color }: ILinefillArgs): void;
+}
+export {};

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

@@ -0,0 +1,31 @@
+import { PseudoArray } from "./index";
+import { BuiltInVariables } from "../buildInVariables";
+import { VLineStyle, VXloc } from "../enum";
+export interface IPolyline {
+    id?: string;
+    points?: PseudoArray;
+    curved?: boolean;
+    closed?: boolean;
+    xloc?: VXloc;
+    line_color?: string;
+    fill_color?: string;
+    line_style?: VLineStyle;
+    line_width?: number;
+}
+type TPolylineArgs = Omit<IPolyline, 'id'> & {
+    id: Polyline;
+};
+export default class BuildInPolyline {
+    private _variables;
+    private _defaultPolyline;
+    constructor(variables: BuiltInVariables);
+    new(args: IPolyline, posStr: string): Polyline;
+    delete({ id }: TPolylineArgs): void;
+}
+export declare class Polyline {
+    private _id;
+    private _variables;
+    constructor(key: string, variables: BuiltInVariables);
+    delete(): void;
+}
+export {};

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

@@ -59,9 +59,9 @@ export default class BuildInTa {
     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;
+    cross({ source1, source2 }: ITaArgs, posStr: string): boolean;
+    crossover({ source1, source2 }: ITaArgs, posStr: string): boolean;
+    crossunder({ source1, source2 }: ITaArgs, posStr: string): boolean;
     cum({ source }: ITaArgs, posStr: string): any;
     dev({ source, length }: ITaArgs, posStr: string): number | undefined;
     dmi({ diLength, adxSmoothing }: ITaArgs, posStr: string): (number | undefined)[];
@@ -109,6 +109,7 @@ export default class BuildInTa {
     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;
+    private _computeBands;
     vwma({ source, length }: ITaArgs, posStr: string): number | undefined;
     wpr({ length }: ITaArgs, posStr: string): number | undefined;
     private _sort;

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

@@ -0,0 +1,94 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { VPosition, VSize, VText } from "../enum";
+export interface ITableArgs {
+    id?: string;
+    table_id?: Table;
+    position?: VPosition;
+    columns?: number;
+    rows?: number;
+    bgcolor?: string;
+    frame_color?: string;
+    frame_width?: number;
+    border_color?: string;
+    border_width?: number;
+    cell?: (ITableCellArgs | undefined)[][];
+    start_column?: number;
+    start_row?: number;
+    end_column?: number;
+    end_row?: number;
+}
+interface ITableCellArgs {
+    table_id?: Table;
+    column?: number;
+    row?: number;
+    text?: string;
+    width?: number;
+    height?: number;
+    text_color?: string;
+    text_halign?: VText;
+    text_valign?: VText;
+    text_size?: VSize;
+    bgcolor?: string;
+    tooltip?: string;
+    text_font_family?: string;
+    isMerge?: boolean;
+    merge_columns?: number;
+    merge_rows?: number;
+}
+export default class BuildInTable {
+    private _variables;
+    private _defaultTable;
+    constructor(variables: BuiltInVariables);
+    table({ x }: {
+        x?: Table;
+    }, posStr: string): Table;
+    new(args: ITableArgs, posStr: string): Table;
+    cell({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_bgcolor({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_height({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_text({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_text_color({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_text_font_family({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_text_halign({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_text_valign({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_text_size({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_tooltip({ table_id, ...args }: ITableCellArgs): void;
+    cell_set_width({ table_id, ...args }: ITableCellArgs): void;
+    clear({ table_id, ...args }: ITableArgs): void;
+    delete({ table_id }: ITableArgs): void;
+    merge_cells({ table_id, ...args }: ITableArgs, posStr: string): void;
+    set_bgcolor({ table_id, ...args }: ITableArgs): void;
+    set_border_color({ table_id, ...args }: ITableArgs): void;
+    set_border_width({ table_id, ...args }: ITableArgs): void;
+    set_frame_color({ table_id, ...args }: ITableArgs): void;
+    set_frame_width({ table_id, ...args }: ITableArgs): void;
+    set_position({ table_id, ...args }: ITableArgs): void;
+}
+export declare class Table {
+    private _id;
+    private _variables;
+    private _defaultCell;
+    constructor(variables: BuiltInVariables, key: string);
+    cell(args: ITableCellArgs): void;
+    cell_set_bgcolor({ column, row, bgcolor }: ITableCellArgs): void;
+    cell_set_height({ column, row, height }: ITableCellArgs): void;
+    cell_set_text({ column, row, text }: ITableCellArgs): void;
+    cell_set_text_color({ column, row, text_color }: ITableCellArgs): void;
+    cell_set_text_font_family({ column, row, text_font_family }: ITableCellArgs): void;
+    cell_set_text_halign({ column, row, text_halign }: ITableCellArgs): void;
+    cell_set_text_valign({ column, row, text_valign }: ITableCellArgs): void;
+    cell_set_text_size({ column, row, text_size }: ITableCellArgs): void;
+    cell_set_tooltip({ column, row, tooltip }: ITableCellArgs): void;
+    cell_set_width({ column, row, width }: ITableCellArgs): void;
+    clear({ start_column, start_row, end_column, end_row }: ITableArgs): void;
+    delete(): void;
+    merge_cells({ start_column, start_row, end_column, end_row }: ITableArgs, posStr: string): void;
+    set_bgcolor({ bgcolor }: ITableArgs): void;
+    set_border_color({ border_color }: ITableArgs): void;
+    set_border_width({ border_width }: ITableArgs): void;
+    set_frame_color({ frame_color }: ITableArgs): void;
+    set_frame_width({ frame_width }: ITableArgs): void;
+    set_position({ position }: ITableArgs): void;
+    private _getTableItem;
+}
+export {};

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

@@ -39,6 +39,9 @@ export declare const ERRORS_TIPS: {
     declaredErr: string;
     globalFuncErr: string;
     onlyStatementErr: string;
+    modifyGlobalVarErr: string;
+    inputDefvalErr: string;
+    objectIsNaErr: string;
 };
 export declare const WARNING_TIPS: {
     repeatVar: string;

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

@@ -24,4 +24,5 @@ export interface IError extends IBase {
     message: string;
     type?: VMarkerSeverity;
 }
+export type WithRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
 export {};

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

@@ -45,6 +45,7 @@ export default class ParserVisitor extends ParserUtils {
         type: string;
         value: IKeyObjectValue;
     } | null;
+    private _verifyGloablVar;
     visitVarModifier: (ctx: IKeyObjectValue) => any;
     visitExpressionSequence: (ctx: IKeyObjectValue) => IKeyObjectValue[];
     visitExpressionBlockSequence: (ctx: IKeyObjectValue) => IKeyObjectValue[];
@@ -195,6 +196,7 @@ export default class ParserVisitor extends ParserUtils {
     private _againAssignHandle;
     private _typeCheck;
     private _verifyName;
+    private _judgeGatherValue;
     private _nameCheck;
     private _inBlock;
     private _errorHandle;

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

@@ -48,6 +48,7 @@ export interface IDocValue {
     isForVar?: boolean;
     hasMemberIndex?: boolean;
     declare?: string;
+    valueType?: string;
 }
 export interface IDetailedDesc {
     desc: string[];
@@ -60,6 +61,7 @@ export interface IField {
     originName?: string;
     isArg?: boolean;
     isVarip?: boolean;
+    valueType?: string;
 }
 export interface IArg {
     name: string;