feat: semi

Author: sheepzh

src/database/backup-database.ts

@@ -36,10 +36,6 @@ class BackupDatabase extends BaseDatabase {
     async updateCache(type: timer.backup.Type, newVal: unknown): Promise<void> {
         return this.storage.put(cacheKeyOf(type), newVal as Object)
     }
-
-    async importData(_data: any): Promise<void> {
-        // Do nothing
-    }
 }
 
 const backupDatabase = new BackupDatabase()

src/database/common/base-database.ts

@@ -24,12 +24,4 @@ export default abstract class BaseDatabase {
     protected setByKey(key: string, val: any): Promise<void> {
         return this.storage.put(key, val)
     }
-
-    /**
-     * Import data
-     *
-     * @since 0.2.5
-     * @param data backup data
-     */
-    abstract importData(data: any): Promise<void>
 }

src/database/common/migratable.ts

@@ -0,0 +1,20 @@
+import { createObjectGuard, isInt, isString } from 'typescript-guard'
+
+export const isExportData = createObjectGuard<Pick<timer.backup.ExportData, '__meta__'>>({
+    __meta__: createObjectGuard({
+        version: isString,
+        ts: isInt,
+    }),
+})
+
+export const isLegacyVersion = (data: unknown): data is timer.backup.ExportData => {
+    if (!isExportData(data)) return false
+
+    const version = data.__meta__.version
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)/)
+    if (!match) return true
+
+    const major = parseInt(match[1])
+
+    return major < 4
+}

src/database/limit-database.ts

@@ -8,6 +8,7 @@
 import { formatTimeYMD, MILL_PER_DAY } from "@util/time"
 import BaseDatabase from "./common/base-database"
 import { REMAIN_WORD_PREFIX } from "./common/constant"
+import { BrowserMigratable } from './types'
 
 const KEY = REMAIN_WORD_PREFIX + 'LIMIT'
 
