@guihz/trading-vue-editor-tes 0.0.1

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

@@ -0,0 +1,40 @@
+export declare enum Token {
+    Comment = "comment",
+    Text = "text",
+    String = "string",
+    Paren = "paren",
+    StringInvalid = "string.invalid",
+    ConstantNumericInteger = "constant.numeric.integer",
+    ConstantNumericFloat = "constant.numeric.float",
+    ConstantLanguage = "constant.language",
+    ConstantLanguageBoolean = "constant.other.boolean",
+    ConstantOtherColor = "constant.other.color",
+    SupportVariable = "support.variable",
+    SupportType = "support.type",
+    Keyword = "keyword",
+    KeywordEquals = "keyword.equals",
+    KeywordOperator = "keyword.operator",
+    CustomType = "entity.name.type",
+    VariableOther = "variable.other",
+    Property = "variable.other.property",
+    SupportFunction = "support.function",
+    SupportMethod = "support.method",
+    ImportedFunction = "meta.function-call",
+    Function = "entity.name.function",
+    ImportName = "entity.name.module",
+    ImportAlias = "entity.name.module.name",
+    ExtensionMethod = "entity.name.method",
+    Annotation = "comment.annotation",
+    PunctuationOperator = "punctuation.operator",
+    Empty = "empty",
+    Source = "source"
+}
+export declare enum DocTitle {
+    Type = "type",
+    Returns = "Returns",
+    Syntax = "Syntax",
+    Remarks = "Remarks",
+    Fields = "Fields",
+    Description = "Description",
+    Example = "Example"
+}

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

@@ -0,0 +1,33 @@
+import { IDocValue } 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;
+    paragraphBreak: string;
+    constructor();
+    bold(value: string): string;
+    italic(value: string): string;
+    pineCode(value: string): string;
+    code(value: string): string;
+    paragraph(...values: string[]): string;
+    link(value: string, url: URL): string;
+}
+export declare const formatMarkdown: FormatMarkdown;
+export declare function markdownHoverBuilder(items: IDocValue[], currentIndex?: number, isSupport?: boolean): string;
+export {};

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

@@ -0,0 +1,70 @@
+import { IRange, languages, IMarkdownString, IPosition } from 'monaco-editor';
+export interface IBaseItem {
+    label: string;
+    insertText?: string;
+    returnType?: string | string[];
+    constents?: IMarkdownString;
+}
+export interface ISuggestion extends Omit<languages.CompletionItem, 'range' | 'label'> {
+    label: string;
+    range?: IRange | languages.CompletionItemRanges;
+}
+export interface IModules {
+    [key: string]: ISuggestion;
+}
+export interface IKeyValue {
+    [key: string]: string | number;
+}
+export interface IKeyValueStr {
+    [key: string]: string;
+}
+export interface IKeyObjectValue {
+    [key: string]: any;
+}
+export interface IDocValue {
+    name: string;
+    title?: string;
+    desc?: string[];
+    kind?: string;
+    type?: string;
+    color?: string;
+    syntax?: string[];
+    detailedDesc?: IDetailedDesc[];
+    fields?: IField[];
+    returns?: string[];
+    remarks?: string | string[];
+    seeAlso?: string[];
+    args?: IArg[];
+    examples?: string[];
+    returnedTypes?: string[];
+    originalName?: string;
+    thisType?: string[];
+    template?: boolean;
+    info?: string;
+    range?: IRange;
+    isUser?: boolean;
+    pos?: IPosition;
+    scope?: number;
+    isForVar?: boolean;
+    hasMemberIndex?: boolean;
+    declare?: string;
+}
+export interface IDetailedDesc {
+    desc: string[];
+    examples?: string[];
+}
+export interface IField {
+    name: string;
+    desc?: string;
+    type?: string;
+    originName?: string;
+    isArg?: boolean;
+    isVarip?: boolean;
+}
+export interface IArg {
+    name: string;
+    desc?: string;
+    required?: boolean;
+    allowedTypeIDs?: string[];
+    displayType?: string;
+}

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

