@guihz/trading-vue-editor-tes 0.0.31 → 0.0.33

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

@@ -1,4 +1,5 @@
 import { VSortOrder } from "../enum";
+import { TccErrorListener } from ".";
 interface IArrayArgs {
     id?: PseudoArray;
     id1?: PseudoArray;
@@ -17,6 +18,8 @@ interface IArrayArgs {
     order?: VSortOrder;
 }
 export default class BuildInArray {
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
     new({ size, initial_value }?: IArrayArgs): PseudoArray;
     new_float({ size, initial_value }?: IArrayArgs): PseudoArray;
     new_int({ size, initial_value }?: IArrayArgs): PseudoArray;
@@ -32,50 +35,51 @@ export default class BuildInArray {
     slice({ id, index_from, index_to }: IArrayArgs): PseudoArray | undefined;
     size({ id }: IArrayArgs): number | undefined;
     first({ id }: IArrayArgs): any;
-    abs({ id }: IArrayArgs): PseudoArray | undefined;
-    avg({ id }: IArrayArgs): number | undefined;
-    binary_search({ id, val }: IArrayArgs): number | undefined;
-    binary_search_leftmost({ id, val }: IArrayArgs): number | undefined;
-    binary_search_rightmost({ id, val }: IArrayArgs): number | undefined;
+    abs({ id }: IArrayArgs, posStr: string): PseudoArray | undefined;
+    avg({ id }: IArrayArgs, posStr: string): number | undefined;
+    binary_search({ id, val }: IArrayArgs, posStr: string): number | undefined;
+    binary_search_leftmost({ id, val }: IArrayArgs, posStr: string): number | undefined;
+    binary_search_rightmost({ id, val }: IArrayArgs, posStr: string): number | undefined;
     clear({ id }: IArrayArgs): void;
     concat({ id1, id2 }: IArrayArgs): PseudoArray | undefined;
-    covariance({ id1, id2, biased }: IArrayArgs): number | undefined;
-    every({ id }: IArrayArgs): boolean | undefined;
+    covariance({ id1, id2, biased }: IArrayArgs, posStr: string): number | undefined;
+    every({ id }: IArrayArgs, posStr: string): boolean | undefined;
     from(_: any, arrVals: any[]): PseudoArray;
     fill({ id, value, index_from, index_to }: IArrayArgs): void;
     get({ id, index }: IArrayArgs): any;
     includes({ id, value }: IArrayArgs): boolean | undefined;
     indexof({ id, value }: IArrayArgs): number | undefined;
     insert({ id, index, value }: IArrayArgs): void;
-    join({ id, separator }: IArrayArgs): string | undefined;
+    join({ id, separator }: IArrayArgs, posStr: string): string | undefined;
     last({ id }: IArrayArgs): any;
     lastindexof({ id, value }: IArrayArgs): number | undefined;
-    max({ id, nth }: IArrayArgs): number | undefined;
-    median({ id }: IArrayArgs): number | undefined;
-    min({ id, nth }: IArrayArgs): number | undefined;
-    mode({ id }: IArrayArgs): number | undefined;
-    percentile_linear_interpolation({ id, percentage }: IArrayArgs): number | undefined;
-    percentile_nearest_rank({ id, percentage }: IArrayArgs): number | undefined;
-    percentrank({ id, index }: IArrayArgs): number | undefined;
+    max({ id, nth }: IArrayArgs, posStr: string): number | undefined;
+    median({ id }: IArrayArgs, posStr: string): number | undefined;
+    min({ id, nth }: IArrayArgs, posStr: string): number | undefined;
+    mode({ id }: IArrayArgs, posStr: string): number | undefined;
+    percentile_linear_interpolation({ id, percentage }: IArrayArgs, posStr: string): number | undefined;
+    percentile_nearest_rank({ id, percentage }: IArrayArgs, posStr: string): number | undefined;
+    percentrank({ id, index }: IArrayArgs, posStr: string): number | undefined;
     pop({ id }: IArrayArgs): any;
     push({ id, value }: IArrayArgs): void;
-    range({ id }: IArrayArgs): number | undefined;
+    range({ id }: IArrayArgs, posStr: string): number | undefined;
     remove({ id, index }: IArrayArgs): any;
     reverse({ id }: IArrayArgs): void | undefined;
     set({ id, index, value }: IArrayArgs): void;
     shift({ id }: IArrayArgs): any;
-    some({ id }: IArrayArgs): boolean | undefined;
-    sort({ id, order }: IArrayArgs): void;
-    sort_indices({ id, order }: IArrayArgs): PseudoArray | undefined;
-    standardize({ id }: IArrayArgs): PseudoArray | undefined;
-    stdev({ id, biased }: IArrayArgs): number | undefined;
-    sum({ id }: IArrayArgs): any;
+    some({ id }: IArrayArgs, posStr: string): boolean | undefined;
+    sort({ id, order }: IArrayArgs, posStr: string): void;
+    sort_indices({ id, order }: IArrayArgs, posStr: string): PseudoArray | undefined;
+    standardize({ id }: IArrayArgs, posStr: string): PseudoArray | undefined;
+    stdev({ id, biased }: IArrayArgs, posStr: string): number | undefined;
+    sum({ id }: IArrayArgs, posStr: string): any;
     unshift({ id, value }: IArrayArgs): void;
-    variance({ id, biased }: IArrayArgs): number | undefined;
+    variance({ id, biased }: IArrayArgs, posStr: string): number | undefined;
 }
 export declare class PseudoArray {
     private _arrInstance;
-    constructor(size?: number, initialValue?: any);
+    private _errorListener?;
+    constructor(size?: number, initialValue?: any, errorListener?: TccErrorListener);
     get isArray(): boolean;
     get _value(): any[];
     set _value(val: any[]);
@@ -85,45 +89,45 @@ export declare class PseudoArray {
     slice({ index_from, index_to }: IArrayArgs): PseudoArray;
     size(): number;
     first(): any;
-    abs(): PseudoArray;
-    avg(): number;
-    binary_search({ val }: IArrayArgs): number;
-    binary_search_leftmost({ val }: IArrayArgs): number;
-    binary_search_rightmost({ val }: IArrayArgs): number;
+    abs(posStr: string): PseudoArray;
+    avg(posStr: string): number;
+    binary_search({ val }: IArrayArgs, posStr: string): number;
+    binary_search_leftmost({ val }: IArrayArgs, posStr: string): number;
+    binary_search_rightmost({ val }: IArrayArgs, posStr: string): number;
     clear(): void;
     concat({ id2 }: IArrayArgs): this;
-    covariance({ id2, biased }: IArrayArgs): number;
-    every(): boolean;
+    covariance({ id2, biased }: IArrayArgs, posStr: string): number | undefined;
+    every(posStr: string): boolean;
     fill({ value, index_from, index_to }: IArrayArgs): void;
     get({ index }: IArrayArgs): any;
     includes({ value }: IArrayArgs): boolean;
     indexof({ value }: IArrayArgs): number;
     insert({ index, value }: IArrayArgs): void;
-    join({ separator }?: IArrayArgs): string;
+    join({ separator }: IArrayArgs | undefined, posStr: string): string;
     last(): any;
     lastindexof({ value }: IArrayArgs): number;
-    max({ nth }?: IArrayArgs): number;
-    median(): number;
-    min({ nth }?: IArrayArgs): number;
-    mode(): number;
-    percentile_linear_interpolation({ percentage }: IArrayArgs): number | undefined;
-    percentile_nearest_rank({ percentage }: IArrayArgs): number;
-    percentrank({ index }: IArrayArgs): number;
+    max({ nth }: IArrayArgs | undefined, posStr: string): number;
+    median(posStr: string): number;
+    min({ nth }: IArrayArgs | undefined, posStr: string): number;
+    mode(posStr: string): number;
+    percentile_linear_interpolation({ percentage }: IArrayArgs, posStr: string): number | undefined;
+    percentile_nearest_rank({ percentage }: IArrayArgs, posStr: string): number | undefined;
+    percentrank({ index }: IArrayArgs, posStr: string): number | undefined;
     pop(): any;
     push({ value }: IArrayArgs): void;
-    range(): number;
+    range(posStr: string): number | undefined;
     remove({ index }: IArrayArgs): any;
     reverse(): void;
     set({ index, value }: IArrayArgs): void;
     shift(): any;
-    some(): boolean;
-    sort({ order }?: IArrayArgs): void;
-    sort_indices({ order }?: IArrayArgs): PseudoArray;
-    standardize(): PseudoArray;
-    stdev({ biased }?: IArrayArgs): number;
-    sum(): any;
+    some(posStr: string): boolean;
+    sort({ order }: IArrayArgs | undefined, posStr: string): void;
+    sort_indices({ order }: IArrayArgs | undefined, posStr: string): PseudoArray;
+    standardize(posStr: string): PseudoArray;
+    stdev({ biased }: IArrayArgs | undefined, posStr: string): number | undefined;
+    sum(posStr: string): any;
     unshift({ value }: IArrayArgs): void;
-    variance({ biased }?: IArrayArgs): number;
+    variance({ biased }: IArrayArgs | undefined, posStr: string): number | undefined;
     private _calculateVariances;
     private _calculateStandardDeviations;
     private _standardizeArray;

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

@@ -1,3 +1,4 @@
+import { TccErrorListener } from ".";
 import { PseudoArray } from "./array";
 interface IMapArgs {
     id?: PseudoMap;
@@ -6,6 +7,8 @@ interface IMapArgs {
     id2?: PseudoMap;
 }
 export default class BuildInMap {
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
     new(): PseudoMap;
     copy({ id }: IMapArgs): PseudoMap | undefined;
     get({ id, key }: IMapArgs): any;
@@ -19,8 +22,9 @@ export default class BuildInMap {
     contains({ id, key }: IMapArgs): boolean | undefined;
 }
 declare class PseudoMap {
+    private _errorListener;
     private _mapInstance;
-    constructor();
+    constructor(errorListener: TccErrorListener);
     get isMap(): boolean;
     private _copyMap;
     copy(): PseudoMap;

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

@@ -1,3 +1,4 @@
+import { TccErrorListener } from ".";
 interface IMathArgs {
     number?: number;
     angle?: number;
@@ -17,31 +18,32 @@ export default class BuildInMath {
     private _mintick;
     private _cacheData;
     private _barIndex;
-    constructor(mintick: number);
+    private _errorListener;
+    constructor(mintick: number, errorListener: TccErrorListener);
     update(barIndex: number): void;
-    abs({ number }: IMathArgs): number;
+    abs({ number }: IMathArgs): number | undefined;
     acos({ angle }: IMathArgs): number | undefined;
     asin({ angle }: IMathArgs): number | undefined;
     atan({ angle }: IMathArgs): number | undefined;
     avg(_: IMathArgs, numbers: number[]): number;
-    ceil({ number }: IMathArgs): number;
-    floor({ number }: IMathArgs): number;
+    ceil({ number }: IMathArgs): number | undefined;
+    floor({ number }: IMathArgs): number | undefined;
     cos({ angle }: IMathArgs): number | undefined;
     sin({ angle }: IMathArgs): number | undefined;
     tan({ angle }: IMathArgs): number | undefined;
-    exp({ number }: IMathArgs): number;
-    log({ number }: IMathArgs): number;
-    log10({ number }: IMathArgs): number;
+    exp({ number }: IMathArgs): number | undefined;
+    log({ number }: IMathArgs): number | undefined;
+    log10({ number }: IMathArgs): number | undefined;
     max(_: IMathArgs, numbers: number[]): number;
     min(_: IMathArgs, numbers: number[]): number;
-    pow({ base, exponent }: IMathArgs): number;
-    random({ min, max, seed }: IMathArgs): string | number;
-    round({ number, precision }: IMathArgs): number;
-    round_to_mintick({ number }: IMathArgs): number;
+    pow({ base, exponent }: IMathArgs): number | undefined;
+    random({ min, max, seed }: IMathArgs, posStr: string): string | number | undefined;
+    round({ number, precision }: IMathArgs): number | undefined;
+    round_to_mintick({ number }: IMathArgs): number | undefined;
     sign({ number }: IMathArgs): number | undefined;
-    sqrt({ number }: IMathArgs): number;
+    sqrt({ number }: IMathArgs): number | undefined;
     sum({ source, length }: IMathArgs, posStr: string): number | undefined;
-    todegrees({ radians }: IMathArgs): number;
-    toradians({ degrees }: IMathArgs): number;
+    todegrees({ radians }: IMathArgs): number | undefined;
+    toradians({ degrees }: IMathArgs): number | undefined;
 }
 export {};

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

@@ -1,5 +1,6 @@
 import { VSortOrder } from "../enum";
 import { PseudoArray } from "./array";
+import { TccErrorListener } from '.';
 interface IMatrixArgs {
     rows?: number;
     columns?: number;
@@ -23,6 +24,8 @@ interface IMatrixArgs {
     column2?: number;
 }
 export default class BuildInMatrix {
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
     new({ rows, columns, initial_value }?: IMatrixArgs): Matrix;
     avg({ id }: IMatrixArgs): number | undefined;
     col({ id, column }: IMatrixArgs): PseudoArray | undefined;
@@ -52,7 +55,7 @@ export default class BuildInMatrix {
     add_col({ id, column, array_id }: IMatrixArgs): void;
     add_row({ id, row, array_id }: IMatrixArgs): void;
     is_zero({ id }: IMatrixArgs): boolean | undefined;
-    reshape({ id, rows, columns }: IMatrixArgs): void | undefined;
+    reshape({ id, rows, columns }: IMatrixArgs, posStr: string): void | undefined;
     reverse({ id }: IMatrixArgs): void;
     is_binary({ id }: IMatrixArgs): boolean | undefined;
     is_square({ id }: IMatrixArgs): boolean | undefined;
@@ -75,7 +78,8 @@ export default class BuildInMatrix {
 }
 declare class Matrix {
     private _matrixInstance;
-    constructor(rows?: number, columns?: number, initial_value?: any);
+    private _errorListener;
+    constructor(rows: number | undefined, columns: number | undefined, initial_value: any, errorListener: TccErrorListener);
     get _matrixArray(): any[][];
     get _value(): PseudoArray[];
     set _value(matrix: PseudoArray[]);
@@ -109,7 +113,7 @@ declare class Matrix {
     add_col({ column, array_id }?: IMatrixArgs): void;
     add_row({ row, array_id }: IMatrixArgs): void;
     is_zero(): boolean;
-    reshape({ rows, columns }: IMatrixArgs): void;
+    reshape({ rows, columns }: IMatrixArgs, posStr: string): void;
     reverse(): void;
     is_binary(): boolean;
     is_square(): boolean;

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

@@ -1,3 +1,4 @@
+import { TccErrorListener } from ".";
 import { PseudoArray } from "./array";
 interface IStrArgs {
     source?: string;
@@ -18,25 +19,27 @@ interface IStrArgs {
     timezone?: string;
 }
 export default class BuildInStr {
-    pos({ source, str }: IStrArgs): number | undefined;
-    trim({ source }: IStrArgs): string | undefined;
-    lower({ source }: IStrArgs): string | undefined;
+    private _errorListener;
+    constructor(errorListener: TccErrorListener);
+    pos({ source, str }: IStrArgs): number;
+    trim({ source }: IStrArgs): string;
+    lower({ source }: IStrArgs): string;
     match({ source, regex }: IStrArgs): string;
     split({ string, separator }: IStrArgs): PseudoArray;
-    upper({ source }: IStrArgs): string | undefined;
+    upper({ source }: IStrArgs): string;
     format({ formatString }: IStrArgs, args: any[]): string;
-    length({ string }: IStrArgs): number | undefined;
-    repeat({ source, repeat, separator }: IStrArgs): string;
-    replace({ source, target, replacement, occurrence }: IStrArgs): string | undefined;
-    contains({ source, str }: IStrArgs): boolean | undefined;
-    endswith({ source, str }: IStrArgs): boolean | undefined;
+    length({ string }: IStrArgs): number;
+    repeat({ source, repeat, separator }: IStrArgs, posStr: string): string | undefined;
+    replace({ source, target, replacement, occurrence }: IStrArgs): string;
+    contains({ source, str }: IStrArgs): boolean;
+    endswith({ source, str }: IStrArgs): boolean;
     tonumber({ string }: IStrArgs): number | undefined;
     tostring({ value, format }: IStrArgs): string | number | undefined;
     private _arrToStr;
-    substring({ source, begin_pos, end_pos }: IStrArgs): string | undefined;
-    startswith({ source, str }: IStrArgs): boolean | undefined;
+    substring({ source, begin_pos, end_pos }: IStrArgs): string;
+    startswith({ source, str }: IStrArgs): boolean;
     format_time({ time, format, timezone }: IStrArgs): string;
-    replace_all({ source, target, replacement }: IStrArgs): string | undefined;
+    replace_all({ source, target, replacement }: IStrArgs): string;
     private _formatNumber;
     private _strFormat;
 }

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

@@ -44,6 +44,7 @@ export declare const ERRORS_TIPS: {
     objectIsNaErr: string;
     buidinAssignErr: string;
     buidinVarErr: string;
+    useNaErr: string;
 };
 export declare const WARNING_TIPS: {
     repeatVar: string;

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

@@ -6,3 +6,4 @@ export declare function generateRandomId(length?: number): string;
 export declare function parseTimezoneOffset(timezone: string): number;
 export declare function parserTimezone(time?: number, timezone?: string): dayjs.Dayjs;
 export declare function periodConvert(period: string): number;
+export declare function isNotNum(num?: number): boolean;