@@ -139,7 +140,9 @@ function migrate(exist: Items, toMigrate: any) {
  *
  * @since 0.2.2
  */
-class LimitDatabase extends BaseDatabase {
+class LimitDatabase extends BaseDatabase implements BrowserMigratable<'__limit__'> {
+    namespace: '__limit__' = '__limit__'
+
     private async getItems(): Promise<Items> {
         let items = await this.storage.getOne<Items>(KEY) || {}
         return items
@@ -259,13 +262,18 @@ class LimitDatabase extends BaseDatabase {
         await this.update(items)
     }
 
-    async importData(data: any): Promise<void> {
-        let toImport = data[KEY] as Items
-        // Not import
-        if (typeof toImport !== 'object') return
-        const exists: Items = await this.getItems()
-        migrate(exists, toImport)
-        this.setByKey(KEY, exists)
+    async importData(data: unknown): Promise<void> {
+        // let toImport = data[KEY] as Items
+        // // Not import
+        // if (typeof toImport !== 'object') return
+        // const exists: Items = await this.getItems()
+        // migrate(exists, toImport)
+        // this.setByKey(KEY, exists)
+        throw new Error('Method not implemented.')
+    }
+
+    exportData(): Promise<timer.limit.Rule[]> {
+        throw new Error('Method not implemented.')
     }
 }
 

src/database/merge-rule-database.ts

@@ -7,6 +7,7 @@
 
 import BaseDatabase from "./common/base-database"
 import { REMAIN_WORD_PREFIX } from "./common/constant"
+import type { BrowserMigratable } from './types'
 
 const DB_KEY = REMAIN_WORD_PREFIX + 'MERGE_RULES'
 
@@ -17,7 +18,8 @@ type MergeRuleSet = { [key: string]: string | number }
  *
  * @since 0.1.2
  */
-class MergeRuleDatabase extends BaseDatabase {
+class MergeRuleDatabase extends BaseDatabase implements BrowserMigratable<'__merge__'> {
+    namespace: '__merge__' = '__merge__'
 
     async refresh(): Promise<MergeRuleSet> {
         const result = await this.storage.getOne<MergeRuleSet>(DB_KEY)
@@ -50,17 +52,22 @@ class MergeRuleDatabase extends BaseDatabase {
         await this.update(set)
     }
 
-    async importData(data: any): Promise<void> {
-        const toMigrate = data?.[DB_KEY]
-        if (!toMigrate) return
-        const exist = await this.refresh()
-        const valueTypes = ['string', 'number']
-        Object.entries(toMigrate as MergeRuleSet)
-            .filter(([_key, value]) => valueTypes.includes(typeof value))
-            // Not rewrite
-            .filter(([key]) => !exist[key])
-            .forEach(([key, value]) => exist[key] = value)
-        this.update(exist)
+    async importData(data: unknown): Promise<void> {
+        // const toMigrate = data?.[DB_KEY]
+        // if (!toMigrate) return
+        // const exist = await this.refresh()
+        // const valueTypes = ['string', 'number']
+        // Object.entries(toMigrate as MergeRuleSet)
+        //     .filter(([_key, value]) => valueTypes.includes(typeof value))
+        //     // Not rewrite
+        //     .filter(([key]) => !exist[key])
+        //     .forEach(([key, value]) => exist[key] = value)
+        // this.update(exist)
+        throw new Error('Method not implemented.')
+    }
+
+    exportData(): Promise<timer.merge.Rule[]> {
+        throw new Error('Method not implemented.')
     }
 }
 

src/database/meta-database.ts

@@ -17,21 +17,6 @@ class MetaDatabase extends BaseDatabase {
         return meta || {}
     }
 
-    async importData(data: any): Promise<void> {
-        const meta: timer.ExtensionMeta = data[META_KEY] as timer.ExtensionMeta
-        if (!meta) return
-
-        const existMeta = await this.getMeta()
-        const { popupCounter = {}, appCounter = {} } = existMeta
-        popupCounter._total = (popupCounter._total ?? 0) + (popupCounter._total ?? 0)
-        if (meta.appCounter) {
-            Object.entries(meta.appCounter).forEach(([routePath, count]) => {
-                appCounter[routePath] = (appCounter[routePath] ?? 0) + count
-            })
-        }
-        await this.update({ ...existMeta, popupCounter, appCounter })
-    }
-
     async update(existMeta: timer.ExtensionMeta): Promise<void> {
         await this.storage.put(META_KEY, existMeta)
     }

src/database/option-database.ts

@@ -17,14 +17,6 @@ const DB_KEY = REMAIN_WORD_PREFIX + 'OPTION'
  * @since 0.3.0
  */
 class OptionDatabase extends BaseDatabase {
-    async importData(data: any): Promise<void> {
-        const newVal = data[DB_KEY]
-        const exist = await this.getOption()
-        if (exist) {
-            Object.entries(exist).forEach(([key, value]) => (exist as any)[key] = value)
-        }
-        await this.setOption(newVal)
-    }
 
     async getOption(): Promise<timer.option.AllOption> {
         const option = await this.storage.getOne<timer.option.AllOption>(DB_KEY)

src/database/period-database.ts

@@ -102,17 +102,6 @@ class PeriodDatabase extends BaseDatabase {
         const keys = dates.map(generateKey)
         await this.storage.remove(keys)
     }
-
-    async importData(data: any): Promise<void> {
-        if (typeof data !== "object") return
-        const items = await this.storage.get()
-        const keyReg = new RegExp(`^${KEY_PREFIX}20\\d{2}[01]\\d[0-3]\\d$`)
-        const toSave: Record<string, _Value> = {}
-        Object.entries(data)
-            .filter(([key]) => keyReg.test(key))
-            .forEach(([key, value]) => toSave[key] = migrate(items[key], value as _Value))
-        this.storage.set(toSave)
-    }
 }
 
 type _Value = { [key: string]: number }

src/database/site-cate-database.ts

@@ -7,6 +7,7 @@
 
 import BaseDatabase from "./common/base-database"
 import { REMAIN_WORD_PREFIX } from "./common/constant"
+import { BrowserMigratable } from './types'
 
 const KEY = REMAIN_WORD_PREFIX + 'CATE'
 
@@ -38,7 +39,9 @@ function migrate(exist: Items, toMigrate: any) {
  *
  * @since 3.0.0
  */
-class SiteCateDatabase extends BaseDatabase {
+class SiteCateDatabase extends BaseDatabase implements BrowserMigratable<'__cate__'> {
+    namespace: '__cate__' = '__cate__'
+
     private async getItems(): Promise<Items> {
         return await this.storage.getOne<Items>(KEY) || {}
     }
@@ -86,14 +89,6 @@ class SiteCateDatabase extends BaseDatabase {
         await this.saveItems(items)
     }
 
-    async importData(data: any): Promise<void> {
-        let toImport = data[KEY] as Items
-        // Not import
-        if (typeof toImport !== 'object') return
-        const exists: Items = await this.getItems()
-        migrate(exists, toImport)
-        this.setByKey(KEY, exists)
-    }
 
     async delete(id: number): Promise<void> {
         const items = await this.getItems()
@@ -102,6 +97,20 @@ class SiteCateDatabase extends BaseDatabase {
         delete items[id]
         await this.saveItems(items)
     }
+
+    async importData(data: unknown): Promise<void> {
+        // let toImport = data[KEY] as Items
+        // // Not import
+        // if (typeof toImport !== 'object') return
+        // const exists: Items = await this.getItems()
+        // migrate(exists, toImport)
+        // this.setByKey(KEY, exists)
+        throw new Error('Method not implemented.')
+    }
+
+    exportData(): Promise<timer.site.Cate[]> {
+        throw new Error('Method not implemented.')
+    }
 }
 
 const siteCateDatabase = new SiteCateDatabase()

src/database/site-database.ts

@@ -179,9 +179,6 @@ async function existBatch(this: SiteDatabase, siteKeys: timer.site.SiteKey[]): P
     return Object.entries(items).map(([key]) => cvt2SiteKey(key))
 }
 
-async function importData(this: SiteDatabase, _data: any) {
-    throw new Error("Method not implemented.")
-}
 
 ////////////////////////////////////////////////////////////////////////////
 /////////////////////////                          /////////////////////////
@@ -197,7 +194,6 @@ class SiteDatabase extends BaseDatabase {
     remove = remove
     exist = exist
     existBatch = existBatch
-    importData = importData
 
     /**
      * Add listener to listen changes