wenay-common 1.0.74 → 1.0.75

package/lib/Common/Common.js

@@ -89,14 +89,14 @@ var E_SORTMODE;
 (function (E_SORTMODE) {
     E_SORTMODE[E_SORTMODE["DESCEND"] = 0] = "DESCEND";
     E_SORTMODE[E_SORTMODE["ASCEND"] = 1] = "ASCEND";
-})(E_SORTMODE = exports.E_SORTMODE || (exports.E_SORTMODE = {}));
+})(E_SORTMODE || (exports.E_SORTMODE = E_SORTMODE = {}));
 ;
 var E_MATCH;
 (function (E_MATCH) {
     E_MATCH[E_MATCH["LESS_OR_EQUAL"] = -1] = "LESS_OR_EQUAL";
     E_MATCH[E_MATCH["EQUAL"] = 0] = "EQUAL";
     E_MATCH[E_MATCH["GREAT_OR_EQUAL"] = 1] = "GREAT_OR_EQUAL";
-})(E_MATCH = exports.E_MATCH || (exports.E_MATCH = {}));
+})(E_MATCH || (exports.E_MATCH = E_MATCH = {}));
 function BSearch(array, arg2, arg3, ...args) {
     return typeof (arg3) == "function" ? __BSearch(array, arg2, arg3, ...args) :
         typeof (arg2) == "function" ? ___BSearch(array, arg2, arg3, ...args) :

package/lib/Exchange/CParams.d.ts

@@ -0,0 +1,216 @@
+import { const_Date } from "../Common/BaseTypes";
+type Year = number;
+type Month = number;
+type Day = number;
+type Hour = number;
+type Minute = number;
+export type DateTimeStr = `${Year}-${Month}-${Day} ${Hour}:${Minute}`;
+type DateTime = DateTimeStr | const_Date;
+export type RangeT<TVal, TStep = TVal> = {
+    min: TVal;
+    max: TVal;
+    step: TStep;
+};
+export type RangeExtT<TVal, TStep> = RangeT<TVal, TStep> & {
+    defaultMin: TVal;
+    defaultMax: TVal;
+    defaultStep: TStep;
+};
+export interface NumRange<T extends number = number> extends RangeT<T> {
+    min: T;
+    max: T;
+    step: T;
+}
+export type NumRangeExt<T extends number> = RangeExtT<T, T>;
+export type UserRangeT<TVal, TStep> = Partial<RangeExtT<TVal, TStep>> & ({
+    min: TVal;
+} | {
+    defaultMin: TVal;
+}) & ({
+    max: TVal;
+} | {
+    defaultMax: TVal;
+}) & ({
+    step: TStep;
+} | {
+    defaultStep: TStep;
+});
+export type UserNumRange<T extends number = number> = UserRangeT<T, T>;
+export type UserTimeRange = Partial<UserRangeT<DateTime, number>>;
+type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type ReadonlyFull<T> = T extends ((...args: any) => any) ? T : T extends const_Date ? const_Date : {
+    readonly [P in keyof T]: ReadonlyFull<T[P]>;
+};
+type ParamType = "number" | "string" | "boolean" | "time" | "symbol";
+export type AnyEnumVal = number | string | const_Date | object;
+interface IParamBase0 {
+    name?: string;
+    range?: (number | string | DateTime | object)[] | UserNumRange | UserTimeRange | undefined;
+    progressive?: boolean | undefined;
+    enabled?: boolean | undefined;
+    hidden?: boolean;
+    type?: ParamType | undefined;
+}
+interface IParamBase1<T = never> {
+    value: string | number | boolean | DateTime | IParams | T | (number | string | boolean | DateTime | IParams | T)[];
+    constLength?: boolean | undefined;
+    elementsEnabled?: boolean | undefined | (boolean[]);
+}
+export interface IParamBase extends IParamBase0, IParamBase1 {
+}
+export type IParamBaseReadonly = ReadonlyFull<IParamBase>;
+interface IParamVal<T extends string | number | boolean | DateTime | IParams | object> extends IParamBase1<T> {
+    value: T;
+    constLength?: undefined;
+    elementsEnabled?: undefined;
+}
+type ParamVal<TParam extends IParamBase0, T extends string | number | boolean | DateTime | IParams> = TParam & IParamVal<T>;
+interface IParamArr<T extends string | number | boolean | DateTime | IParams> extends IParamBase1<T> {
+    value: T[];
+    constLength?: boolean;
+    elementsEnabled?: boolean | (boolean[]);
+}
+type ParamArr<TParam extends IParamBase0, T extends string | number | boolean | DateTime | IParams> = TParam & IParamArr<T>;
+interface IParamBaseDefault extends IParamBase0 {
+    progressive?: undefined;
+}
+interface IParamNumBase<T extends number> extends IParamBase0 {
+    range: UserNumRange<T>;
+    progressive?: boolean;
+    type?: "number" | undefined;
+}
+export type IParamNum<T extends number = number> = ParamVal<IParamNumBase<T>, T>;
+export type IParamNumArr<T extends number = number> = ParamArr<IParamNumBase<T>, T>;
+export type ParamNum<T extends number = number> = IParamNum<T> | IParamNumArr<T>;
+interface _IParamEnumBase<T extends AnyEnumVal> extends IParamBaseDefault {
+    range: T[];
+    labels?: string[] | undefined;
+    valueToString?: {
+        (value: T): string;
+    } | undefined;
+}
+interface IParamEnumBaseAny1<T extends AnyEnumVal> extends _IParamEnumBase<T> {
+    labels: string[];
+    valueToString?: undefined;
+}
+interface IParamEnumBaseAny2<T extends AnyEnumVal> extends _IParamEnumBase<T> {
+    valueToString(value: T): string;
+    labels?: undefined;
+}
+type IParamEnumBaseAny<T extends AnyEnumVal> = IParamEnumBaseAny1<T> | IParamEnumBaseAny2<T>;
+interface IParamEnumBase<T extends number | string | DateTime> extends _IParamEnumBase<T> {
+    labels?: string[];
+    type?: T extends number ? "number" : "string";
+    valueToString?: undefined;
+}
+export interface IParamEnum<T extends number | string | DateTime = number | string | DateTime> extends ParamVal<IParamEnumBase<T>, T> {
+}
+export type IParamEnumReadonly<T extends number | string | DateTime = number | string | DateTime> = ReadonlyFull<IParamEnum<T>>;
+export type IParamEnumAny<T extends AnyEnumVal = AnyEnumVal> = (T extends number | string | DateTime ? IParamEnumReadonly<T> : IParamEnumBaseAny<T>) & IParamVal<T>;
+export interface IParamEnumArr<T extends number | string | DateTime = number | string | DateTime> extends ParamArr<IParamEnumBase<T>, T> {
+}
+export type ParamEnum<T extends number | string | DateTime = number | string | DateTime> = IParamEnum<T> | IParamEnumArr<T>;
+export type ParamEnumReadonly<T extends number | string | DateTime> = ReadonlyFull<ParamEnum<T>>;
+interface IParamTimeBase1 extends IParamBaseDefault {
+    range?: DateTimeStr[] | UserTimeRange;
+    type: "time";
+}
+interface IParamTimeBase2 extends IParamBaseDefault {
+    range?: const_Date[] | UserTimeRange;
+    type?: "time";
+}
+export interface IParamTime1 extends ParamVal<IParamTimeBase1, DateTimeStr> {
+}
+export interface IParamTime2 extends ParamVal<IParamTimeBase2, const_Date> {
+}
+export interface IParamTimeArr1 extends ParamArr<IParamTimeBase1, DateTimeStr> {
+}
+export interface IParamTimeArr2 extends ParamArr<IParamTimeBase2, const_Date> {
+}
+export type ParamTime = IParamTime1 | IParamTime2 | IParamTimeArr1 | IParamTimeArr2;
+export interface IParamEnum2<T extends number | string> extends IParamBaseDefault {
+    value: T | T[];
+    range: [T, ...T[]];
+    enabled?: undefined;
+}
+interface IParamStringBase extends IParamBaseDefault {
+    range?: undefined;
+    type?: "string" | "symbol";
+}
+interface IParamString extends ParamVal<IParamStringBase, string> {
+}
+interface IParamStringArr extends ParamArr<IParamStringBase, string> {
+}
+export type ParamString = IParamString | IParamStringArr;
+interface IParamBoolBase extends IParamBaseDefault {
+    range?: undefined;
+    enabled?: undefined;
+    type?: "boolean";
+}
+export interface IParamBoolean extends ParamVal<IParamBoolBase, boolean> {
+}
+export interface IParamBooleanArr extends ParamArr<IParamBoolBase, boolean> {
+    constLength?: true;
+}
+export type ParamBoolean = IParamBoolean | IParamBooleanArr;
+export interface IParamGroup extends IParamBaseDefault, IParamBase1 {
+    value: IParams;
+    range?: undefined;
+    enabled?: boolean;
+    type?: undefined;
+    constLength?: undefined;
+    elementsEnabled?: undefined;
+}
+export type ParamBase<T extends "time" | number | string | boolean | object = "time" | number | string | boolean | object> = T extends "time" ? ParamTime : T extends string ? ParamEnum<T> : T extends number ? ParamNum<T> | ParamEnum<T> : T extends boolean ? ParamBoolean : T extends object ? IParamGroup : never;
+export type IParam = ParamTime | ParamNum | ParamEnum<number> | ParamEnum<string> | ParamBoolean | ParamString | boolean | number | string | IParamGroup | (() => any);
+export type IParamReadonly = ReadonlyFull<IParam>;
+export declare function isParamBase(param: IParam): param is IParam & IParamBase;
+export type IParams = {
+    [key in string]: IParam;
+};
+export type IParamsReadonly = {
+    readonly [key in string]: IParamReadonly;
+};
+export declare class CParams implements IParams {
+    [key: string]: IParam;
+}
+export declare class CParamsReadonly implements IParamsReadonly {
+    readonly [key: string]: IParamReadonly;
+}
+export type IParamExpandable = Exclude<IParam, {
+    value: any;
+}> | (Extract<IParam, {
+    value: any;
+}> & {
+    expanded?: boolean;
+});
+export type IParamExpandableReadonly = ReadonlyFull<IParamExpandable>;
+export type IParamsExpandable = {
+    [key: string]: IParamExpandable;
+};
+export type IParamsExpandableReadonly = ReadonlyFull<IParamsExpandable>;
+export declare function isParamGroupOrArray<TParam extends IParamReadonly>(param: TParam): param is Extract<TParam, ReadonlyFull<IParamGroup | IParamArr<any>>>;
+export declare function isParamGroup<TParam extends IParamReadonly>(param: TParam): param is Extract<TParam, ReadonlyFull<IParamGroup>>;
+type ObjectKeyPath<TObject extends object = object, TValue = unknown> = readonly string[];
+export declare function iterateParams<TObj extends IParamsReadonly, TVal extends IParamReadonly = TObj[string]>(obj: TObj, currentPath?: ObjectKeyPath<TObj, TVal>): Generator<[key: string, value: TVal, path: ObjectKeyPath<TObj, TVal>]>;
+export declare function enableAllParams<T extends IParamsReadonly>(params: T, enabled?: boolean): T;
+export type SimpleParamsMutable<T> = T extends const_Date ? const_Date : Mutable<{
+    [key in keyof T]: (T[key] extends {
+        value: IParamsReadonly;
+    } ? SimpleParamsMutable<T[key]["value"]> : T[key] extends {
+        value: any;
+    } ? (T[key] extends {
+        value: [];
+        elementsEnabled: boolean | [];
+    } ? Partial<Mutable<T[key]["value"]>> : Mutable<T[key]["value"]>) : T[key] extends () => infer RES ? RES : Mutable<T[key]>) | (T[key] extends {
+        enabled: boolean;
+    } ? null : never);
+}> & {
+    readonly [key: number]: void;
+};
+export type SimpleParams<T = IParams> = ReadonlyFull<SimpleParamsMutable<T>>;
+export declare function GetSimpleParams<T extends ReadonlyFull<IParams>>(params: T): SimpleParamsMutable<T>;
+export declare function mergeParamValuesToInfos<TParams extends IParamsReadonly>(srcObj: TParams, valuesObj: SimpleParams): TParams;
+export {};

package/lib/Exchange/CParams.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeParamValuesToInfos = exports.GetSimpleParams = exports.enableAllParams = exports.iterateParams = exports.isParamGroup = exports.isParamGroupOrArray = exports.CParamsReadonly = exports.CParams = exports.isParamBase = void 0;
+const Common_1 = require("../Common/Common");
+let ts = "2025-06-01 16:25:25";
+{
+    let x = { value: 5, range: [5, 6] };
+}
+let dd;
+function isParamBase(param) {
+    return typeof param == "object" && !Array.isArray(param) && !(param instanceof Date);
+}
+exports.isParamBase = isParamBase;
+class CParams {
+}
+exports.CParams = CParams;
+class CParamsReadonly {
+}
+exports.CParamsReadonly = CParamsReadonly;
+function isParamGroupOrArray(param) {
+    return typeof param == "object" && typeof param.value == "object" && !(param.value instanceof Date);
+}
+exports.isParamGroupOrArray = isParamGroupOrArray;
+function isParamGroup(param) {
+    return isParamGroupOrArray(param) && !Array.isArray(param.value);
+}
+exports.isParamGroup = isParamGroup;
+function* iterateParams(obj, currentPath = []) {
+    for (let [key, param] of Object.entries(obj)) {
+        let keyPath = currentPath.concat(key);
+        yield [key, param, keyPath];
+        if (typeof param == "object") {
+            const valKey = "value";
+            let value = param[valKey];
+            if (typeof value == "object" && !(0, Common_1.isDate)(value) && !Array.isArray(value))
+                yield* iterateParams(value, keyPath.concat(valKey));
+        }
+    }
+}
+exports.iterateParams = iterateParams;
+function enableAllParams(params, enabled = true) {
+    const paramsInfoClone = (0, Common_1.deepCloneMutable)(params);
+    for (let [key, param] of iterateParams(paramsInfoClone)) {
+        if (isParamBase(param) && param.enabled != null)
+            param.enabled = enabled;
+        if (isParamBase(param) && param.elementsEnabled != null)
+            param.elementsEnabled = enabled;
+    }
+    return paramsInfoClone;
+}
+exports.enableAllParams = enableAllParams;
+class C extends CParams {
+    lastBar = { name: "Last_Bar", value: 0, range: { defaultMin: -10000, max: 0, step: 1 } };
+}
+let xxx = {};
+let bbb = xxx;
+const param = {
+    p0: { name: "MA0", value: [10, 20], range: [10, 20, 30] },
+    p1: { name: "MA1", value: 20, range: { min: 10, max: 20, step: 2 } },
+    p2: { name: "MA2", value: 10, range: [10, 20, 30] },
+    p3: { name: "MA3", value: "a", range: ["a", "b", "c"] },
+    p4: { name: "MA4", value: true },
+    p5: {
+        name: "group",
+        enabled: true,
+        value: {
+            p1: { name: "gMA1", value: 20, range: { min: 10, max: 20, step: 2 } },
+            p2: { name: "gMA2", value: 10, range: [10, 20, 30] }
+        }
+    },
+    p6: 10,
+    p7: { name: "time", value: "2020-01-05 12:46", type: "time", range: { min: "2020-01-05 00:00", max: "2020-01-05 00:00", step: 200 } },
+    p8: { name: "time2", value: new Date() }
+};
+class CCC extends CParams {
+    time = { name: "Time", value: "2020-01-05 12:46", type: "time" };
+    text = { value: "text", type: "symbol" };
+}
+class Test2 {
+    p0 = 123;
+    p1 = "213";
+    p2 = [10, 20, 30];
+    p3 = "a";
+    p4 = true;
+    p5 = {
+        enabled: true,
+        p1: "gMA1",
+        p2: "gMA2"
+    };
+}
+class Test extends CParams {
+    p0 = { name: "MA0", value: [10, 20], range: [10, 20, 30] };
+    p1 = { name: "MA1", value: 20, range: { min: 10, max: 20, step: 2 } };
+    p2 = { name: "MA2", value: 10, range: [10, 20, 30] };
+    p3 = { name: "MA3", value: "a", range: ["a", "b", "c"] };
+    p4 = { name: "MA4", value: true };
+    p5 = {
+        name: "group",
+        enabled: true,
+        value: {
+            p1: { name: "gMA1", value: 20, range: { min: 10, max: 20, step: 2 } },
+            p2: { name: "gMA2", value: 10, range: [10, 20, 30] }
+        }
+    };
+}
+function GetSimpleParams(params) {
+    let simpleParams = params;
+    for (let key in params) {
+        const param = params[key];
+        simpleParams[key] =
+            typeof (param) == "function" ? param() :
+                typeof (param) != "object" ? param :
+                    param.enabled == false ? null :
+                        typeof (param.value) != "object" ? param.value :
+                            param.value instanceof Array ? (param.value.filter((item, i) => Array.isArray(param.elementsEnabled) ? param.elementsEnabled[i] : param.elementsEnabled != false)) :
+                                param.value instanceof Date ? new Date(param.value) :
+                                    GetSimpleParams(param.value);
+    }
+    return simpleParams;
+}
+exports.GetSimpleParams = GetSimpleParams;
+let p = GetSimpleParams(new Test());
+let p0 = p.p1;
+let p3 = p.p3;
+let p4 = p.p4;
+let p5 = p.p5?.p1;
+function convert_(valuesObj, srcObj) {
+    let resObj = {};
+    if (srcObj instanceof Array)
+        if (valuesObj instanceof Array)
+            return [...valuesObj];
+        else
+            return srcObj;
+    for (let key in srcObj) {
+        const srcval = srcObj[key];
+        resObj[key] = (() => {
+            const val = valuesObj[key];
+            if (val == undefined) {
+                if (typeof srcval == "object" && srcval.enabled != undefined)
+                    return { ...srcval, enabled: false };
+            }
+            if (typeof srcval == "boolean") {
+                if (typeof val == "boolean")
+                    return val;
+            }
+            if (typeof srcval == "object") {
+                let srcvalue = srcval.value;
+                if (srcvalue == null)
+                    return srcval;
+                const resVal = { ...srcval };
+                if (srcvalue instanceof Date && (typeof val == "string" || val instanceof Date))
+                    resVal.value = new Date(val);
+                else if (typeof srcvalue != typeof val)
+                    return srcval;
+                else if (typeof srcvalue != "object")
+                    resVal.value = val;
+                else if (Array.isArray(val)) {
+                    resVal.value = [...val];
+                    if (resVal.elementsEnabled != null)
+                        resVal.elementsEnabled = true;
+                }
+                else
+                    resVal.value = convert_(val, srcvalue);
+                if (srcval.enabled != undefined)
+                    resVal.enabled = true;
+                return resVal;
+            }
+            return srcval;
+        })();
+    }
+    return resObj;
+}
+function mergeParamValuesToInfos(srcObj, valuesObj) {
+    return convert_(valuesObj, srcObj);
+}
+exports.mergeParamValuesToInfos = mergeParamValuesToInfos;

package/lib/Exchange/ConnectData/Binance/order.js

@@ -412,4 +412,4 @@ var spaceBinance;
     }
     spaceBinance.BinanceDataFunc = BinanceDataFunc;
     spaceBinance.binanceFunc = new BinanceDataFunc;
