@guihz/trading-vue-editor-tes 0.0.302 → 0.1.2

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

@@ -0,0 +1,43 @@
+import { BuildInTa } from ".";
+import { BuiltInVariables } from "../buildInVariables";
+import { VInputType, VPlotDisplay } from "../enum";
+import { TccErrorListener } from "./errorListener";
+type TSimpleType = string | number | boolean;
+interface IInputArgs {
+    id: string;
+    defval: TSimpleType;
+    title?: string;
+    type?: VInputType;
+    inline?: string;
+    group?: string;
+    display?: VPlotDisplay[];
+    sourceTypeName?: string;
+    isModify?: boolean;
+    options?: TSimpleType[];
+    confirm?: boolean;
+    minval?: number;
+    maxval?: number;
+    step?: number;
+    inputType?: VInputType;
+    index?: number;
+    modifyDefval?: TSimpleType;
+}
+interface ICacheData {
+    [key: string]: IInputArgs;
+}
+declare class Input extends BuildInTa {
+    private _inputCacheDataLoc;
+    protected _errorListener: TccErrorListener;
+    private _historyInputs;
+    private _name;
+    private _newCacheData;
+    constructor(variables: BuiltInVariables, id: string);
+    get _inputCacheData(): ICacheData;
+    set _inputCacheData(data: ICacheData);
+    updateInput(vals?: IInputArgs[]): void;
+    input(args: IInputArgs, posStr: string): TSimpleType;
+    private _cacheHandle;
+    private _verifyMaxOrMin;
+    getInputs(): IInputArgs[];
+}
+export default Input;

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

@@ -0,0 +1,50 @@
+import { IKeyObjectValue } from "../../../type";
+interface IMathArgs {
+    number?: number;
+    angle?: number;
+    base?: number;
+    exponent?: number;
+    min?: number;
+    max?: number;
+    seed?: number;
+    precision?: number;
+    source?: number;
+    length?: number;
+    radians?: number;
+    degrees?: number;
+    x?: number;
+    y?: number;
+    z?: number;
+    a?: number;
+    b?: number;
+    c?: number;
+}
+export default class BuildInMath {
+    private _mathCacheDataLoc;
+    private _barIndex;
+    constructor();
+    get _mathCacheData(): IKeyObjectValue;
+    set _mathCacheData(val: IKeyObjectValue);
+    updateMath(barIndex: number): void;
+    abs({ x }: IMathArgs): number;
+    acos({ x }: IMathArgs): number;
+    asin({ x }: IMathArgs): number;
+    atan({ x }: IMathArgs): number;
+    avg(args: IMathArgs): number;
+    ceil({ x }: IMathArgs): number;
+    floor({ x }: IMathArgs): number;
+    cos({ x }: IMathArgs): number;
+    sin({ x }: IMathArgs): number;
+    tan({ x }: IMathArgs): number;
+    exp({ x }: IMathArgs): number;
+    log({ x }: IMathArgs): number;
+    log10({ x }: IMathArgs): number;
+    max({ x, y }: IMathArgs): number | undefined;
+    min({ x, y }: IMathArgs): number | undefined;
+    pow({ base, exponent }: IMathArgs): number;
+    round({ x }: IMathArgs): number;
+    sign({ x }: IMathArgs): number | undefined;
+    sqrt({ x }: IMathArgs): number;
+    sum({ source, length }: IMathArgs, posStr: string): number | undefined;
+}
+export {};

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