@@ -0,0 +1,33 @@
+import { editor, languages } from 'monaco-editor';
+export declare class Color {
+    private _colors;
+    constructor();
+    getDocumentColors(list: editor.FindMatch[]): languages.IColorInformation[];
+    private get _defultColorsRegStr();
+    get colorMatchesRegStr(): string;
+    getDocumentColorPresentations(model: editor.ITextModel, { color, range }: languages.IColorInformation): {
+        label: string;
+    }[] | {
+        label: string;
+        textEdit: {
+            text: string;
+            range: import("monaco-editor").IRange;
+        };
+    }[] | null;
+    private _hexFromNumber;
+    private _normalize;
+    private _denormalize;
+    private _normalizeAlpha;
+    private _denormalizeAlpha;
+    private _extractNewExpression;
+    private _colorHexRepresentation;
+    private _colorRgbRepresentation;
+    private _colorNewRepresentation;
+    private _hexToColor;
+    private _rgbToColor;
+    private _isHexToken;
+    private _isRgbColor;
+    private _isColorExpression;
+}
+declare const _default: Color;
+export default _default;

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

@@ -0,0 +1,61 @@
+import { IDocValue, ISuggestion } from '../type';
+export declare class MyCompletion {
+    private _bracketsPostfix;
+    private _builtinSubtreeCache;
+    private _formatter;
+    private _namespaceCache;
+    private _suggestions;
+    private _outermostNsItems;
+    private _funcArgsCache;
+    private _userSuggestions;
+    private _userFuncArgsCache;
+    private _userNamespaceCache;
+    private _userOutermostNsItems;
+    private _methodNamespaceCache;
+    private _userMethods;
+    private _userFunctions;
+    private _methodFuncs;
+    private _userTypes;
+    constructor();
+    get methodFuncs(): Map<string, IDocValue[]>;
+    get userFuncs(): Map<string, IDocValue[]>;
+    initBuiltinsTrees(): void;
+    getArgSuggestions(key: string): ISuggestion[] | undefined;
+    getSuggestions(key?: string): ISuggestion[] | undefined;
+    private _initUserDefind;
+    setUserDefind(functions: Map<string, IDocValue[]>, types: Map<string, IDocValue[]>, variables: Map<string, IDocValue[]>, methods: Map<string, IDocValue[]>): void;
+    private _getAllUserCompletionItems;
+    private _getAllCompletionItems;
+    private _getNodeKey;
+    private _mergeTreeSlices;
+    private _mergeCompletions;
+    private _mergeUserCompletions;
+    private _generateTreeSlice;
+    private _getBuiltinsCacheFragment;
+    private _getVariableCompletionItems;
+    private _setUserVariableSubItems;
+    private _getUserVariableCompletionItems;
+    private _getTypeCompletionItems;
+    private _getKeywordCompletionItems;
+    private _getMethodNamespaceCache;
+    private _getFunctionCompletionItems;
+    private _getSnippetsCompletionsList;
+    private _getFuncArgumentsCompletionItemsToCache;
+    private _getUserFuncArgumentsCompletionItemsToCache;
+    private _getNamedArgumentsCompletionList;
+    private _getVariableCompletionItem;
+    private _getKeywordCompletionItem;
+    private _getTypeCompletionItem;
+    private _getCustomTypeCompletionItem;
+    private _getInstanceTypeCompletionItemProp;
+    private _getFunctionCompletionItem;
+    private _getNamespaceCompletionItem;
+    private _extractExamples;
+    private _extractDescription;
+    private _createExampleSection;
+    private _createSyntaxSection;
+    private _createReturnSection;
+    private _createDescriptionSection;
+}
+declare const _default: MyCompletion;
+export default _default;

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

