wenay-common2 1.0.42 → 1.0.44

package/lib/Common/events/Listen.d.ts

@@ -1,6 +1,6 @@
 export type Listener<T extends any[]> = (...r: T) => void;
 export type NormalizeTuple<T> = T extends any[] ? T : [T];
-export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), data?: {
+export declare function funcListenCallbackBase<T, T2 = any>(b: (e: Listener<NormalizeTuple<T>>) => (void | (() => void)), data?: {
     event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void;
     fast?: boolean;
     addListenClose?: ReturnType<typeof funcListenCallbackBase<any>>;
@@ -10,11 +10,14 @@ export declare function funcListenCallbackBase<T>(b: (e: Listener<NormalizeTuple
     run: () => void;
     close: () => void;
     eventClose: (cb: () => void) => () => void;
-    removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: () => void) => () => void;
-    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    removeEventClose: (cb: (() => void)) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
+        cbClose?: () => void;
+        key?: T2;
+    }) => () => void;
+    removeListen: (k: Listener<NormalizeTuple<T>> | null | T2) => void;
     count: () => number;
-    readonly getAllKeys: Listener<NormalizeTuple<T>>[];
+    readonly getAllKeys: (T2 | Listener<NormalizeTuple<T>>)[];
 };
 export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void))): {
     func: Listener<NormalizeTuple<T>>;
@@ -23,10 +26,13 @@ export declare function funcListenCallbackFast<T>(a: (e: (Listener<NormalizeTupl
     close: () => void;
     eventClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
-    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
+        cbClose?: (() => void) | undefined;
+        key?: any;
+    }) => () => void;
+    removeListen: (k: any) => void;
     count: () => number;
-    readonly getAllKeys: Listener<NormalizeTuple<T>>[];
+    readonly getAllKeys: (T2 | Listener<NormalizeTuple<T_1>>)[];
 };
 export declare function funcListenCallback<T>(a: (e: (Listener<NormalizeTuple<T>> | null)) => (void | (() => void)), event?: (type: "add" | "remove", count: number, api: ReturnType<typeof funcListenCallbackBase<T>>) => void, fast?: boolean): {
     func: Listener<NormalizeTuple<T>>;
@@ -35,10 +41,13 @@ export declare function funcListenCallback<T>(a: (e: (Listener<NormalizeTuple<T>
     close: () => void;
     eventClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
-    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
+        cbClose?: (() => void) | undefined;
+        key?: any;
+    }) => () => void;
+    removeListen: (k: any) => void;
     count: () => number;
-    readonly getAllKeys: Listener<NormalizeTuple<T>>[];
+    readonly getAllKeys: (T2 | Listener<NormalizeTuple<T_1>>)[];
 };
 export declare function UseListen<T>(data?: Parameters<typeof funcListenCallbackBase<T>>[1]): readonly [(...a: NormalizeTuple<T>) => void, {
     func: Listener<NormalizeTuple<T>>;
@@ -47,9 +56,12 @@ export declare function UseListen<T>(data?: Parameters<typeof funcListenCallback
     close: () => void;
     eventClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<T>>, cbClose?: (() => void) | undefined) => () => void;
-    removeListen: (cb: Listener<NormalizeTuple<T>> | null) => void;
+    addListen: (cb: Listener<NormalizeTuple<T>>, { cbClose, key }?: {
+        cbClose?: (() => void) | undefined;
+        key?: any;
+    }) => () => void;
+    removeListen: (k: any) => void;
     count: () => number;
-    readonly getAllKeys: Listener<NormalizeTuple<T>>[];
+    readonly getAllKeys: (T2 | Listener<NormalizeTuple<T_1>>)[];
 }];
 export declare function isListenCallback(obj: any): obj is ReturnType<typeof funcListenCallbackBase>;

package/lib/Common/events/Listen.js

@@ -75,31 +75,32 @@ function funcListenCallbackBase(b, data) {
             sinh.delete(cb);
             evClose.delete(cb);
         },
-        addListen: (cb, cbClose) => {
-            obj.set(cb, cb);
+        addListen: (cb, { cbClose, key } = {}) => {
+            const k = key ?? cb;
+            obj.set(k, cb);
             if (cbClose) {
-                if (evClose.has(cb)) {
-                    const r = evClose.get(cb);
+                if (evClose.has(k)) {
+                    const r = evClose.get(k);
                     if (r !== cbClose) {
                         evClose.delete(r);
-                        evClose.delete(cb);
+                        evClose.delete(k);
                         sinh.delete(r);
                     }
                 }
-                evClose.set(cb, cbClose);
+                evClose.set(k, cbClose);
                 sinh.set(cbClose, cb);
             }
             if (fast)
                 rebuild();
             event?.("add", obj.size, api);
-            return () => api.removeListen(cb);
+            return () => api.removeListen(k);
         },
-        removeListen: (cb) => {
-            obj.delete(cb);
-            const e = evClose.get(cb);
+        removeListen: (k) => {
+            obj.delete(k);
+            const e = evClose.get(k);
             if (fast)
                 rebuild();
-            evClose.delete(cb);
+            evClose.delete(k);
             if (e) {
                 evClose.delete(e);
                 sinh.delete(e);

package/lib/Common/events/SocketBuffer.d.ts

@@ -18,7 +18,10 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
     memo: T4;
     snapshot?: (memo: T4) => T3;
 }): {
-    run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, cbClose?: (() => void) | undefined) => () => void;
+    run: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, params_1?: {
+        cbClose?: (() => void) | undefined;
+        key?: any;
+    } | undefined) => () => void;
     snapshot: () => T3 | undefined;
     memo: T4;
     listenA: {
@@ -28,10 +31,13 @@ export declare function funcListenCallbackSnapshot<T extends realSocket2<any | a
         close: () => void;
         eventClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
-        addListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, cbClose?: (() => void) | undefined) => () => void;
-        removeListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]> | null) => void;
+        addListen: (cb: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>, { cbClose, key }?: {
+            cbClose?: (() => void) | undefined;
+            key?: any;
+        }) => () => void;
+        removeListen: (k: any) => void;
         count: () => number;
-        readonly getAllKeys: import("./Listen").Listener<[data: getTypeCallback<T>, memo: T3]>[];
+        readonly getAllKeys: (T2_1 | import("./Listen").Listener<import("./Listen").NormalizeTuple<T_1>>)[];
     };
     connect: () => void;
     readonly disconnect: ((a: Omit<Parameters<T>[0], "callback"> & {

package/lib/Common/events/SocketServerHook.d.ts

@@ -11,10 +11,13 @@ export declare function SocketServerHook(opt?: {
             close: () => void;
             eventClose: (cb: () => void) => () => void;
             removeEventClose: (cb: () => void) => void;
-            addListen: (cb: import("./Listen").Listener<[unknown]>, cbClose?: (() => void) | undefined) => () => void;
-            removeListen: (cb: import("./Listen").Listener<[unknown]> | null) => void;
+            addListen: (cb: import("./Listen").Listener<[unknown]>, { cbClose, key }?: {
+                cbClose?: (() => void) | undefined;
+                key?: any;
+            }) => () => void;
+            removeListen: (k: any) => void;
             count: () => number;
-            readonly getAllKeys: import("./Listen").Listener<[unknown]>[];
+            readonly getAllKeys: (T2 | import("./Listen").Listener<import("./Listen").NormalizeTuple<T>>)[];
         }];
     };
     get(tag: string): readonly [(a_0: unknown) => void, {
@@ -24,10 +27,13 @@ export declare function SocketServerHook(opt?: {
         close: () => void;
         eventClose: (cb: () => void) => () => void;
         removeEventClose: (cb: () => void) => void;
-        addListen: (cb: import("./Listen").Listener<[unknown]>, cbClose?: (() => void) | undefined) => () => void;
-        removeListen: (cb: import("./Listen").Listener<[unknown]> | null) => void;
+        addListen: (cb: import("./Listen").Listener<[unknown]>, { cbClose, key }?: {
+            cbClose?: (() => void) | undefined;
+            key?: any;
+        }) => () => void;
+        removeListen: (k: any) => void;
         count: () => number;
-        readonly getAllKeys: import("./Listen").Listener<[unknown]>[];
+        readonly getAllKeys: (T2 | import("./Listen").Listener<import("./Listen").NormalizeTuple<T>>)[];
     }];
     provider: (tag: string, data: any) => void;
 };

package/lib/Common/events/UseListenTransform.d.ts

@@ -8,8 +8,11 @@ export declare function UseListenTransform<TSource extends any[], TTarget extend
     close: () => void;
     eventClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
-    addListen: (cb: Listener<NormalizeTuple<TTarget>>, cbClose?: (() => void) | undefined) => () => void;
-    removeListen: (cb: Listener<NormalizeTuple<TTarget>> | null) => void;
+    addListen: (cb: Listener<NormalizeTuple<TTarget>>, { cbClose, key }?: {
+        cbClose?: (() => void) | undefined;
+        key?: any;
+    }) => () => void;
+    removeListen: (k: any) => void;
     count: () => number;
-    readonly getAllKeys: Listener<NormalizeTuple<TTarget>>[];
+    readonly getAllKeys: (T2 | Listener<NormalizeTuple<T>>)[];
 }];

package/lib/Common/funcTimeWait.d.ts

@@ -1,29 +1,32 @@
 export type tApiKey = string;
-type tType = "UID" | "IP" | (string & {});
+type tType = "UID" | "IP" | tApiKey;
 type tFunc = {
     timeStamp?: number;
     type: tType;
     weight: number;
 };
-export declare function funcTimeW(maxHistoryElements?: number): {
+export declare function funcTimeW(): {
     dStatic: {
         [key: string]: [number, number][];
     };
+    data: any[];
     add(item: tFunc): void;
     cleanByTime(type: tType, ms?: number): void;
     weight(type: tType, ms?: number): number;
-    byWeight(type: tType, weight?: number, timeNow?: number): number;
-    removeKey(type: tType): void;
+    weightNow(type: tType, ms?: number): number;
+    byWeight(type: tType, weight?: number): number;
+    byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
 };
 export declare const FuncTimeWait: {
     dStatic: {
         [key: string]: [number, number][];
     };
+    data: any[];
     add(item: tFunc): void;
     cleanByTime(type: tType, ms?: number): void;
     weight(type: tType, ms?: number): number;
-    byWeight(type: tType, weight?: number, timeNow?: number): number;
-    removeKey(type: tType): void;
+    weightNow(type: tType, ms?: number): number;
+    byWeight(type: tType, weight?: number): number;
+    byWeightTimeNow(type: tType, timeNow?: number, weight?: number): number;
 };
-export declare function testFuncTimeW(): void;
 export {};

package/lib/Common/funcTimeWait.js

@@ -2,74 +2,89 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncTimeWait = void 0;
 exports.funcTimeW = funcTimeW;
-exports.testFuncTimeW = testFuncTimeW;
-const common_1 = require("./core/common");
-function funcTimeW(maxHistoryElements = 800) {
+function funcTimeW() {
     const dStatic = {};
-    function getInsertIndex(arr, timeStamp) {
-        if (arr.length === 0)
-            return 0;
-        if (timeStamp >= arr[arr.length - 1][0])
-            return arr.length;
-        if (timeStamp <= arr[0][0])
-            return 0;
-        const index = (0, common_1.BSearch)(arr, timeStamp, (a, b) => a[0] - b, "greatOrEqual", "ascend");
-        return index === -1 ? arr.length : index;
-    }
-    function cleanupEmptyKey(type) {
-        if (dStatic[type] && dStatic[type].length === 0) {
-            delete dStatic[type];
-        }
-    }
+    const data = [];
     return {
         dStatic,
+        data,
         add(item) {
-            const arr = (dStatic[item.type] ??= []);
-            const timeStamp = item.timeStamp ?? Date.now();
-            const insertIndex = getInsertIndex(arr, timeStamp);
-            if (insertIndex === arr.length) {
-                arr.push([timeStamp, item.weight]);
-            }
-            else {
-                arr.splice(insertIndex, 0, [timeStamp, item.weight]);
+            if (!dStatic[item.type]) {
+                dStatic[item.type] = [];
             }
+            dStatic[item.type].push([item.timeStamp ?? Date.now(), item.weight]);
         },
         cleanByTime(type, ms = 60 * 1000) {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return;
-            const cutoff = Date.now() - ms;
-            if (arr[0][0] > cutoff)
+            const timeStamp = Date.now();
+            if (arr[0][0] > timeStamp - ms)
                 return;
-            const cutIndex = (0, common_1.BSearch)(arr, cutoff, (a, b) => a[0] - b, "greatOrEqual", "ascend");
-            if (cutIndex === -1) {
-                arr.splice(0, arr.length);
+            let cutIndex = 0;
+            while (cutIndex < arr.length && arr[cutIndex][0] < timeStamp - ms) {
+                cutIndex++;
             }
-            else if (cutIndex > 0) {
+            if (cutIndex > 0) {
                 arr.splice(0, cutIndex);
             }
-            cleanupEmptyKey(type);
         },
         weight(type, ms = 60 * 1000) {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return 0;
-            const cutoff = Date.now() - ms;
+            const timeStamp = Date.now();
             let sum = 0;
             let i = arr.length - 1;
             for (; i >= 0; i--) {
                 const [_time, _weight] = arr[i];
-                if (_time < cutoff)
+                if (_time < timeStamp - ms)
                     break;
                 sum += _weight;
             }
             if (i >= 0) {
                 arr.splice(0, i + 1);
-                cleanupEmptyKey(type);
             }
             return sum;
         },
-        byWeight(type, weight = 50000, timeNow = Date.now()) {
+        weightNow(type, ms = 60 * 1000) {
+            const arr = dStatic[type];
+            if (!arr || arr.length === 0)
+                return 0;
+            const timeStamp = Date.now();
+            let sum = 0;
+            let i = arr.length - 1;
+            for (; i >= 0; i--) {
+                const [_time, _weight] = arr[i];
+                if (_time < timeStamp - ms)
+                    break;
+                sum += _weight;
+            }
+            if (i >= 0) {
+                arr.splice(0, i + 1);
+            }
+            return sum;
+        },
+        byWeight(type, weight = 50000) {
+            const arr = dStatic[type];
+            if (!arr || arr.length === 0)
+                return 0;
+            let sum = 0;
+            let i = arr.length - 1;
+            let result = 0;
+            for (; i >= 0; i--) {
+                sum += arr[i][1];
+                if (sum > weight) {
+                    result = arr[i + 1]?.[0] ?? 0;
+                    break;
+                }
+            }
+            if (i > 800) {
+                arr.splice(0, i - 800);
+            }
+            return result;
+        },
+        byWeightTimeNow(type, timeNow = Date.now(), weight = 50000) {
             const arr = dStatic[type];
             if (!arr || arr.length === 0)
                 return 0;
@@ -89,28 +104,11 @@ function funcTimeW(maxHistoryElements = 800) {
                     break;
                 }
             }
-            if (i > maxHistoryElements) {
-                arr.splice(0, i - maxHistoryElements);
-                cleanupEmptyKey(type);
+            if (i > 800) {
+                arr.splice(0, i - 800);
             }
             return result;
         },
-        removeKey(type) {
-            delete dStatic[type];
-        }
     };
 }
 exports.FuncTimeWait = funcTimeW();
-function testFuncTimeW() {
-    const tracker = funcTimeW();
-    const type = "UID";
-    const now = Date.now();
-    tracker.add({ type, weight: 1, timeStamp: now });
-    tracker.add({ type, weight: 2, timeStamp: now - 500 });
-    tracker.add({ type, weight: 3, timeStamp: now + 500 });
-    console.log("funcTimeW order", tracker.dStatic);
-    tracker.cleanByTime(type, 200);
-    console.log("funcTimeW cleanByTime", tracker.dStatic);
-    const w = tracker.weight(type, 1000);
-    console.log("funcTimeW weight 1s", w, tracker.dStatic);
-}

package/lib/Common/rcp/listen-socket.js

@@ -71,7 +71,7 @@ function listenSocket(e, d) {
             }
             inner(...a);
         };
-        addListen(active, removeCallback);
+        addListen(active, { cbClose: removeCallback });
         addListenClose?.addListen(removeCallback);
         return new Promise((resolve) => {
             resolveWait = () => { resolve(); };

package/lib/Exchange/LoadBase.d.ts

@@ -1,5 +1,4 @@
-import { TF } from "../Common/Time";
-import type { CBar } from "./Bars";
+import { CBar, TF } from "wenay-common2";
 type RequestInfo = any;
 type RequestInit = any;
 type Response = any;

package/lib/Exchange/LoadBase.js

@@ -1,22 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadQuoteBase = LoadQuoteBase;
+const wenay_common2_1 = require("wenay-common2");
 const funcTimeWait_1 = require("../Common/funcTimeWait");
-const common_1 = require("../Common/core/common");
 function LoadQuoteBase(setting, data) {
-    const { base, maxLoadBars, intervalToName } = setting;
+    const { base, maxLoadBars, countConnect, intervalToName } = setting;
+    const maxLoadBars2 = setting.maxLoadBars2 ?? maxLoadBars;
     const startMap = new Map();
     const keyName = setting.nameKey ?? "loadKey";
     const time = setting.time ?? 60000;
     const other = data;
     const getDataEl = (a) => setting.controlTimeToNumber?.(a);
     async function waitLimit(weight = 1) {
-        const oldestTs = funcTimeWait_1.FuncTimeWait.byWeight(keyName, setting.countConnect);
-        const t1 = oldestTs > 0 ? oldestTs - Date.now() + time + 1 : 0;
+        const t1 = funcTimeWait_1.FuncTimeWait.byWeight(keyName, setting.countConnect) - (Date.now() - time) + 1;
         if (t1 > 0) {
-            await (0, common_1.sleepAsync)(t1);
+            funcTimeWait_1.FuncTimeWait.add({ type: keyName, weight: weight, timeStamp: Date.now() + t1 });
+            await (0, wenay_common2_1.sleepAsync)(t1);
+        }
+        else {
+            funcTimeWait_1.FuncTimeWait.add({ type: keyName, weight: weight, timeStamp: Date.now() });
         }
-        funcTimeWait_1.FuncTimeWait.add({ type: keyName, weight: weight, timeStamp: Date.now() });
     }
     const mapTimeToName = new Map(intervalToName.map((e) => [e.time.sec, e]));
     const _fetch = other?.fetch ?? fetch;
@@ -26,82 +29,136 @@ function LoadQuoteBase(setting, data) {
             throw "_fetch - не определен";
         if (!infoTF)
             throw "нет такого таймфрейма";
+        let lastTime;
         const nameForMap = info.exchangeName + info.symbol + infoTF.name;
         let leftTime = startMap.get(nameForMap);
         if (!leftTime) {
             await waitLimit();
-            leftTime = await setting.funcFistTime({
-                symbol: info.symbol, baseURL: base, interval: infoTF.name,
-                fetch: _fetch, intervalTF: info.tf, waitLimit
-            });
-            startMap.set(nameForMap, leftTime);
+            try {
+                leftTime = await setting.funcFistTime({ symbol: info.symbol, baseURL: base, interval: infoTF.name, fetch: _fetch, intervalTF: info.tf, waitLimit });
+                startMap.set(nameForMap, leftTime);
+            }
+            catch (e) {
+                if (data?.error == true)
+                    throw e;
+                else
+                    return [];
+            }
         }
-        const time1 = Math.max(info.time1.valueOf(), leftTime.valueOf());
-        const time2 = info.time2.valueOf();
+        const [time1, time2] = [Math.max(info.time1.valueOf(), leftTime.valueOf()), info.time2.valueOf()];
         if (time2 <= time1) {
             return [];
         }
-        const [tNewer, tOlder] = info.right ? [time2, time1] : [time2, time1];
+        const [t1, t2] = info.right ? [time1, time2] : [time2, time1];
         const arr = [];
         const interval = infoTF.time.valueOf();
+        const map = [];
         if (maxLoadBars instanceof Date) {
-            const step = maxLoadBars.valueOf();
-            arr.push(tNewer);
-            let span = tNewer - tOlder;
-            while (span > step) {
-                arr.push(arr[arr.length - 1] - step);
-                span -= step;
+            const [step1] = [
+                maxLoadBars.valueOf()
+            ];
+            arr.push(lastTime = t1);
+            let barsTime = (t1 - t2);
+            if (barsTime <= maxLoadBars.valueOf())
+                arr.push(t2);
+            else {
+                barsTime -= maxLoadBars.valueOf();
+                arr.push(lastTime = lastTime - step1);
+                for (; barsTime > 0; barsTime -= maxLoadBars.valueOf())
+                    arr.push(lastTime = lastTime - step1);
+                if (barsTime < 0)
+                    arr.push(t2);
             }
-            if (arr[arr.length - 1] > tOlder)
-                arr.push(tOlder);
         }
-        else if (typeof maxLoadBars === "number") {
-            const step = maxLoadBars * interval;
-            arr.push(tNewer);
-            let bars = (tNewer - tOlder) / interval;
-            while (bars > maxLoadBars) {
-                arr.push(arr[arr.length - 1] - step);
+        else if (typeof maxLoadBars == "number") {
+            const [step1] = [
+                maxLoadBars * interval,
+            ];
+            arr.push(lastTime = t1);
+            let bars = (t1 - t2) / interval;
+            if (bars <= maxLoadBars)
+                arr.push(t2);
+            else {
                 bars -= maxLoadBars;
+                arr.push(lastTime = lastTime - step1);
+                for (; bars > 0; bars -= maxLoadBars)
+                    arr.push(lastTime = lastTime - step1);
+                arr.push(t2);
             }
-            if (arr[arr.length - 1] > tOlder)
-                arr.push(tOlder);
         }
-        const result = [];
-        for (let i = 0; i < arr.length - 1; i++) {
-            const endTime = arr[i];
-            const startTime = arr[i + 1];
-            if (startTime >= endTime)
+        for (let i = 1; i < arr.length; i++) {
+            if (arr[i].valueOf() >= arr[i - 1].valueOf())
                 continue;
-            await waitLimit();
-            const reqData = {
-                maxLoadBars,
-                fetch: _fetch,
-                baseURL: base,
-                symbol: info.symbol,
-                interval: infoTF.name,
-                startTime: new Date(startTime),
-                endTime: new Date(endTime),
-                limit: maxLoadBars,
-                intervalTF: info.tf,
-                waitLimit
-            };
-            try {
-                let res = await setting.funcLoad(reqData);
-                if (setting.controlTimeToNumber && res.length > 0) {
-                    const t1 = getDataEl(res[0]);
-                    const t2 = getDataEl(res.at(-1));
-                    if (t1 != null && t2 != null && t1 > t2) {
+            const loader = async () => {
+                const data = {
+                    maxLoadBars: maxLoadBars,
+                    fetch: _fetch,
+                    baseURL: base,
+                    symbol: info.symbol,
+                    interval: infoTF.name,
+                    startTime: new Date(arr[i]),
+                    endTime: new Date(arr[i - 1]),
+                    limit: maxLoadBars,
+                    intervalTF: info.tf,
+                    waitLimit
+                };
+                await waitLimit();
+                let res = await setting.funcLoad(data);
+                if (setting.controlTimeToNumber && res.length) {
+                    let [t1, t2] = [
+                        getDataEl(res[0]),
+                        getDataEl(res.at(-1))
+                    ];
+                    if (t1 && t2 && t1 > t2) {
                         res = res.reverse();
                     }
                 }
-                result.unshift(...res);
+                return res;
+            };
+            map.push(loader());
+        }
+        const resulI = await Promise.allSettled(map);
+        const result = [];
+        for (let i = resulI.length - 1; i >= 0; i--) {
+            const el = resulI[i];
+            if (el.status == "fulfilled") {
+                result.push(...el.value);
             }
-            catch (e) {
-                console.error(e);
-                if (data?.error === true)
-                    throw e;
+            if (el.status == "rejected") {
+                console.error(el.reason);
+                if (data?.error == true)
+                    throw el.reason;
             }
         }
         return result;
     };
 }
+async function test() {
+    const arr = [];
+    for (let i = 0; i < 10000; i++) {
+        arr[i] = { time: Date.now() - i * wenay_common2_1.TF.H1.msec, price: i };
+    }
+    let ress = [];
+    const tt = LoadQuoteBase({
+        base: "",
+        countConnect: 2,
+        funcFistTime: async ({}) => {
+            const time = new Date(arr.at(-1).time);
+            console.log("funcFistTime: ", time);
+            return time;
+        },
+        nameKey: "cd",
+        maxLoadBars: 100,
+        time: 50,
+        intervalToName: [{ name: "1", time: wenay_common2_1.TF.H1 }],
+        funcLoad: (data) => {
+            ress.push(data.startTime);
+            ress.push(data.endTime);
+            return (async () => [{ time: 5 }])();
+        }
+    });
+    const res = await tt({ symbol: "s", time2: new Date(), tf: wenay_common2_1.TF.H1, time1: new Date(2015) });
+    ress.sort((a, b) => a.valueOf() - b.valueOf());
+    console.log(ress);
+    console.log(res);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wenay-common2",
-  "version": "1.0.42",
+  "version": "1.0.44",
   "description": "Common library",
   "strict": true,
   "main": "lib/index.js",