@@ -0,0 +1,243 @@
+import { TccErrorListener } from ".";
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import { VCommission, VDirection, VFormatType, VOca, VScale, VStrategy } from "../enum";
+import { Risk } from '../strategyNamespace';
+export 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;
+    scriptType?: string;
+    direction_short_long?: boolean;
+}
+interface IOrderArgs {
+    id: string;
+    direction: VDirection;
+    from_entry?: string;
+    qty?: number;
+    limit?: number;
+    loss?: number;
+    stop?: number;
+    oca_name?: string;
+    oca_type?: VOca;
+    comment?: string;
+    alert_message?: string;
+    disable_alert?: false;
+    qty_percent?: number;
+    immediately?: boolean;
+    trail_price?: number;
+    trail_points?: number;
+    trail_offset?: number;
+    profit?: number;
+    comment_profit?: string;
+    comment_loss?: string;
+    comment_trailing?: string;
+    last_commission?: number;
+    when?: boolean;
+    long?: boolean;
+}
+type PlaceOrderType = 'order' | 'entry' | 'exit' | 'close' | 'close_all';
+export interface IOrder extends IOrderArgs {
+    isMarketPrice?: boolean;
+    out_id?: string;
+    in_index?: number;
+    out_index?: number;
+    in_price: number;
+    out_price?: number;
+    in_time?: number;
+    out_time?: number;
+    out_qty?: number;
+    out_comment?: string;
+    total_profit?: number;
+    max_profit?: number;
+    trading_loss?: number;
+    place_order_type?: PlaceOrderType;
+    position_close_type?: PlaceOrderType;
+    isDeal?: boolean;
+    exitIds?: string[];
+    active_price?: number;
+    trail_stop_price?: number;
+    hasOrder?: boolean;
+    isMarketPriceLimit?: boolean;
+    isMarketPriceStop?: boolean;
+    isCancel?: boolean;
+    close_qty?: number;
+    profit_percent?: number;
+    max_profit_percent?: number;
+    trading_loss_percent?: number;
+    commission?: number;
+    original_qty?: number;
+    in_low?: number;
+    in_high?: number;
+    out_low?: number;
+    out_high?: number;
+    isTiggerClose?: boolean;
+    entry_time?: number;
+}
+interface IRisk {
+    allow_entry_in?: VDirection;
+    max_cons_loss_days?: number;
+    max_drawdown?: number;
+    max_drawdown_type?: VStrategy;
+    max_intraday_filled_orders?: number;
+    max_intraday_loss?: number;
+    max_intraday_loss_type?: VStrategy;
+    max_position_size?: number;
+    isDisabledOpen?: boolean;
+    lossDays?: number;
+    totalProfit?: number;
+    intradayOrders?: number;
+    isTemporaryBan?: boolean;
+    preNetprofit?: number;
+}
+interface IData {
+    close: number;
+    high: number;
+    low: number;
+    open: number;
+}
+interface IFillsData {
+    data?: IData;
+    tradeData?: IData;
+    index: number;
+    currentData?: IData;
+}
+type CloseEntriesRuleType = 'FIFO' | 'ANY';
+export default class Strategy {
+    private _variables;
+    private _options;
+    private _totalChangeCapital;
+    private _historyOrder;
+    private _orders;
+    private _exitOrders;
+    private _pendingOrders;
+    private _mintick;
+    private _funcOptions;
+    private _pendingCloseOrders;
+    private _errorListener;
+    private _risk;
+    private _riskNamespace;
+    private _updateOptions;
+    private _maxDrawdownVerifyIndex;
+    calcOnOrderFillsData: IFillsData;
+    private _cacheArgs;
+    private _useSetArgs;
+    constructor(variables: BuiltInVariables, options: IKeyObjectValue, mintick: number, errorListener: TccErrorListener);
+    get _strategyCacheData(): IKeyObjectValue;
+    set _strategyCacheData(val: IKeyObjectValue);
+    get orders(): IOrder[];
+    get historyOrders(): IOrder[];
+    get _freezeCapital(): number;
+    get risk(): Risk;
+    get isCalcOnEveryTick(): boolean | undefined;
+    updateOptions(options?: IStrategy): void;
+    update(): void;
+    calcCurrentOrder(): void;
+    updateRisk(risk: IRisk): void;
+    endExecution(): void;
+    private _maxIntradayLoss;
+    private _maxIntradayFilledOrdersVerify;
+    private _maxConsLossDaysVerify;
+    private _maxDrawdownVerify;
+    private _riskTouchOff;
+    strategy(args: IKeyObjectValue, posStr: string): void;
+    private _updateArgToOptions;
+    order(args: IOrderArgs, posStr: string): void;
+    entry(args: IOrderArgs, posStr: string): void;
+    close(args: IOrder, posStr: string): void;
+    close_all(args: IOrder, posStr: string): void;
+    cancel(args: IOrderArgs, posStr: string): void;
+    cancel_all(args: IOrderArgs, posStr: string): void;
+    exit(args: IOrderArgs, posStr: string): void;
+    private _calcDefaultQty;
+    private _calcExitQty;
+    private _getCommQty;
+    private _getLen;
+    private _getCapital;
+    private _calcProfitAndLoss;
+    private _calcProfitAndLossHandle;
+    private _calcOrderPercent;
+    private _calcLiquidate;
+    private _marginCallOrders;
+    private _orderHandle;
+    private _orderOnCloseHandle;
+    private _judgeCapitalEnough;
+    private _getOrderProfit;
+    private _ocaGroupVerify;
+    private _processOrders;
+    private _addPendingOrders;
+    private _orderArgsParse;
+    private _entryHandle;
+    private _entryOnCloseHandle;
+    private _getOrders;
+    private _entryOrder;
+    private _getAvailablePositionSize;
+    private _getEntryOrders;
+    private _addPendingEntry;
+    private _closeAllOrders;
+    private _closeOrders;
+    private _closeOrder;
+    private _exitOrdersHandle;
+    private _executesSort;
+    private _getLimitPrice;
+    private _getStopPrice;
+    private _getTrailStopPrice;
+    private _ordersHandle;
+    private _calcTrailStopPrice;
+    private _pendingOrderHandle;
+    private _pendingOrderSort;
+    private _pendingCloseOrderHandle;
+    private _onCloseOrderHandle;
+    private _entryOrderHandle;
+    private _orderOrderHandle;
+    private _getCloseOrders;
+    private _closeOrderHandle;
+    private _processCloseOrders;
+    private _exitOrderHandle;
+    private _exit;
+    private _updateExitOrders;
+    private _ordersToExit;
+    private _addExitPendingCloseOrders;
+    private _stopProfit;
+    private _stopLoss;
+    private _trailStopLoss;
+    private _processExitOnClose;
+    private _processExitOrders;
+    private _processOrder;
+    private _calcPercent;
+    private _getCommission;
+    private _calcCurrentOrder;
+    private _calcOrderFillsHandle;
+    private _isNaN;
+    private _paramVerfiy;
+    _verfiyRequestFunc(posStr: string, name: string): void;
+}
+export {};

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