-})(spaceBinance = exports.spaceBinance || (exports.spaceBinance = {}));
+})(spaceBinance || (exports.spaceBinance = spaceBinance = {}));

package/lib/Exchange/ConnectData/Binance.js

@@ -510,4 +510,4 @@ var Test;
     function Test1() { }
     Test.Test1 = Test1;
     function Test2() { }
-})(Test = exports.Test || (exports.Test = {}));
+})(Test || (exports.Test = Test = {}));

package/lib/index.d.ts

@@ -22,5 +22,6 @@ export * as Color from "./Common/Color";
 export * as ListNodeAnd from "./Common/ListNodeAnd";
 export * as Math from "./Common/Math";
 export * as List from "./Common/List";
+export * as Params from "./Exchange/CParams";
 export * as LoadCandles from "./Exchange/ConnectData/Binance";
 export declare function test(): void;

package/lib/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.test = exports.LoadCandles = exports.List = exports.Math = exports.ListNodeAnd = exports.Color = exports.Time = exports.Common = exports.BaseTypes = void 0;
+exports.test = exports.LoadCandles = exports.Params = exports.List = exports.Math = exports.ListNodeAnd = exports.Color = exports.Time = exports.Common = exports.BaseTypes = void 0;
 __exportStar(require("./Common/BaseTypes"), exports);
 __exportStar(require("./Common/ByteStream"), exports);
 __exportStar(require("./Common/Color"), exports);
