template-replacement 3.3.2 → 3.4.0

package/download/index.ts

@@ -1,22 +1,22 @@
-import streamClass from "./stream"
+import Stream from './stream'
 
 function download(fileName: string, blob: Blob): void {
-    const href = window.URL.createObjectURL(blob)
-    const a = document.createElement('a')
-    a.href = href
-    a.target = 'target'
-    a.download = fileName
-    document.body.appendChild(a)
-    a.click();
-    document.body.removeChild(a)
-    window.URL.revokeObjectURL(href)
+  const href = window.URL.createObjectURL(blob)
+  const a = document.createElement('a')
+  a.href = href
+  a.target = 'target'
+  a.download = fileName
+  document.body.appendChild(a)
+  a.click()
+  document.body.removeChild(a)
+  window.URL.revokeObjectURL(href)
 }
 
 export default (fileName: string, blob: Blob): void => {
-    download(fileName, blob)
+  download(fileName, blob)
 }
 
 //流式下载
-export function stream(fileName: string, size?: number): streamClass {
-    return new streamClass(fileName, size)
+export function stream(fileName: string, size?: number): Stream {
+  return new Stream(fileName, size)
 }

package/download/stream.ts

@@ -1,38 +1,39 @@
-import streamSaver from "streamsaver"
+import streamSaver from 'streamsaver'
+
+streamSaver.mitm = 'https://unpkg.com/streamsaver/mitm.html'
 
 export function setMitm(mitm: string) {
-    streamSaver.mitm = mitm
+  streamSaver.mitm = mitm
 }
 
 export default class Stream {
-    tasks: Promise<any>[] = []
-    writer: WritableStreamDefaultWriter<any>
-    fileStream: WritableStream
+  #tasks: Promise<unknown>[] = []
+  #writer: WritableStreamDefaultWriter<unknown>
+  #fileStream: WritableStream
 
-    constructor(fileName: string, size?: number) {
-        this.fileStream = streamSaver.createWriteStream(fileName, {
-            size
-        })
-        this.writer = this.fileStream.getWriter()
-    }
+  constructor(fileName: string, size?: number) {
+    this.#fileStream = streamSaver.createWriteStream(fileName, {
+      size,
+    })
+    this.#writer = this.#fileStream.getWriter()
+  }
 
-    async write(chunk: any): Promise<void> {
-        const a = this.writer.write(chunk)
-        this.tasks.push(a)
-        const res = await a
-        return res
-    }
+  write(chunk: unknown): Promise<void> {
+    const res = this.#writer.write(chunk)
+    this.#tasks.push(res)
+    return res
+  }
 
-    async close(): Promise<void> {
-        if (this.tasks.length) {
-            await Promise.all(this.tasks)
-        }
-        const res = await this.writer.close()
-        this.writer.releaseLock()
-        return res
+  async close(): Promise<void> {
+    if (this.#tasks.length) {
+      await Promise.all(this.#tasks)
     }
+    const res = await this.#writer.close()
+    this.#writer.releaseLock()
+    return res
+  }
 
-    async abort(reason?: any): Promise<void> {
-        return await this.fileStream.abort(reason)
-    }
-}
+  abort(reason?: unknown): Promise<void> {
+    return this.#fileStream.abort(reason)
+  }
+}

package/eslint.config.ts

@@ -0,0 +1,28 @@
+import { globalIgnores } from 'eslint/config'
+import oxlint from 'eslint-plugin-oxlint'
+import tseslint from '@typescript-eslint/eslint-plugin'
+import tsParser from '@typescript-eslint/parser'
+
+export default [
+  {
+    name: 'app/files-to-lint',
+    files: ['**/*.{ts,mts,tsx}'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        sourceType: 'module',
+      },
+    },
+    plugins: {
+      '@typescript-eslint': tseslint,
+    },
+    rules: {
+      ...tseslint.configs.recommended.rules,
+    },
+  },
+
+  globalIgnores(['/dist/**', '/node_modules/**']),
+
+  ...oxlint.configs['flat/recommended'], // oxlint should be the last one
+]

package/fileSystem/db/index.ts

@@ -1,37 +1,37 @@
 import indexedDBCache from './indexedDBCache'
