opt: indicator calc

Author: liihuu

src/Store.ts

@@ -20,7 +20,7 @@ import type { KLineData, VisibleRangeData } from './common/Data'
 import type VisibleRange from './common/VisibleRange'
 import type Coordinate from './common/Coordinate'
 import { getDefaultVisibleRange } from './common/VisibleRange'
-import TaskScheduler, { generateTaskId } from './common/TaskScheduler'
+import TaskScheduler from './common/TaskScheduler'
 import type Crosshair from './common/Crosshair'
 import type BarSpace from './common/BarSpace'
 import type { Period } from './common/Period'
@@ -308,7 +308,7 @@ export default class StoreImp implements Store {
   /**
    * Task scheduler
    */
-  private readonly _taskScheduler = new TaskScheduler()
+  private readonly _taskScheduler: TaskScheduler
 
   /**
    * Overlay
@@ -376,6 +376,13 @@ export default class StoreImp implements Store {
     if (isValid(decimalFold)) {
       this.setDecimalFold(decimalFold)
     }
+    this._taskScheduler = new TaskScheduler(() => {
+      this._chart.layout({
+        measureWidth: true,
+        update: true,
+        buildYAxisTick: true
+      })
+    })
   }
 
   setStyles (value: string | DeepPartial<Styles>): void {
@@ -577,14 +584,13 @@ export default class StoreImp implements Store {
         adjustFlag = true
       }
     }
-    if (success) {
-      if (adjustFlag) {
-        this._adjustVisibleRange()
-        this.setCrosshair(this._crosshair, { notInvalidate: true })
-        const filterIndicators = this.getIndicatorsByFilter({})
-        filterIndicators.forEach(indicator => {
-          this._addIndicatorCalcTask(indicator, type)
-        })
+    if (success && adjustFlag) {
+      this._adjustVisibleRange()
+      this.setCrosshair(this._crosshair, { notInvalidate: true })
+      const filterIndicators = this.getIndicatorsByFilter({})
+      if (filterIndicators.length > 0) {
+        this._calcIndicator(filterIndicators)
+      } else {
         this._chart.layout({
           measureWidth: true,
           update: true,
@@ -699,7 +705,7 @@ export default class StoreImp implements Store {
         symbol: this._symbol,
         period: this._period,
         timestamp: null,
-        callback: (data: KLineData[], more?: boolean) => {
+        callback: (data: KLineData[], more?: DataLoadMore) => {
           this._loading = false
           this._addData(data, type, more)
           if (type === 'init') {
@@ -1123,38 +1129,16 @@ export default class StoreImp implements Store {
     }
   }
 
-  private _addIndicatorCalcTask (indicator: IndicatorImp, dataLoadType: DataLoadType): void {
-    indicator.onDataStateChange?.({
-      state: 'loading',
-      type: dataLoadType,
-      indicator
-    })
-    void this._taskScheduler.add<boolean>({
-      id: generateTaskId(indicator.id),
-      handler: async () => await indicator.calcImp(this._dataList).then(result => result)
-    }).then(result => {
-      if (result) {
-        this._chart.layout({
-          measureWidth: true,
-          update: true,
-          buildYAxisTick: true,
-          cacheYAxisWidth: dataLoadType !== 'init'
-        })
-        indicator.onDataStateChange?.({
-          state: 'ready',
-          type: dataLoadType,
-          indicator
-        })
-      }
-    }).catch((e: unknown) => {
-      if (e !== 'canceled') {
-        indicator.onDataStateChange?.({
-          state: 'error',
-          type: dataLoadType,
-          indicator
-        })
-      }
-    })
+  private _calcIndicator (data: IndicatorImp | IndicatorImp[]): void {
+    let indicators: IndicatorImp[] = []
+    indicators = indicators.concat(data)
+    if (indicators.length > 0) {
+      const tasks: Record<string, Promise<unknown>> = {}
+      indicators.forEach(indicator => {
+        tasks[indicator.id] = indicator.calcImp(this._dataList)
+      })
+      this._taskScheduler.add(tasks)
+    }
   }
 
   addIndicator (create: PickRequired<IndicatorCreate, 'id' | 'name'>, paneId: string, isStack: boolean): boolean {
@@ -1177,7 +1161,7 @@ export default class StoreImp implements Store {
     paneIndicators.push(indicator)
     this._indicators.set(paneId, paneIndicators)
     this._sortIndicators(paneId)
-    this._addIndicatorCalcTask(indicator, 'init')
+    this._calcIndicator(indicator)
     return true
   }
 
@@ -1211,7 +1195,6 @@ export default class StoreImp implements Store {
       const paneIndicators = this.getIndicatorsByPaneId(indicator.paneId)
       const index = paneIndicators.findIndex(ins => ins.id === indicator.id)
       if (index > -1) {
-        this._taskScheduler.remove(generateTaskId(indicator.id))
         paneIndicators.splice(index, 1)
         removed = true
       }
@@ -1269,7 +1252,7 @@ export default class StoreImp implements Store {
         sortFlag = true
       }
       if (calc) {
-        this._addIndicatorCalcTask(indicator, 'update')
+        this._calcIndicator(indicator)
       } else {
         if (draw) {
           updateFlag = true

src/common/DataLoader.ts

@@ -20,8 +20,8 @@ import type { Period } from './Period'
 export type DataLoadType = 'init' | 'forward' | 'backward' | 'update'
 
 export type DataLoadMore = boolean | {
-  backward: boolean
-  forward: boolean
+  backward?: boolean
+  forward?: boolean
 }
 
 export interface DataLoaderGetBarsParams {

src/common/TaskScheduler.ts

@@ -12,101 +12,53 @@
  * limitations under the License.
  */
 
+import type Nullable from './Nullable'
 import { isValid } from './utils/typeChecks'
 
-export function generateTaskId (...params: string[]): string {
-  return params.join('_')
-}
-
-interface Task<T> {
-  id: string
-  handler: () => Promise<T>
-}
-
-type TaskRun = () => void
-
-export type TaskRejectReason = 'canceled' | 'failed'
-
-interface TaskWrapper {
-  run: TaskRun
-  reject: (reason?: TaskRejectReason) => void
-}
-
-const DEFAULT_TASK_LIMIT = 5
+type TaskFinishedCallback = () => void
 
 export default class TaskScheduler {
-  private readonly _limit: number
-  private _running = 0
-  private _queue: TaskRun[] = []
-  private readonly _taskMap = new Map<string, TaskWrapper>()
+  private _holdingTasks: Nullable<Record<string, Promise<unknown>>> = null
 
-  constructor (limit?: number) {
-    this._limit = limit ?? DEFAULT_TASK_LIMIT
-  }
+  private _running = false
 
-  async add<T> (task: Task<T>): Promise<T> {
-    return await new Promise<T>((resolve, reject) => {
-      const { id, handler } = task
-      const run: TaskRun = () => {
-        this._running++
-        handler().then(
-          result => {
-            resolve(result)
-          }
-        ).catch(
-          () => {
-            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors, prefer-promise-reject-errors -- ignore
-            reject('failed')
-          }
-        ).finally(() => {
-          this._running--
-          this._taskMap.delete(id)
-          this._next()
-        })
-      }
+  private readonly _callback: Nullable<TaskFinishedCallback>
 
-      const oldTaskWrapper = this._taskMap.get(id)
-      if (isValid(oldTaskWrapper)) {
-        oldTaskWrapper.reject('canceled')
+  constructor (callback: TaskFinishedCallback) {
+    this._callback = callback
+  }
 
-        const index = this._queue.indexOf(oldTaskWrapper.run)
-        if (index > -1) {
-          this._queue.splice(index, 1)
+  add (tasks: Record<string, Promise<unknown>>): void {
+    if (!this._running) {
+      void this._runTask(tasks)
+    } else {
+      if (isValid(this._holdingTasks)) {
+        this._holdingTasks = {
+          ...this._holdingTasks,
+          ...tasks
         }
+      } else {
+        this._holdingTasks = tasks
       }
-
-      this._taskMap.set(id, { run, reject })
-      this._queue.push(run)
-      this._next()
-    })
-  }
-
-  private _next (): void {
-    while (this._running < this._limit && this._queue.length > 0) {
-      const fn = this._queue.shift()
-      fn?.()
     }
   }
 
-  remove (id: string): void {
-    const taskWrapper = this._taskMap.get(id)
-    if (isValid(taskWrapper)) {
-      this._taskMap.delete(id)
-
-      const index = this._queue.indexOf(taskWrapper.run)
-      if (index > -1) {
-        this._queue.splice(index, 1)
+  private async _runTask (tasks: Record<string, Promise<unknown>>): Promise<void> {
+    this._running = true
+    try {
+      await Promise.all(Object.values(tasks))
+    } finally {
+      this._running = false
+      this._callback?.()
+      if (isValid(this._holdingTasks)) {
+        const next = this._holdingTasks
+        void this._runTask(next)
+        this._holdingTasks = null
       }
-
-      taskWrapper.reject('canceled')
     }
   }
 
   clear (): void {
-    for (const [, { reject }] of this._taskMap) {
-      reject('canceled')
-    }
-    this._taskMap.clear()
-    this._queue = []
+    this._holdingTasks = null
   }
 }

src/component/Indicator.ts

@@ -111,7 +111,6 @@ export interface IndicatorOnDataStateChangeParams<D> {
 
   indicator: Indicator<D>
 }
-export type IndicatorOnDataStateChangeCallback<D> = (params: IndicatorOnDataStateChangeParams<D>) => void
 
 export interface Indicator<D = unknown, C = unknown, E = unknown> {
   /**
@@ -219,11 +218,6 @@ export interface Indicator<D = unknown, C = unknown, E = unknown> {
    */
   draw: Nullable<IndicatorDrawCallback<D, C, E>>
 
-  /**
-   * Data state change
-   */
-  onDataStateChange: Nullable<IndicatorOnDataStateChangeCallback<D>>
-
   /**
    * Calculation result
    */
@@ -352,8 +346,6 @@ export default class IndicatorImp<D = unknown, C = unknown, E = unknown> impleme
   createTooltipDataSource: Nullable<IndicatorCreateTooltipDataSourceCallback<D>> = null
   draw: Nullable<IndicatorDrawCallback<D, C, E>> = null
 
-  onDataStateChange: Nullable<IndicatorOnDataStateChangeCallback<D>> = null
-
   result: D[] = []
 
   private _prevIndicator: Indicator<D, C, E>