feat: semi

Author: sheepzh

src/database/common/indexed-storage.ts

@@ -32,19 +32,28 @@ export function req2Promise<T = unknown>(req: IDBRequest<T>): Promise<T | undefi
     })
 }
 
+export async function iterateCursor<T = unknown>(
+    req: IDBRequest<IDBCursorWithValue | null>
+): Promise<readonly T[]>
+export async function iterateCursor<T = unknown>(
+    req: IDBRequest<IDBCursorWithValue | null>,
+    processor: (cursor: IDBCursorWithValue) => void | Promise<void>
+): Promise<void>
+
 export async function iterateCursor<T = unknown>(
     req: IDBRequest<IDBCursorWithValue | null>,
     processor?: (cursor: IDBCursorWithValue) => void | Promise<void>
-): Promise<T[]> {
+): Promise<readonly T[] | void> {
+    const collectResults = !processor
     const results: T[] = []
 
     return new Promise((resolve, reject) => {
         req.onsuccess = async () => {
             const cursor = req.result
-            if (!cursor) return resolve(results)
+            if (!cursor) return resolve(collectResults ? results : undefined)
 
             try {
-                results.push(cursor.value as T)
+                collectResults && results.push(cursor.value as T)
                 await processor?.(cursor)
                 cursor.continue()
             } catch (error) {

src/database/stat-database/classic.ts

@@ -3,17 +3,12 @@ import { REMAIN_WORD_PREFIX } from '@db/common/constant'
 import { log } from '@src/common/logger'
 import { escapeRegExp } from '@util/pattern'
 import { isNotZeroResult } from '@util/stat'
-import { cvtGroupId2Host, formatDateStr, GROUP_PREFIX, increase } from './common'
-import { filterRow, processCondition } from './filter'
+import { cvtGroupId2Host, formatDateStr, GROUP_PREFIX, increase, zeroResult } from './common'
+import { filterDate, filterHost, filterNumberRange, processCondition, type ProcessedCondition } from './condition'
 import type { StatCondition, StatDatabase } from './types'
 
-function createZeroResult(): timer.core.Result {
-    return { focus: 0, time: 0 }
-}
-
-function mergeMigration(exist: timer.core.Result | undefined, another: any) {
-    exist = exist || createZeroResult()
-    return increase(exist, { focus: another.focus ?? 0, time: another.time ?? 0, run: another.run ?? 0 })
+function mergeMigration(exist: timer.core.Result | undefined, another: any): timer.core.Result {
+    return increase({ focus: another.focus ?? 0, time: another.time ?? 0, run: another.run ?? 0 }, exist ?? zeroResult())
 }
 
 /**
@@ -36,11 +31,21 @@ function migrate(exists: { [key: string]: timer.core.Result }, data: any): Recor
             if (typeof value !== "object") return
             const exist = exists[key]
             const merged = mergeMigration(exist, value)
-            merged && isNotZeroResult(merged) && (result[key] = mergeMigration(exist, value))
+            isNotZeroResult(merged) && (result[key] = merged)
         })
     return result
 }
 
+function filterRow(row: timer.core.Row, condition: ProcessedCondition): boolean {
+    const { host, date, focus, time } = row
+    const { timeStart, timeEnd, focusStart, focusEnd } = condition
+
+    return filterHost(host, condition)
+        && filterDate(date, condition)
+        && filterNumberRange(time, [timeStart, timeEnd])
+        && filterNumberRange(focus, [focusStart, focusEnd])
+}
+
 /**
  * Default implementation by `chrome.storage.local`
  */
@@ -73,10 +78,10 @@ export class ClassicStatDatabase extends BaseDatabase implements StatDatabase {
     }
 
     private async accumulateInner(key: string, item: timer.core.Result): Promise<timer.core.Result> {
-        let exist = await this.storage.getOne<timer.core.Result>(key)
-        exist = increase(exist || createZeroResult(), item)
-        await this.setByKey(key, exist)
-        return exist
+        const exist = await this.storage.getOne<timer.core.Result>(key)
+        const value = increase(item, exist)
+        await this.setByKey(key, value)
+        return value
     }
 
     /**
@@ -99,7 +104,7 @@ export class ClassicStatDatabase extends BaseDatabase implements StatDatabase {
         const afterUpdated: Record<string, timer.core.Result> = {}
         Object.entries(keys).forEach(([host, key]) => {
             const item = data[host]
-            const exist: timer.core.Result = increase(items[key] as timer.core.Result || createZeroResult(), item)
+            const exist: timer.core.Result = increase(item, items[key] as timer.core.Result)
             toUpdate[key] = afterUpdated[host] = exist
         })
         await this.storage.set(toUpdate)
@@ -127,12 +132,8 @@ export class ClassicStatDatabase extends BaseDatabase implements StatDatabase {
             }
             const { focus, time, run } = value as timer.core.Result
             const row: timer.core.Row = { host, date, focus, time }
-            if (run !== undefined) {
-                row.run = run
-            }
-            if (filterRow(row, cond)) {
-                result.push(row)
-            }
+            run !== undefined && (row.run = run)
+            filterRow(row, cond) && result.push(row)
         })
         return result
     }
@@ -159,7 +160,7 @@ export class ClassicStatDatabase extends BaseDatabase implements StatDatabase {
     async get(host: string, date: Date | string): Promise<timer.core.Result> {
         const key = generateKey(host, date)
         const exist = await this.storage.getOne<timer.core.Result>(key)
-        return exist || createZeroResult()
+        return exist ?? zeroResult()
     }
 
     /**

src/database/stat-database/condition.ts

@@ -0,0 +1,72 @@
+import { judgeVirtualFast } from "@util/pattern"
+import { formatTimeYMD } from "@util/time"
+import type { StatCondition } from './types'
+
+export type ProcessedCondition = StatCondition & {
+    useExactDate?: boolean
+    exactDateStr?: string
+    startDateStr?: string
+    endDateStr?: string
+    timeStart?: number
+    timeEnd?: number
+    focusStart?: number
+    focusEnd?: number
+}
+
+export function filterHost(host: string, condition: ProcessedCondition): boolean {
+    const { keys, virtual } = condition
+    const keyArr = typeof keys === 'string' ? [keys] : keys
+    if (!virtual && judgeVirtualFast(host)) return false
+    if (keyArr?.length && !keyArr.includes(host)) return false
+    return true
+}
+
+export function filterDate(
+    date: string,
+    { useExactDate, exactDateStr, startDateStr, endDateStr }: ProcessedCondition
+): boolean {
+    if (useExactDate) {
+        if (exactDateStr !== date) return false
+    } else {
+        if (startDateStr && startDateStr > date) return false
+        if (endDateStr && endDateStr < date) return false
+    }
+    return true
+}
+
+export function filterNumberRange(val: number, [start, end]: [start?: number, end?: number]): boolean {
+    if (start !== null && start !== undefined && start > val) return false
+    if (end !== null && end !== undefined && end < val) return false
+    return true
+}
+
+export function processCondition(condition?: StatCondition): ProcessedCondition {
+    const result: ProcessedCondition = { ...condition }
+
+    const paramDate = condition?.date
+    if (paramDate) {
+        if (paramDate instanceof Date) {
+            result.useExactDate = true
+            result.exactDateStr = formatTimeYMD(paramDate)
+        } else {
+            const [startDate, endDate] = paramDate
+            result.useExactDate = false
+            startDate && (result.startDateStr = formatTimeYMD(startDate))
+            endDate && (result.endDateStr = formatTimeYMD(endDate))
+        }
+    }
+
+    const paramTime = condition?.timeRange
+    if (paramTime) {
+        paramTime.length >= 2 && (result.timeEnd = paramTime[1])
+        paramTime.length >= 1 && (result.timeStart = paramTime[0])
+    }
+
+    const paramFocus = condition?.focusRange
+    if (paramFocus) {
+        paramFocus.length >= 2 && (result.focusEnd = paramFocus[1])
+        paramFocus.length >= 1 && (result.focusStart = paramFocus[0])
+    }
+
+    return result
+}