@@ -0,0 +1,102 @@
+import { IKeyObjectValue } from "../../../type";
+import { BuiltInVariables } from "../buildInVariables";
+import BuildInTimeframe from "./timeframe";
+import BuildInMath from "./math";
+interface ITaArgs {
+    series?: number;
+    length?: number;
+    offset?: number;
+    sigma?: number;
+    floor?: boolean;
+    source?: number;
+    condition?: boolean;
+    biased?: boolean;
+    mult?: number;
+    source_a?: number;
+    source_b?: number;
+    diLength?: number;
+    adxSmoothing?: number;
+    useTrueRange?: boolean;
+    fastlen?: number;
+    slowlen?: number;
+    siglen?: number;
+    percentage?: number;
+    type?: string;
+    anchor?: boolean;
+    developing?: boolean;
+    leftbars?: number;
+    rightbars?: number;
+    start?: number;
+    inc?: number;
+    max?: number;
+    high?: number;
+    low?: number;
+    factor?: number;
+    atrPeriod?: number;
+    handle_na?: boolean;
+    short_length?: number;
+    long_length?: number;
+    occurrence?: number;
+    stdev_mult?: number;
+    isSeriesLen?: boolean;
+    x?: number;
+    y?: number;
+}
+export default class BuildInTa extends BuildInMath {
+    private _taCacheDataLoc;
+    protected _variables: BuiltInVariables;
+    protected _timeframe: BuildInTimeframe;
+    constructor(variables: BuiltInVariables);
+    get _taCacheData(): IKeyObjectValue;
+    set _taCacheData(data: IKeyObjectValue);
+    alma({ series, length, offset, sigma, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    sma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    rma({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    atr({ length, isSeriesLen }: ITaArgs, posStr: string): any;
+    barssince({ condition }: ITaArgs, posStr: string): any;
+    stdev({ source, length, biased, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    private _sum;
+    cci({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    change({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    cog({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    correlation({ source_a, source_b, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    cross({ x, y }: ITaArgs, posStr: string): any;
+    crossover({ x, y }: ITaArgs, posStr: string): any;
+    crossunder({ x, y }: ITaArgs, posStr: string): any;
+    cum({ x }: ITaArgs, posStr: string): any;
+    dev({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    ema({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    falling({ source, length }: ITaArgs, posStr: string): any;
+    rising({ source, length }: ITaArgs, posStr: string): any;
+    highest(args: ITaArgs, posStr: string): number | undefined;
+    highestbars(args: ITaArgs, posStr: string): number | undefined;
+    wma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    linreg({ source, length, offset, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    lowest(args: ITaArgs, posStr: string): number | undefined;
+    lowestbars(args: ITaArgs, posStr: string): number | undefined;
+    macd({ source, fastlen, slowlen, siglen }: ITaArgs, posStr: string): any[];
+    mom({ source, length, isSeriesLen }: ITaArgs, posStr: string): any;
+    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;
+    pivothigh(args: ITaArgs, posStr: string): any;
+    pivotlow(args: ITaArgs, posStr: string): any;
+    roc({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    rsi({ x: source, y: length, isSeriesLen }: ITaArgs, posStr: string): any;
+    sar({ start, inc, max }: ITaArgs, posStr: string): any;
+    stoch({ source, high, low, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    swma({ x }: ITaArgs, posStr: string): any;
+    tr({ handle_na }: ITaArgs, posStr: string): any;
+    tsi({ source, short_length, long_length }: ITaArgs, posStr: string): number | undefined;
+    private _doubleSmooth;
+    valuewhen({ condition, source, occurrence }: ITaArgs, posStr: string): any;
+    variance({ source, length, biased, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    vwap({ x }: ITaArgs, posStr: string): any;
+    vwma({ source, length, isSeriesLen }: ITaArgs, posStr: string): number | undefined;
+    private _sort;
+    private _cacheDataList;
+    private _getCacheData;
+    private _cacheDataHandle;
+    private _verifyCacheData;
+}
+export {};

package/lib/components/editor/{parseScript → v3/parseScript}/buildInFuncNamespace/timeframe.d.ts

@@ -1,4 +1,4 @@
-import { IKeyObjectValue } from "../../type";
+import { IKeyObjectValue } from "../../../type";
 import { BuiltInVariables } from "../buildInVariables";
 interface ITimeArgs {
     timeframe?: string;

package/lib/components/editor/v3/parseScript/buildInVarNamespace/barstate.d.ts

@@ -0,0 +1,19 @@
+import { IKeyObjectValue } from "../../../type";
+export declare class Barstate {
+    private _currentBarIndex;
+    private _totalBarIndex;
+    private _isRealTimeBar;
+    private _preBarIndex;
+    private _isFirstRun;
+    constructor();
+    update(currentBarIndex: number, totalBarIndex: number, isRealTimeBar: boolean): void;
+    get _barstateCacheData(): IKeyObjectValue;
+    set _barstateCacheData(val: IKeyObjectValue);
+    set isFirstRun(status: boolean);
+    get isnew(): boolean;
+    get islast(): boolean;
+    get isfirst(): boolean;
+    get ishistory(): boolean;
+    get isrealtime(): boolean;
+    get isconfirmed(): boolean;
+}

package/lib/components/editor/v3/parseScript/buildInVarNamespace/index.d.ts

@@ -0,0 +1,4 @@
+export { Barstate } from './barstate';
+export { Strategy } from './strategy';
+export { Ta } from './ta';
+export { Syminfo } from './syminfo';

package/lib/components/editor/v3/parseScript/buildInVarNamespace/strategy.d.ts

@@ -0,0 +1,126 @@
+import { IKeyObjectValue } from "../../../type";
+import { IOrder, IStrategy } from "../runType";
+import { BuiltInVariables } from "../buildInVariables";
+export declare class Strategy {
+    private _orders;
+    private _historyOrders;
+    private _options?;
+    private _max_contracts_held_all;
+    private _max_contracts_held_long;
+    private _max_contracts_held_short;
+    private _max_drawdown;
+    private _max_runup;
+    private _max_runup_percent;
+    private _max_drawdown_percent;
+    private _variables;
+    private _netprofit;
+    private _eventrades;
+    private _avg_trade_percent?;
+    private _avg_losing_trade_percent?;
+    private _avg_winning_trade_percent?;
+    private _closedtrades;
+    private _losstrades;
+    private _grossloss;
+    private _grossprofit;
+    private _wintrades;
+    private _position_avg_price?;
+    private _position_size;
+    private _openprofit;
+    private _preMaxNetValue;
+    private _preMinNetValue;
+    marginCallLong: number;
+    marginCallShort: number;
+    opentrades_long: number;
+    opentrades_short: number;
+    position_size_long: number;
+    position_size_short: number;
+    position_size_total: number;
+    openprofit_long: number;
+    openprofit_short: number;
+    constructor(variables: BuiltInVariables);
+    update(data: IKeyObjectValue): void;
+    private _calcMaxDrawdownAndMaxRunup;
+    updateOrders(orders: IOrder[]): void;
+    private _calcMaxContracts;
+    updateHistoryOrders(orders: IOrder[]): void;
+    updateStrategyOptions(options: IStrategy): void;
+    get account_currency(): string;
+    get closedtrades(): number;
+    get opentrades(): number;
+    get price_first_long(): number;
+    get price_last_long(): number;
+    get avg_price_long(): number;
+    get price_highest_long(): number | undefined;
+    get price_lowest_long(): number | undefined;
+    get price_first_short(): number;
+    get price_last_short(): number;
+    get avg_price_short(): number;
+    get price_highest_short(): number | undefined;
+    get price_lowest_short(): number | undefined;
+    get avg_losing_trade(): number | undefined;
+    get avg_losing_trade_percent(): number | undefined;
+    get avg_trade(): number | undefined;
+    get equity(): number;
+    get netprofit(): number;
+    get eventrades(): number;
+    get openprofit(): number;
+    get avg_trade_percent(): number | undefined;
+    get avg_winning_trade(): number | undefined;
+    get avg_winning_trade_percent(): number | undefined;
+    get initial_capital(): number;
+    get losstrades(): number;
+    get grossloss(): number;
+    get grossloss_percent(): number;
+    get grossprofit(): number;
+    get grossprofit_percent(): number;
+    get wintrades(): number;
+    get margin_liquidation_price(): number | undefined;
+    get max_contracts_held_all(): number;
+    get max_contracts_held_long(): number;
+    get max_contracts_held_short(): number;
+    get max_drawdown(): number;
+    get max_runup(): number;
+    get max_runup_percent(): number;
+    get max_drawdown_percent(): number;
+    get netprofit_percent(): number;
+    get openprofit_percent(): number;
+    get position_avg_price(): number | undefined;
+    get position_entry_name(): string | undefined;
+    get position_size(): number;
+    get summaryData(): {
+        position_size: number;
+        position_avg_price: number | undefined;
+        position_entry_name: string | undefined;
+        openprofit_percent: number;
+        netprofit_percent: number;
+        max_drawdown_percent: number;
+        max_runup_percent: number;
+        max_drawdown: number;
+        max_runup: number;
+        max_contracts_held_long: number;
+        max_contracts_held_short: number;
+        max_contracts_held_all: number;
+        avg_winning_trade_percent: number | undefined;
+        avg_winning_trade: number | undefined;
+        avg_trade_percent: number | undefined;
+        avg_trade: number | undefined;
+        avg_losing_trade: number | undefined;
+        avg_losing_trade_percent: number | undefined;
+        wintrades: number;
+        losstrades: number;
+        eventrades: number;
+        grossprofit: number;
+        grossprofit_percent: number;
+        grossloss: number;
+        grossloss_percent: number;
+        openprofit: number;
+        initial_capital: number;
+        netprofit: number;
+        closedtrades: number;
+        opentrades: number;
+        equity: number;
+        margin_call_long: number;
+        margin_call_short: number;
+    };
+    private _getOrderPrices;
+}

package/lib/components/editor/v3/parseScript/buildInVarNamespace/syminfo.d.ts

@@ -0,0 +1,22 @@
+import { IKeyObjectValue } from "../../../type";
+export declare class Syminfo {
+    private _syminfo;
+    update(syminfo: IKeyObjectValue): void;
+    get __syminfo(): IKeyObjectValue;
+    get root(): any;
+    get prefix(): any;
+    get mintick(): any;
+    get pointvalue(): any;
+    get basecurrency(): any;
+    get country(): any;
+    get currency(): any;
+    get description(): any;
+    get employees(): any;
+    get expiration_date(): any;
+    get industry(): any;
+    get minmove(): any;
+    get session(): any;
+    get timezone(): any;
+    get ticker(): any;
+    get tickerid(): any;
+}

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

@@ -0,0 +1,17 @@
+import { IKeyObjectValue } from "../../../type";
+export declare class Ta {
+    private _preAccdist;
+    private _preVwap;
+    private _preValue;
+    private _currentData;
+    private _preData;
+    private _id;
+    constructor(id: string);
+    get _varTaCacheData(): IKeyObjectValue;
+    set _varTaCacheData(data: IKeyObjectValue);
+    update(currentData: IKeyObjectValue): void;
+    get isRealTime(): boolean;
+    get accdist(): any;
+    get tr(): any;
+    get vwap(): any;
+}