@@ -39,6 +39,7 @@ exports.Color = require("./Common/Color");
 exports.ListNodeAnd = require("./Common/ListNodeAnd");
 exports.Math = require("./Common/Math");
 exports.List = require("./Common/List");
+exports.Params = require("./Exchange/CParams");
 exports.LoadCandles = require("./Exchange/ConnectData/Binance");
 const ListNodeAnd_1 = require("./Common/ListNodeAnd");
 function test() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common",
-  "version": "1.0.74",
+  "version": "1.0.75",
   "description": "math math math",
   "strict": true,
   "main": "lib/index.js",
@@ -30,15 +30,16 @@
     "node-fetch": "^3.3.1",
     "npm": "^9.6.7",
     "ts-node": "^10.9.1",
-    "xmlhttprequest": "^1.8.0",
-    "wenay-common": "^1.0.69"
+    "wenay-common": "^1.0.69",
+    "xmlhttprequest": "^1.8.0"
   },
   "devDependencies": {
     "@types/create-hmac": "^1.1.0",
     "@types/dotenv": "^8.2.0",
     "@types/node": "^18.7.14",
     "@types/validator": "^13.1.0",
-    "dotenv": "^8.2.0"
+    "dotenv": "^8.2.0",
+    "typescript": "^5.1.3"
   },
   "optionalDependencies": {
     "utf-8-validate": "^6.0.3"