@guihz/trading-vue-editor-tes 0.0.63 → 0.0.64

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

@@ -53,6 +53,9 @@ export declare const ERRORS_TIPS: {
     strategyRunErr: string;
     exportUseErr: string;
     funcRepeatErr: string;
+    importMultipleErr: string;
+    importNotExitErr: string;
+    importNameRepeatErr: string;
 };
 export declare const WARNING_TIPS: {
     repeatVar: string;
@@ -86,3 +89,162 @@ export declare const READY_ONLY_OPTIONS: {
     contextmenu: boolean;
 };
 export declare const COMMENTS_DESC_REG: RegExp;
+export declare const DEFAULT_EXPORT_TEST: {
+    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;
+};

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

@@ -28,7 +28,11 @@ export default class ParserVisitor extends ParserUtils {
     private _exportMethods;
     private _exportTypes;
     private _exportPositions;
-    constructor(props: IKeyObjectValue, comments: IKeyObjectValue[]);
+    private _description;
+    private _endExport;
+    private _importLibs;
+    private _getImportLibraryFunc;
+    constructor(props: IKeyObjectValue, comments: IKeyObjectValue[], getImportLibraryFunc: (obj: IKeyObjectValue) => IKeyObjectValue);
     get overloadsFuncs(): IKeyValue[];
     get errors(): IError[];
     get userTypes(): Map<string, IDocValue[]>;
@@ -43,11 +47,14 @@ export default class ParserVisitor extends ParserUtils {
         methods: IDocValue[];
         types: IDocValue[];
     };
+    get description(): string;
     get exportPositions(): (IRange & {
         type: string;
     })[];
-    visitProgram: (ctx: IKeyObjectValue) => any[];
-    visitGlobalStmt: (ctx: IKeyObjectValue) => any;
+    get endExport(): IKeyObjectValue;
+    get imports(): Map<string, IKeyObjectValue>;
+    visitProgram: (ctx: IKeyObjectValue) => Promise<any[]>;
+    visitGlobalStmt: (ctx: IKeyObjectValue) => Promise<any>;
     visitBlockStmt: (ctx: IKeyObjectValue) => IKeyObjectValue[];
     visitStmt: (ctx: IKeyObjectValue) => any;
     visitSimpleStmt: (ctx: IKeyObjectValue) => any;
@@ -189,8 +196,12 @@ export default class ParserVisitor extends ParserUtils {
     visitCaseClause: (ctx: IKeyObjectValue) => IKeyObjectValue;
     visitDefaultCaluse: (ctx: IKeyObjectValue) => IKeyObjectValue;
     visitWhileStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
-    visitImportStmt: (ctx: IKeyObjectValue) => IKeyObjectValue[];
-    visitImportElement: (ctx: IKeyObjectValue) => IKeyObjectValue | undefined;
+    visitImportStmt: (ctx: IKeyObjectValue) => Promise<IKeyObjectValue[]>;
+    visitImportElement: (ctx: IKeyObjectValue) => Promise<IKeyObjectValue | undefined>;
+    private _importHandle;
+    private _importDataHandle;
+    private _importTypeUpdate;
+    private _replaceTypeName;
     visitLiteral: (ctx: IKeyObjectValue) => {
         ruleType: VRuleType;
         ctx: IKeyObjectValue;

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

@@ -1,4 +1,4 @@
-import { IDocValue } from '../type';
+import { IDocValue, IKeyObjectValue } from '../type';
 import { Token } from './config';
 import { IKeys } from '../constants/contents';
 export declare function mergeToRegExpStr(keys: string[]): string;
@@ -29,5 +29,6 @@ export declare class FormatMarkdown {
     link(value: string, url: URL): string;
 }
 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

@@ -51,6 +51,7 @@ export interface IDocValue {
     valueType?: string;
     defaultValue?: any;
     index?: number;
+    isImport?: boolean;
 }
 export interface IDetailedDesc {
     desc: string[];
@@ -72,3 +73,10 @@ export interface IArg {
     allowedTypeIDs?: string[];
     displayType?: string;
 }
+export interface IImportLibrary {
+    codeStr: string;
+    description: string;
+    functions: IDocValue[];
+    types: IDocValue[];
+    methods: IDocValue[];
+}

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

@@ -17,7 +17,6 @@ export declare class MyCompletion {
     private _methodFuncs;
     private _userTypes;
     private _nextIsBracket;
-    private _annotationSuggestions;
     constructor();
     get methodFuncs(): Map<string, IDocValue[]>;
     get userFuncs(): Map<string, IDocValue[]>;

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

@@ -0,0 +1,179 @@
+import { editor, languages } from "monaco-editor";
+import { IImportLibrary, IKeyObjectValue } from "../type";
+declare class ImportLibrary {
+    private _inlayHints;
+    private _editor?;
+    private _importCompleteLibrary;
+    private _funcs;
+    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>;
+    deleteInlayHints(name: string): void;
+    clearInlayHints(): void;
+    triggerInlayHints(): void;
+    private _updateFuncNames;
+    private _setNoNameInlayHints;
+    private _inlayHintsHandle;
+    private _updateMonarchTokens;
+}
+declare const _default: ImportLibrary;
+export default _default;

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

@@ -5,16 +5,19 @@ interface IUserDefined {
     variables?: Map<string, IDocValue[]>;
     types?: Map<string, IDocValue[]>;
     methods?: Map<string, IDocValue[]>;
+    imports?: Map<string, IKeyObjectValue>;
 }
 export declare class Parse {
     private _userFunctions;
     private _userVariables;
     private _userTypes;
     private _userMethods;
+    private _imports;
     private _overloadsFuncs;
     constructor();
     setUserDefined(maps: IUserDefined, overloadsFuncs: IKeyValue[]): void;
     parseLineContentFuncVar(column: number, line: number, model: editor.ITextModel | null, position?: Position): IKeyObjectValue | null | undefined;
+    private _getImportDocVal;
     private _getBuildInFunc;
     private _getBuildInMethod;
     private _getBuildInOther;

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

@@ -14,9 +14,19 @@ export declare function parseTcc(val: string, hasTranscoding?: boolean): Promise
         [k: string]: import("../type").IDocValue[];
     };
     overloadsFuncs: import("../type").IKeyValue[];
+    imports: {
+        [k: string]: IKeyObjectValue;
+    };
     codeStr: string;
     preParserCode: string | undefined;
 }>;
+export declare function parseLibrary(val: string, title: string): Promise<{
+    description: string;
+    codeStr: string;
+    functions: import("../type").IDocValue[];
+    methods: import("../type").IDocValue[];
+    types: import("../type").IDocValue[];
+}>;
 export declare function scriptsRun(strJs: string, data: IKeyObjectValue, isNew?: boolean): Promise<{
     status: number;
     errors: any;

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

@@ -1,7 +1,7 @@
 /// <reference path="../../../../src/vite-env.d.ts" />
 import { ErrorListener } from "antlr4";
 import { IKeyObjectValue } from "../type";
-export default function parseTcc(program: string, hasTranscoding: boolean, keyObjs: IKeyObjectValue): Promise<{
+export declare function parseTcc(program: string, hasTranscoding: boolean, getImportLibraryFunc: (obj: IKeyObjectValue) => IKeyObjectValue, keyObjs: IKeyObjectValue): Promise<{
     errors: any[];
     functions: {
         [k: string]: import("../type").IDocValue[];
@@ -16,10 +16,24 @@ export default function parseTcc(program: string, hasTranscoding: boolean, keyOb
         [k: string]: import("../type").IDocValue[];
     };
     overloadsFuncs: import("../type").IKeyValue[];
+    imports: {
+        [k: string]: IKeyObjectValue;
+    };
     codeStr: string;
     preParserCode: string | undefined;
 }>;
+export declare function parseLibraryCode(program: string, libTitle: string, getImportLibraryFunc: (obj: IKeyObjectValue) => IKeyObjectValue, keyObjs: IKeyObjectValue): Promise<{
+    description: string;
+    codeStr: string;
+    functions: import("../type").IDocValue[];
+    methods: import("../type").IDocValue[];
+    types: 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/suggestions.d.ts

@@ -17,3 +17,7 @@ export declare function provideDefinition(model: editor.ITextModel, position: Po
         endColumn: number;
     };
 } | null;
+export declare function provideInlayHints(): {
+    hints: languages.InlayHint[];
+    dispose: () => void;
+};

package/lib/packages/index.d.ts

@@ -2,7 +2,7 @@ export { Actions } from '../components/editor/tokenizer/config';
 export { default as TradingVueEditor } from '../components/editor/index';
 export { default as TradingVueDiffEditor } from '../components/diffEditor/index';
 export type { IRefs as IEditorRefs } from '../components/editor/index';
-export { parseTcc, scriptsRun, removeScript } from '../components/editor/utils/parserTcc';
+export { parseTcc, scriptsRun, removeScript, parseLibrary } from '../components/editor/utils/parserTcc';
 export type { IError, IPosition } from '../components/editor/parseScript/type';
 export { VMarkerSeverity } from '../components/editor/parseScript/type';
 export { default as ReferenceManual } from '../components/referenceManual';