@@ -0,0 +1,23 @@
+import { Monaco } from "@monaco-editor/react";
+import { editor } from "monaco-editor";
+export declare class DiffDecorations {
+    private _editor;
+    private _monaco;
+    private _originalModel;
+    private _oldDecorations;
+    private _diffEditor?;
+    private _diffPopupWidget?;
+    private _didChangeListener?;
+    private _onMouseDownListener?;
+    constructor(editor: editor.IStandaloneCodeEditor, monaco: Monaco, theme?: string);
+    private _init;
+    update(val: string): void;
+    dispose(): void;
+    private _changesHandle;
+    private _changeHandle;
+    private _addDecorationList;
+    private _changeEvent;
+    private _eventListening;
+    private _onMouseDownHandle;
+    private _createDiffEditor;
+}

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

@@ -0,0 +1,23 @@
+import { Monaco } from "@monaco-editor/react";
+import { IPosition, editor } from "monaco-editor";
+export default class InitEditor {
+    private _editor;
+    private _monaco;
+    private _decorations?;
+    private _changPositionListener?;
+    constructor(editor: editor.IStandaloneCodeEditor, monaco: Monaco);
+    setModelMarkers(markers: editor.IMarkerData[]): void;
+    addDiffDecorations(): void;
+    removeDiffDecorations(): void;
+    setValue(val: string): void;
+    saveScripts(): void;
+    private _init;
+    private _setCursorPosition;
+    private _register;
+    private _setOptions;
+    private _addCommands;
+    private _addActions;
+    gotoLine(): void;
+    onChangeCursorPosition(_callback?: (postion: IPosition) => void): void;
+    private _addListening;
+}

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

@@ -0,0 +1,22 @@
+import { editor } from "monaco-editor";
+export type TChangeType = 'added' | 'removed' | 'modified';
+export declare enum ChangeType {
+    added = "added",
+    removed = "removed",
+    modified = "modified"
+}
+export declare class DiffPopupWidget {
+    private _domNode;
+    private _id;
+    private _top;
+    private _content?;
+    constructor(id: string, editor: editor.IStandaloneCodeEditor, hasMap?: boolean);
+    private _close;
+    private _retracement;
+    getId(): string;
+    getDomNode(): HTMLElement;
+    getPosition(): null;
+    show(top: number, originalTop: number, type: TChangeType): void;
+    hide(): void;
+    private scrollChangeHandler;
+}

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

@@ -0,0 +1,43 @@
+import { IDocValue, IKeyObjectValue, IKeyValue } from '../type';
+interface IUserDefined {
+    functions?: Map<string, IDocValue[]>;
+    variables?: Map<string, IDocValue[]>;
+    types?: Map<string, IDocValue[]>;
+    methods?: Map<string, IDocValue[]>;
+}
+export declare class Parse {
+    private _userFunctions;
+    private _userVariables;
+    private _userTypes;
+    private _userMethods;
+    private _overloadsFuncs;
+    constructor();
+    setUserDefined(maps: IUserDefined, overloadsFuncs: IKeyValue[]): void;
+    parseLineContentFuncVar(lineContent: string, column: number, line: number): IKeyObjectValue | null | undefined;
+    private _getBuildInFunc;
+    private _getBuildInMethod;
+    private _getBuildInOther;
+    parseCurrentInputFunc(content: string, isQString?: boolean, isQqString?: boolean): {
+        funcName: string;
+        startIndex: number;
+    } | undefined;
+    parseCurrentInputFuncAndArg(content: string, isQString?: boolean, isQqString?: boolean): {
+        funcName: string;
+        args: string[];
+    } | undefined;
+    private _removeString;
+    private _getVariablesDocVal;
+    private _getUserVariablesDocVal;
+    private _getUserTypesDocVal;
+    private _getTypesAndFileds;
+    private _getFuncsDocVal;
+    private _getOverloadsFuncIndex;
+    private _getUserFuncsDocVal;
+    private _getUserMethodsDocVal;
+    private _getUserVarFuncsDocVal;
+    private _arrayTypeTransform;
+    private _matchContent;
+    private _judgeVal;
+}
+declare const _default: Parse;
+export default _default;

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

@@ -0,0 +1,25 @@
+/// <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<{
+    errors: import("../parseScript/type").IError[];
+    functions: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    variables: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    types: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    methods: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    overloadsFuncs: import("../type").IKeyValue[];
+    codeStr: string;
+    preParserCode: string;
+}>;
+export declare class ExprErrorListener extends ErrorListener {
+    errors: any[];
+    syntaxError(_: any, __: any, line: number, column: number, msg: string): void;
+}

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

