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

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

@@ -8,6 +8,7 @@ interface IProps {
     modified?: string;
     original?: string;
     renderSideBySide?: boolean;
+    version?: number;
 }
 declare const TradingDiffEditor: FC<IProps>;
 export default TradingDiffEditor;

package/lib/components/editor/config/monarchTokens.d.ts

@@ -1,7 +1,5 @@
-import { languages, editor } from 'monaco-editor';
-export declare const LANGAGE_NAME = "tccScript";
-export declare const LANGUAGE_MONARCH_TOKENS: languages.IMonarchLanguage;
-export declare const CONFIGURATION: languages.LanguageConfiguration;
+import { editor } from 'monaco-editor';
+export declare const LANGAGE_NAME = "mineScript";
 export declare const COLORS: {
     "color-white": string;
     "color-black": string;

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

@@ -0,0 +1,38 @@
+import { IKeyValueStr } from "../type";
+export declare const NOT_SHOW_KEYWORDS: string[];
+export declare const COMPLETE_KEYS: string[];
+export declare const HOVER_KEYS: string[];
+export declare const BUILD_IN_VALUE: IKeyValueStr;
+export declare const ALL_KINDS: {
+    argument: string;
+    keyword: string;
+    field: string;
+    userFunction: string;
+    builtInFunction: string;
+    library: string;
+    userVariable: string;
+    builtInVariable: string;
+    namespace: string;
+    operator: string;
+    constant: string;
+    annotation: string;
+    userMethod: string;
+    builtinMethod: string;
+    userType: string;
+    builtinType: string;
+};
+export declare const DEFAULT_DETIALS: IKeyValueStr;
+export declare const READY_ONLY_OPTIONS: {
+    domReadOnly: boolean;
+    scrollBeyondLastLine: boolean;
+    readOnly: boolean;
+    minimap: {
+        enabled: boolean;
+    };
+    scrollbar: {
+        vertical: string;
+        horizontal: string;
+        alwaysConsumeMouseWheel: boolean;
+    };
+    contextmenu: boolean;
+};

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

@@ -2,3 +2,4 @@ export declare const LAST_EDITED_SCRIPT = "tcc_last_edited_script";
 export declare const ORIGINAL_SCRIPT = "tcc_original_script";
 export declare const CURSOR_POSITION = "tcc_cursor_position";
 export declare const REMOVE_ACTIONS: string[];
+export declare const DEFAULT_VERSION = 3;

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

@@ -19,6 +19,7 @@ interface IProps {
     onDeclareConfigChange?: (value: IKeyObjectValue) => void;
     onActionTrigger?: (actionId: string) => void;
     onLinkOpen?: (source: string, index?: number) => void;
+    onVersionChange?: (version: number) => void;
 }
 export interface IRefs {
     setOriginalScript: (val: string) => void;

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

@@ -1,21 +1,6 @@
 import { IDocValue, IKeyObjectValue } from '../type';
-import { Token } from './config';
-import { IKeys } from '../constants/contents';
 export declare function mergeToRegExpStr(keys: string[]): string;
-interface ITokenRules {
-    [key: string]: ITokenRule[];
-}
-interface ITokenRule {
-    token?: Token | string | Token[];
-    regex?: string | RegExp;
-    next?: string;
-    merge?: boolean;
-    id?: string;
-    defaultToken?: string | Token;
-    [key: string]: unknown;
-}
 export declare function removeArrow(str: string): string;
-export declare function getTokenRules(fields: IKeys): ITokenRules;
 export declare class FormatMarkdown {
     delimiter: string;
     lineBreak: string;
@@ -31,4 +16,3 @@ export declare class FormatMarkdown {
 export declare const formatMarkdown: FormatMarkdown;
 export declare function markdownHoverImportBuilder(item: IKeyObjectValue): string;
 export declare function markdownHoverBuilder(items: IDocValue[], currentIndex?: number, isSupport?: boolean): string;
-export {};

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

@@ -1,15 +1,42 @@
-import { IRange, languages, IMarkdownString, IPosition } from 'monaco-editor';
+import { IRange, languages, IMarkdownString } from 'monaco-editor';
+interface IBase {
+    startColumn: number;
+    startLineNumber: number;
+    endColumn: number;
+    endLineNumber: number;
+}
+export declare enum VMarkerSeverity {
+    Hint = 1,
+    Info = 2,
+    Warning = 4,
+    Error = 8
+}
+export interface IPosition {
+    readonly lineNumber: number;
+    readonly column: number;
+    reName?: string;
+}
 export interface IBaseItem {
     label: string;
     insertText?: string;
     returnType?: string | string[];
     constents?: IMarkdownString;
 }
+export interface IKeys {
+    [key: string]: string[];
+}
+export interface IKeyMaps {
+    [key: string]: Map<string, IDocValue[]>;
+}
 export interface ISuggestion extends Omit<languages.CompletionItem, 'range' | 'label'> {
     label: string;
     originInsertText?: string;
     range?: IRange | languages.CompletionItemRanges;
 }
+export interface IError extends IBase {
+    message: string;
+    type?: VMarkerSeverity;
+}
 export interface IModules {
     [key: string]: ISuggestion;
 }
@@ -60,6 +87,8 @@ export interface IDocValue {
     isEnumMember?: boolean;
     value?: string;
     selfArg?: IArg;
+    disallowedInTemplate?: boolean;
+    expectsTemplate?: boolean;
 }
 export interface IDetailedDesc {
     desc: string[];
@@ -82,6 +111,7 @@ export interface IArg {
     required?: boolean;
     allowedTypeIDs?: string[];
     displayType?: string;
+    kind?: string;
 }
 export interface IImportLibrary {
     codeStr: string;
@@ -90,3 +120,4 @@ export interface IImportLibrary {
     types: IDocValue[];
     methods: IDocValue[];
 }
+export {};

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

@@ -18,6 +18,8 @@ export declare class MyCompletion {
     private _userTypes;
     private _userEnums;
     private _nextIsBracket;
+    private _keyMaps;
+    private _snippets;
     constructor();
     get methodFuncs(): Map<string, IDocValue[]>;
     get userFuncs(): Map<string, IDocValue[]>;
@@ -25,7 +27,7 @@ export declare class MyCompletion {
     set nextIsBracket(value: boolean);
     get nextIsBracket(): boolean;
     get annotationSuggestions(): ISuggestion[];
-    initBuiltinsTrees(): void;
+    initBuiltinsTrees(version: number): Promise<void>;
     getArgSuggestions(key: string): ISuggestion[] | undefined;
     getSuggestions(key?: string): ISuggestion[] | undefined;
     private _initUserDefind;

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

@@ -1,5 +1,5 @@
 import { editor, languages } from "monaco-editor";
-import { IImportLibrary, IKeyObjectValue } from "../type";
+import { IKeyObjectValue } from "../type";
 declare class ImportLibrary {
     private _inlayHints;
     private _editor?;
@@ -8,165 +8,7 @@ declare class ImportLibrary {
     constructor();
     get inlayHints(): languages.InlayHint[];
     setEditor(editor: editor.IStandaloneCodeEditor): void;
-    setInlayHints(params: IKeyObjectValue): Promise<IImportLibrary | {
-        functions: ({
-            name: string;
-            desc: string[];
-            args: ({
-                name: string;
-                desc: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-            } | {
-                name: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-                desc?: undefined;
-            })[];
-            syntax: string[];
-            hasMemberIndex: boolean;
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            isUser: boolean;
-            returnedTypes: string[];
-            returns: string[];
-            index?: undefined;
-            info?: undefined;
-        } | {
-            name: string;
-            args: {
-                name: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-            }[];
-            syntax: string[];
-            hasMemberIndex: boolean;
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            isUser: boolean;
-            returnedTypes: string[];
-            index: number;
-            desc?: undefined;
-            returns?: undefined;
-            info?: undefined;
-        } | {
-            name: string;
-            args: {
-                name: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-            }[];
-            returnedTypes: string[];
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            syntax: string[];
-            desc?: undefined;
-            hasMemberIndex?: undefined;
-            isUser?: undefined;
-            returns?: undefined;
-            index?: undefined;
-            info?: undefined;
-        } | {
-            name: string;
-            args: {
-                name: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-            }[];
-            returnedTypes: string[];
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            info: string;
-            syntax: string[];
-            desc?: undefined;
-            hasMemberIndex?: undefined;
-            isUser?: undefined;
-            returns?: undefined;
-            index?: undefined;
-        })[];
-        methods: ({
-            name: string;
-            args: {
-                name: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-            }[];
-            desc: string[];
-            originalName: string;
-            syntax: string[];
-            returnedTypes: string[];
-            hasMemberIndex: boolean;
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            thisType: string[];
-            returns: string[];
-            index?: undefined;
-        } | {
-            name: string;
-            args: {
-                name: string;
-                required: boolean;
-                allowedTypeIDs: string[];
-                displayType: string;
-            }[];
-            originalName: string;
-            syntax: string[];
-            returnedTypes: string[];
-            hasMemberIndex: boolean;
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            thisType: string[];
-            index: number;
-            desc?: undefined;
-            returns?: undefined;
-        } | {
-            name: string;
-            args: never[];
-            returnedTypes: string[];
-            thisType: string[];
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-            syntax: string[];
-            desc?: undefined;
-            originalName?: undefined;
-            hasMemberIndex?: undefined;
-            returns?: undefined;
-            index?: undefined;
-        })[];
-        types: {
-            fields: {
-                name: string;
-                type: string;
-            }[];
-            name: string;
-            pos: {
-                lineNumber: number;
-                column: number;
-            };
-        }[];
-        description: string;
-        codeStr: string;
-    } | undefined>;
+    setInlayHints(params: IKeyObjectValue): Promise<{} | undefined>;
     deleteInlayHints(name: string): void;
     clearInlayHints(): void;
     triggerInlayHints(): void;

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

@@ -9,6 +9,7 @@ export default class InitEditor {
     private _onActionTrigger?;
     private _onLinkOpen?;
     private _registerList;
+    private _version;
     constructor(editor: editor.IStandaloneCodeEditor, monaco: Monaco, onActionTrigger?: (actionId: string) => void);
     addLinkOpenFunc(onLinkOpen: (source: string, index?: number) => void): void;
     updateActionTrigger(onActionTrigger?: (actionId: string) => void): void;
@@ -24,6 +25,8 @@ export default class InitEditor {
         lineCount: number | undefined;
     };
     setEditorLayout(height: number, width?: number): void;
+    getVersion(): number;
+    private updateOptions;
     private _init;
     private _onTabSizeChange;
     private _setCursorPosition;

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

@@ -16,8 +16,10 @@ export declare class Parse {
     private _userEnums;
     private _imports;
     private _overloadsFuncs;
+    private _keyMaps;
     constructor();
     get overloadsFuncs(): IKeyValue[];
+    onVersionChange(version: number): Promise<void>;
     setUserDefined(maps: IUserDefined, overloadsFuncs: IKeyValue[]): void;
     parseLineContentFuncVar(column: number, line: number, model: editor.ITextModel | null, position?: Position): IKeyObjectValue | null | undefined;
     private _getImportDocVal;

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

@@ -1,7 +1,5 @@
-/// <reference path="../../../../src/vite-env.d.ts" />
-import { ErrorListener } from "antlr4";
 import { IKeyObjectValue } from "../type";
-export declare function parseTcc(program: string, hasTranscoding: boolean, getImportLibraryFunc: (obj: IKeyObjectValue) => IKeyObjectValue, keyObjs: IKeyObjectValue): Promise<{
+export declare function parseTcc(program: string, hasTranscoding: boolean, getImportLibraryFunc: (obj: IKeyObjectValue) => IKeyObjectValue, keyObjs: IKeyObjectValue, version: number): Promise<{
     errors: any[];
     functions: {
         [k: string]: import("../type").IDocValue[];
@@ -34,10 +32,6 @@ export declare function parseLibraryCode(program: string, libTitle: string, getI
     types: import("../type").IDocValue[];
     enums: import("../type").IDocValue[];
 }>;
-export declare class ExprErrorListener extends ErrorListener {
-    errors: any[];
-    syntaxError(_: any, __: any, line: number, column: number, msg: string): void;
-}
 export interface IParseWorker {
     parseTcc: typeof parseTcc;
     parseLibraryCode: typeof parseLibraryCode;

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

@@ -6,7 +6,7 @@ interface IRunResult {
     cacheData?: any;
     options?: any;
 }
-export declare function runScript(strJs: string, options: IKeyObjectValue, isNew: boolean): Promise<IRunResult>;
+export declare function runScript(strJs: string, options: IKeyObjectValue, isNew: boolean, version: number): Promise<IRunResult>;
 export declare function removeScript(id: string): void;
 export interface IScriptWorker {
     runScript: typeof runScript;

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

@@ -1,7 +1,9 @@
 export declare class SignatureHelp {
     private _formatter;
     private _isMac;
+    private _keyMaps;
     constructor(userAgent: string);
+    onVersionChange(version: number): Promise<void>;
     getSignatureHelpValues(funcName: string, args?: string[], startIndex?: number, line?: number): {
         activeParameter: number;
         activeSignature: number;

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

@@ -1,3 +1,9 @@
 import { editor } from "monaco-editor";
+import { IKeyValue } from "../type";
 export declare function getTypeOriginName(type: string): string;
 export declare function removeContextMenu(editor: editor.IStandaloneCodeEditor): void;
+export declare function replaceTemplate(template: string, replacements: IKeyValue): string;
+export declare function encode(str: string): string;
+export declare function decode(base64: string): string;
+export declare function getContents(version?: number): Promise<typeof import("../v3/constants") | undefined>;
+export declare function getMonarchTokens(version?: number): Promise<typeof import("../v3/config/monarchTokens") | undefined>;

package/lib/components/editor/v3/config/monarchTokens.d.ts

@@ -0,0 +1,3 @@
+import { languages } from 'monaco-editor';
+export declare const LANGUAGE_MONARCH_TOKENS: languages.IMonarchLanguage;
+export declare const CONFIGURATION: languages.LanguageConfiguration;

package/lib/components/editor/v3/constants/contents_zh.d.ts

@@ -0,0 +1,6 @@
+import { IDocValue } from "../../type";
+interface IContents {
+    [key: string]: IDocValue[];
+}
+export declare const CONTENTS: IContents;
+export {};

package/lib/components/editor/{constants/contents.d.ts → v3/constants/index.d.ts}

@@ -1,14 +1,10 @@
-import { IDocValue, IKeyValueStr } from '../type';
-interface IContents {
-    [key: string]: IDocValue[];
-}
+import { IDocValue, IKeyValueStr } from '../../type';
 interface IKeyMaps {
     [key: string]: Map<string, IDocValue[]>;
 }
 export interface IKeys {
     [key: string]: string[];
 }
-export declare const ALL_CONTENT: IContents;
 export declare const SNIPPET_COMPLETIONS: {
     label: string;
     insertText: string;

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

@@ -0,0 +1,179 @@
+import { VPlotDisplay, VHlineStyle, VLocation, VPlotStyle, VAdjustment, VBarmergeGaps, VScale, VSession, VShape, VSize, VStrategy, VCommission, VDirection, VOca, VInputType } 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 {
+    bool: VInputType;
+    integer: VInputType;
+    float: VInputType;
+    string: VInputType;
+    symbol: VInputType;
+    resolution: VInputType;
+    source: VInputType;
+    session: {
+        session: VInputType;
+        extended: VSession;
+        regular: VSession;
+    };
+    adjustment: {
+        dividends: VAdjustment;
+        none: VAdjustment;
+        splits: VAdjustment;
+    };
+    solid: VHlineStyle;
+    dotted: VHlineStyle;
+    dashed: VHlineStyle;
+    size: {
+        auto: VSize;
+        huge: VSize;
+        large: VSize;
+        normal: VSize;
+        small: VSize;
+        tiny: VSize;
+    };
+    line: VPlotStyle;
+    linebr: VPlotStyle;
+    stepline: VPlotStyle;
+    histogram: VPlotStyle;
+    cross: VPlotStyle;
+    area: VPlotStyle;
+    areabr: VPlotStyle;
+    columns: VPlotStyle;
+    circles: VPlotStyle;
+    sunday: number;
+    monday: number;
+    tuesday: number;
+    wednesday: number;
+    thursday: number;
+    friday: number;
+    saturday: number;
+    shape: {
+        arrowdown: VShape;
+        arrowup: VShape;
+        circle: VShape;
+        cross: VShape;
+        diamond: VShape;
+        flag: VShape;
+        labeldown: VShape;
+        labelup: VShape;
+        square: VShape;
+        triangledown: VShape;
+        triangleup: VShape;
+        xcross: VShape;
+    };
+    location: {
+        abovebar: VLocation;
+        absolute: VLocation;
+        belowbar: VLocation;
+        bottom: VLocation;
+        top: VLocation;
+    };
+    scale: {
+        left: VScale;
+        none: VScale;
+        right: VScale;
+    };
+    strategy: {
+        cash: VStrategy;
+        fixed: VStrategy;
+        percent_of_equity: VStrategy;
+        long: boolean;
+        short: boolean;
+        commission: {
+            cash_per_contract: VCommission;
+            cash_per_order: VCommission;
+            percent: VCommission;
+        };
+        direction: {
+            all: VDirection;
+            long: VDirection;
+            short: VDirection;
+        };
+        oca: {
+            cancel: VOca;
+            none: VOca;
+            reduce: VOca;
+        };
+    };
+    currency: {
+        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;
+    };
+    barmerge: {
+        gaps_off: VBarmergeGaps;
+        gaps_on: VBarmergeGaps;
+        lookahead_off: VBarmergeGaps;
+        lookahead_on: VBarmergeGaps;
+    };
+    true: boolean;
+    false: boolean;
+    constructor();
+}

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

@@ -0,0 +1,9 @@
+import BuildInMath from "./math";
+import BuildInTa from "./ta";
+import BuildInInput from "./input";
+import BuildInTimeframe from "./timeframe";
+import Strategy, { IOrder, IStrategy } from './strategy';
+import Request from './request';
+export { TccErrorListener } from './errorListener';
+export { BuildInMath, BuildInTa, BuildInInput, BuildInTimeframe, Strategy, Request };
+export type { IOrder, IStrategy };