@guihz/trading-vue-editor-tes 0.0.8 → 0.0.10

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

@@ -7,6 +7,7 @@ interface IProps {
     height?: string | number;
     width?: string | number;
     theme?: Theme;
+    readOnly?: boolean;
     options?: editor.IStandaloneEditorConstructionOptions;
     hasDiff?: boolean;
     onCursorPositionChange?: (position: IPosition) => void;
@@ -17,6 +18,10 @@ export interface IRefs {
     saveScript: () => void;
     gotoLine: () => void;
     setScript: (code: string) => void;
+    getEditorLayout: () => undefined | {
+        contentHeight: number;
+        lineCount: number | undefined;
+    };
 }
 declare const TradingEditorComponent: import("react").ForwardRefExoticComponent<IProps & import("react").RefAttributes<IRefs>>;
 export default TradingEditorComponent;

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,16 @@ 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";
+import { Log } from './log';
+import { Runtime } from './runtime';
 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, Log, Runtime };
+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/log.d.ts

@@ -0,0 +1,24 @@
+import { BuiltInVariables } from "../buildInVariables";
+interface ILogArgs {
+    message?: string;
+    formatString?: string;
+}
+interface ILog {
+    message: string;
+    time: number;
+    barIndex: number;
+    type: LogType;
+}
+type LogType = 'error' | 'info' | 'warning';
+export declare class Log {
+    private _logs;
+    private _variables;
+    constructor(variables: BuiltInVariables);
+    get logs(): ILog[];
+    clearLogs(): void;
+    info(args: ILogArgs, replaces: (string | number)[]): void;
+    error(args: ILogArgs, replaces: (string | number)[]): void;
+    warning(args: ILogArgs, replaces: (string | number)[]): void;
+    private _addLog;
+}
+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/runtime.d.ts

@@ -0,0 +1,10 @@
+import { TccErrorListener } from "./index";
+interface IRuntimeArgs {
+    message: string;
+}
+export declare class Runtime {
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
+    error({ message }: IRuntimeArgs, posStr: string): void;
+}
+export {};

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

@@ -0,0 +1,95 @@
+import { BuiltInVariables } from "../buildInVariables";
+import { VCommission, VDirection, VFormatType, VOca, VScale, VStrategy } from "../enum";
+interface IStrategy {
+    title?: string;
+    shorttitle?: string;
+    overlay?: boolean;
+    format?: VFormatType;
+    precision?: number;
+    scale?: VScale;
+    pyramiding?: number;
+    calc_on_order_fills?: boolean;
+    calc_on_every_tick?: boolean;
+    max_bars_back?: number;
+    backtest_fill_limits_assumption?: number;
+    default_qty_type?: VStrategy;
+    default_qty_value?: number;
+    initial_capital: number;
+    currency?: string;
+    slippage?: number;
+    commission_type?: VCommission;
+    commission_value?: number;
+    process_orders_on_close?: boolean;
+    close_entries_rule?: CloseEntriesRuleType;
+    margin_long?: number;
+    margin_short?: number;
+    explicit_plot_zorder?: boolean;
+    max_lines_count?: number;
+    max_labels_count?: number;
+    max_boxes_count?: number;
+    calc_bars_count?: number;
+    risk_free_rate?: number;
+    use_bar_magnifier?: boolean;
+    fill_orders_on_standard_ohlc?: boolean;
+    max_polylines_count?: number;
+}
+interface IOrderArgs {
+    id: string;
+    direction: VDirection;
+    qty?: number;
+    limit?: number;
+    stop?: number;
+    oca_name?: string;
+    oca_type?: VOca;
+    comment?: string;
+    alert_message?: string;
+    disable_alert?: false;
+}
+type CloseEntriesRuleType = 'FIFO' | 'ANY';
+export default class Strategy {
+    private _variables;
+    private _options;
+    private _totalChangeCapital;
+    private _historyOrder;
+    private _orders;
+    private _pendingOrders;
+    constructor(variables: BuiltInVariables);
+    get options(): {
+        title?: string | undefined;
+        shorttitle?: string | undefined;
+        overlay?: boolean | undefined;
+        format?: VFormatType | undefined;
+        precision?: number | undefined;
+        scale?: VScale | undefined;
+        pyramiding?: number | undefined;
+        calc_on_order_fills?: boolean | undefined;
+        calc_on_every_tick?: boolean | undefined;
+        max_bars_back?: number | undefined;
+        backtest_fill_limits_assumption?: number | undefined;
+        default_qty_type?: VStrategy | undefined;
+        default_qty_value?: number | undefined;
+        initial_capital: number;
+        currency?: string | undefined;
+        slippage?: number | undefined;
+        commission_type?: VCommission | undefined;
+        commission_value?: number | undefined;
+        process_orders_on_close?: boolean | undefined;
+        close_entries_rule?: CloseEntriesRuleType | undefined;
+        margin_long?: number | undefined;
+        margin_short?: number | undefined;
+        explicit_plot_zorder?: boolean | undefined;
+        max_lines_count?: number | undefined;
+        max_labels_count?: number | undefined;
+        max_boxes_count?: number | undefined;
+        calc_bars_count?: number | undefined;
+        risk_free_rate?: number | undefined;
+        use_bar_magnifier?: boolean | undefined;
+        fill_orders_on_standard_ohlc?: boolean | undefined;
+        max_polylines_count?: number | undefined;
+    };
+    updateOptions(options: IStrategy): void;
+    strategy(args: IStrategy): void;
+    order(args: IOrderArgs): void;
+    private _longOrderHandle;
+}
+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)[];