@@ -0,0 +1,29 @@
+export declare class SignatureHelp {
+    private _formatter;
+    private _isMac;
+    constructor(userAgent: string);
+    getSignatureHelpValues(funcName: string, args?: string[]): {
+        activeParameter: number;
+        activeSignature: number;
+        signatures: {
+            label: string;
+            documentation: {
+                value: string;
+            };
+            parameters: {
+                label: any[];
+                documentation: {
+                    value: string;
+                };
+            }[];
+        }[];
+    } | null;
+    private _getActiveIndex;
+    private _getFuncItems;
+    private _getSequentialSignatures;
+    private _getSignatureLabel;
+    private _getFormattedSignatureDocumentation;
+    private _getSignatureParams;
+}
+declare const _default: SignatureHelp;
+export default _default;

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

@@ -0,0 +1,18 @@
+import { Position, editor, languages, IRange, Uri } from 'monaco-editor';
+export declare function provideCompletionItems(model: editor.ITextModel, position: Position): languages.ProviderResult<languages.CompletionList>;
+export declare function provideHover(model: editor.ITextModel, position: Position): languages.ProviderResult<languages.Hover>;
+export declare function provideSignatureHelp(model: editor.ITextModel, position: Position): languages.ProviderResult<languages.SignatureHelpResult>;
+export declare function provideDocumentColors(model: editor.ITextModel): languages.IColorInformation[];
+export declare function provideColorPresentations(model: editor.ITextModel, colorInfo: languages.IColorInformation): {
+    label: string;
+}[];
+export declare function openCodeEditor(source: editor.ICodeEditor, _: Uri, selectionOrPosition: IRange): boolean;
+export declare function provideDefinition(model: editor.ITextModel, position: Position): {
+    uri: Uri;
+    range: {
+        startLineNumber: number;
+        endLineNumber: number;
+        startColumn: number;
+        endColumn: number;
+    };
+};

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

@@ -0,0 +1,22 @@
+/// <reference path="../../../../src/vite-env.d.ts" />
+import { ErrorListener } from 'antlr4';
+export default function parseTcc(program: string): {
+    errors: import("../parseScript/type").IError[];
+    functions: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    variables: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    types: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    methods: {
+        [k: string]: import("../type").IDocValue[];
+    };
+    overloadsFuncs: import("../type").IKeyValue[];
+};
+export declare class ExprErrorListener extends ErrorListener {
+    errors: any[];
+    syntaxError(_: any, __: any, line: number, column: number, msg: string): void;
+}

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

@@ -0,0 +1 @@
+export declare function getTypeOriginName(type: string): string;

package/lib/main.d.ts

@@ -0,0 +1 @@
+import './index.css';

package/lib/packages/index.d.ts

@@ -0,0 +1,5 @@
+export { default as TradingVueEditor } from '../components/editor/index';
+export type { IRefs as IEditorRefs } from '../components/editor/index';
+export { parseTcc, scriptsRun } from '../components/editor/utils/parserTcc';
+export type { IError, IPosition } from '../components/editor/parseScript/type';
+export { VMarkerSeverity } from '../components/editor/parseScript/type';

package/lib/tccParser/LexerBase.d.ts

@@ -0,0 +1,19 @@
+/// <reference path="../../src/vite-env.d.ts" />
+import { Lexer } from "antlr4";
+export default abstract class LexerBase extends Lexer {
+    tokens: any[];
+    indents: any[];
+    opened: number;
+    constructor(input: any);
+    reset(): void;
+    emitToken(token: any): void;
+    nextToken(): any;
+    createDedent(): any;
+    getCharIndex(): any;
+    commonToken(type: number, text: string): any;
+    getIndentationCount(whitespace: string): number;
+    atStartOfInput(): boolean;
+    openBrace(): void;
+    closeBrace(): void;
+    onNewLine(): void;
+}