-import FileSystem, {fileDataType} from '../interface'
+import FileSystem, { fileDataType } from '../interface'
 
 const db = new indexedDBCache()
 
 export default class DbFile implements FileSystem {
-    #name: string = ''
+  #name: string
 
-    constructor(name: string){
-        this.#name = name
-    }
+  constructor(name: string = '') {
+    this.#name = name
+  }
 
-    async write(data: fileDataType): Promise<boolean> {
-        try {
-            await db.putData<File>({
-                url: this.#name,
-                data: new File([data], this.#name),
-            })
-            return true
-        } catch (error) {
-            console.error(error)
-            return false
-        }
+  async write(data: fileDataType): Promise<boolean> {
+    try {
+      await db.putData<File>({
+        key: this.#name,
+        data: new File([data], this.#name),
+      })
+      return true
+    } catch (error) {
+      console.error(error)
+      return false
     }
+  }
 
-    async read(): Promise<File>{
-        const data = await db.getDataByKey<File>(this.#name)
-        if (data && data.data) {
-            return data.data
-        }
-        return new File([], this.#name)
+  async read(): Promise<File> {
+    const data = await db.getDataByKey<File>(this.#name)
+    if (data && data.data) {
+      return data.data
     }
+    return new File([], this.#name)
+  }
 
-    remove(): Promise<void> {
-        return db.deleteDataByKey(this.#name)
-    }
+  remove(): Promise<void> {
+    return db.deleteDataByKey(this.#name)
+  }
 }

package/fileSystem/db/indexedDBCache.ts

@@ -1,145 +1,163 @@
-
 type templateData<T> = {
-    url: string
-    data: T
+  key: string // 主键
+  data: T // 文件数据
 }
 
 export default class indexedDBCache {
-    _initFinishCallBackFuns?: Function[] = [] //初始化完成回调
-    _isInitFinish: boolean = false  //是否初始化完成
+  private _initFinishCallBackFuns?: ((value: void) => void)[] = [] //初始化完成回调
+  #isInitFinish: boolean = false //是否初始化完成
 
-    _db?: IDBDatabase //数据库
-    _dbName: string = 'template_replacement' //数据库名
-    _dbversion: number  = 1 //数据库版本
-    _cacheTableName: string = 'templates' //表名
-    _tableMap: any = {} //表配置
+  private _db?: IDBDatabase //数据库
+  #dbName: string = 'template_replacement_db' //数据库名
+  #dbversion: number = 1 //数据库版本
+  #cacheTableName: string = 'template_files' //表名
 
+  private _init: Promise<unknown> | undefined
 
-    // 构造函数
-    constructor() {
-        this.initDB()
-    }
+  // 构造函数
+  constructor() {
+    this.#initDB()
+  }
 
-    initDB(): Promise<any> {
-        return new Promise((resolve, reject) => {
-            const request = indexedDB.open(this._dbName, this._dbversion) // 打开数据库
-            // 数据库初始化成功
-            request.onsuccess = (event) => {
-                this._db = request.result
-                this._isInitFinish = true
-                if (this._initFinishCallBackFuns) {
-                    try {
-                        for (const fun of this._initFinishCallBackFuns) {
-                            fun()
-                        }
-                    } catch (error) {
-                    }
-                    this._initFinishCallBackFuns = undefined
-                }
-                resolve(event)
-            }
-            // 数据库初始化失败
-            request.onerror = (event) => {
-                console.error(event)
-                reject(event)
-            }
-            // 数据库初次创建或更新时会触发
-            request.onupgradeneeded = (event) => {
-                let db = request.result
-                if (!db.objectStoreNames.contains(this._cacheTableName)) {
-                    db.createObjectStore(this._cacheTableName, {
-                        keyPath: 'url', // 设置主键
-                    })
-                }
-                resolve(event)
-            }
-        })
+  #initDB(): Promise<unknown> {
+    if (this._init) {
+      return this._init
     }
-
-    async awaitInit(): Promise<void> {
-        if(this._isInitFinish || !this._initFinishCallBackFuns) {
-            return
+    this._init = new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.#dbName, this.#dbversion) // 打开数据库
+      // 数据库初始化成功
+      request.onsuccess = (event) => {
+        this._db = request.result
+        this.#isInitFinish = true
+        if (this._initFinishCallBackFuns) {
+          try {
+            for (const fun of this._initFinishCallBackFuns) {
+              fun()
+            }
+          } catch (error) { }
+          this._initFinishCallBackFuns = undefined
         }
-        await new Promise((resolve, reject) => {
-            this._initFinishCallBackFuns?.push(resolve)
-        })
-    }
+        resolve(event)
+      }
+      // 数据库初始化失败
+      request.onerror = (event) => {
+        console.error(event)
+        reject(event)
+      }
+      // 数据库初次创建或更新时会触发
+      request.onupgradeneeded = (event) => {
+        let db = request.result
+        if (!db.objectStoreNames.contains(this.#cacheTableName)) {
+          db.createObjectStore(this.#cacheTableName, {
+            keyPath: 'key', // 设置主键
+          })
+        }
+        resolve(event)
+      }
+    })
 
-    closeDB(): void {
-        this._db?.close()
-    }
+    return this._init
+  }
 
-    async store(mode?: IDBTransactionMode): Promise<IDBObjectStore> {
-        await this.awaitInit()
-        const db = this._db as IDBDatabase
-        const transaction = db.transaction(this._cacheTableName, mode)
-        return transaction.objectStore(this._cacheTableName)
+  async awaitInit(): Promise<void> {
+    if (this.#isInitFinish || !this._initFinishCallBackFuns) {
+      return
     }
+    await new Promise((resolve, reject) => {
+      this._initFinishCallBackFuns?.push(resolve)
+    })
+  }
 
-    /**
-     * @description : 更新数据
-     * @param        {Object} params 添加到数据库中的数据 { url: 文件地址, data: 文件blob }
-     * @return       {*}
-     */
-    putData<T>(params: templateData<T>): Promise<any> {
-        return new Promise(async (resolve, reject) => {
-            const response = (await this.store('readwrite')).put(params)
-            // 操作成功
-            response.onsuccess = (event) => {
-                resolve(event)
-            }
-            // 操作失败
-            response.onerror = (event) => {
-                reject(event)
-            }
-        })
-    }
+  closeDB(): void {
+    this._db?.close()
+  }
 
-    // 通过主键读取数据
-    getDataByKey<T>(key: string): Promise<templateData<T>> {
-        return new Promise(async (resolve, reject) => {
-            // 通过主键读取数据
-            const request = (await this.store()).get(key)
-            // 操作成功
-            request.onsuccess = () => {
-                resolve(request.result)
-            }
-            // 操作失败
-            request.onerror = (event) => {
-                reject(event)
-            }
+  async store(mode?: IDBTransactionMode): Promise<IDBObjectStore> {
+    await this.awaitInit()
+    const db = this._db as IDBDatabase
+    const transaction = db.transaction(this.#cacheTableName, mode)
+    return transaction.objectStore(this.#cacheTableName)
+  }
+
+  /**
+   * @description : 更新数据
+   * @param        {templateData} params 添加到数据库中的数据 { key: 文件key, data: 文件blob }
+   * @return       {*}
+   */
+  putData<T>(params: templateData<T>): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      this.store('readwrite')
+        .then((store) => {
+          const response = store.put(params)
+          // 操作成功
+          response.onsuccess = (event) => {
+            resolve(event)
+          }
+          // 操作失败
+          response.onerror = (event) => {
+            reject(event)
+          }
         })
-    }
+        .catch(reject)
+    })
+  }
 
-    // 通过主键移除数据
-    deleteDataByKey<T>(key: string): Promise<void> {
-        return new Promise(async (resolve, reject) => {
-            // 通过主键读取数据
-            const request = (await this.store()).delete(key)
-            // 操作成功
-            request.onsuccess = () => {
-                resolve()
-            }
-            // 操作失败
-            request.onerror = (event) => {
-                reject(event)
-            }
+  // 通过主键读取数据
+  getDataByKey<T>(key: string): Promise<templateData<T>> {
+    return new Promise((resolve, reject) => {
+      this.store()
+        .then((store) => {
+          // 通过主键读取数据
+          const request = store.get(key)
+          // 操作成功
+          request.onsuccess = () => {
+            resolve(request.result)
+          }
+          // 操作失败
+          request.onerror = (event) => {
+            reject(event)
+          }
         })
-    }
+        .catch(reject)
+    })
+  }
 
-    // 清空数据库数据
-    clearDB(): Promise<any> {
-        return new Promise(async (resolve, reject) => {
-            const response = (await this.store('readwrite')).clear()
-            // 操作成功
-            response.onsuccess = (event) => {
-                resolve(event)
-            }
-            // 操作失败
-            response.onerror = (event) => {
-                reject(event)
-            }
+  // 通过主键移除数据
+  deleteDataByKey(key: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.store()
+        .then((store) => {
+          // 通过主键读取数据
+          const request = store.delete(key)
+          // 操作成功
+          request.onsuccess = () => {
+            resolve(request.result)
+          }
+          // 操作失败
+          request.onerror = (event) => {
+            reject(event)
+          }
         })
-    }
+        .catch(reject)
+    })
+  }
 
-}
+  // 清空数据库数据
+  clearDB(): Promise<unknown> {
+    return new Promise((resolve, reject) => {
+      this.store('readwrite')
+        .then((store) => {
+          const response = store.clear()
+          // 操作成功
+          response.onsuccess = (event) => {
+            resolve(event)
+          }
+          // 操作失败
+          response.onerror = (event) => {
+            reject(event)
+          }
+        })
+        .catch(reject)
+    })
+  }
+}

package/fileSystem/index.ts

@@ -2,12 +2,9 @@ import FileSystem from './interface'
 import OpfsFile from './opfs'
 import DbFile from './db'
 
-export default (name: string): FileSystem =>  {
-    if (navigator?.storage?.getDirectory) {
-        return new OpfsFile(name)
-    }
-    return new DbFile(name)
+export default (name: string): FileSystem => {
+  if ('storage' in navigator && typeof navigator.storage.getDirectory === 'function') {
+    return new OpfsFile(name)
+  }
+  return new DbFile(name)
 }
-
-
-

package/fileSystem/interface.ts

@@ -1,8 +1,7 @@
-
 export type fileDataType = BufferSource | Blob | string
 
 export default interface FileSystem {
-    write(data: fileDataType): Promise<boolean>
-    read(): Promise<File>
-    remove(): Promise<void>
-}
+  write(data: fileDataType): Promise<boolean>
+  read(): Promise<File>
+  remove(): Promise<void>
+}

package/fileSystem/opfs/index.ts

@@ -1,48 +1,52 @@
-import FileSystem, {fileDataType} from '../interface'
+import FileSystem, { fileDataType } from '../interface'
 
 let opfsRoot: FileSystemDirectoryHandle | undefined = undefined
 
 async function getOpfsRoot(): Promise<FileSystemDirectoryHandle> {
-    if (!opfsRoot) {
-        opfsRoot = await (await navigator.storage.getDirectory()).getDirectoryHandle('template_replacement', {
-            create: true,
-        })
-    }
-    return opfsRoot
+  if (!opfsRoot) {
+    opfsRoot = await (
+      await navigator.storage.getDirectory()
+    ).getDirectoryHandle('template_replacement', {
+      create: true,
+    })
+  }
+  return opfsRoot
 }
 
 export default class OpfsFile implements FileSystem {
-    #name: string = ''
-    #handle: FileSystemFileHandle | undefined
-
-    constructor(name: string){
-        this.#name = name
+  #name: string = ''
+  private _handle: FileSystemFileHandle | undefined
+
+  constructor(name: string) {
+    this.#name = name
+  }
+
+  async getHandle(): Promise<FileSystemFileHandle> {
+    if (!this._handle) {
+      this._handle = await (
+        await getOpfsRoot()
+      ).getFileHandle(this.#name, { create: true })
     }
-
-    async getHandle(): Promise<FileSystemFileHandle> {
-        if (!this.#handle) {
-            this.#handle = await (await getOpfsRoot()).getFileHandle(this.#name, { create: true })
-        }
-        return this.#handle
+    return this._handle
+  }
+
+  async write(data: fileDataType): Promise<boolean> {
+    try {
+      const writable = await (await this.getHandle()).createWritable()
+      await writable.write(data)
+      await writable.close()
+      return true
+    } catch (error) {
+      console.error(error)
+      return false
     }
+  }
 
-    async write(data: fileDataType): Promise<boolean> {
-        try {
-            const writable = await (await this.getHandle()).createWritable()
-            await writable.write(data)
-            await writable.close()
-            return true
-        } catch (error) {
-            console.error(error)
-            return false
-        }
-    }
+  async read(): Promise<File> {
+    return (await this.getHandle()).getFile()
+  }
 
-    async read(): Promise<File>{
-        return (await this.getHandle()).getFile()
-    }
-
-    async remove(): Promise<void> {
-        return (await getOpfsRoot()).removeEntry(this.#name)
-    }
+  async remove(): Promise<void> {
+    return (await getOpfsRoot()).removeEntry(this.#name)
+  }
 }