template-replacement 3.3.3 → 3.4.0

package/helper/index.ts

@@ -2,176 +2,187 @@ import urlDownloadTask from '../task/urlDownloadTask'
 import { fileTypeFromBuffer } from 'file-type'
 
 export function urlSuffix(url: string): string {
-    url = url.split('?')[0]
-    if (url.lastIndexOf('.') === -1) {
-        return ''
-    }
-    return url.substring(url.lastIndexOf('.') + 1)
+  url = url.split('?')[0]
+  if (url.lastIndexOf('.') === -1) {
+    return ''
+  }
+  return url.substring(url.lastIndexOf('.') + 1)
 }
 
-export function getFileNameFromUrl(url: string): string  {
-    url = url.split('?')[0]
-    const pathParts = url.split('/')
-    return pathParts[pathParts.length - 1]
+export function getFileNameFromUrl(url: string): string {
+  url = url.split('?')[0]
+  const pathParts = url.split('/')
+  return pathParts[pathParts.length - 1]
 }
 
-export const enum fileTypes  {
-    word = 'word',
-    excel = 'excel',
-    unknown = 'unknown',
+export const enum fileTypes {
+  word = 'word',
+  excel = 'excel',
+  unknown = 'unknown',
 }
 
 export const officeMIMETypes: Record<string, fileTypes> = {
-    //docx
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': fileTypes.word,
-    //dotx
-    'application/vnd.openxmlformats-officedocument.wordprocessingml.template': fileTypes.word,
-    //xlsx
-    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': fileTypes.excel,
+  //docx
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.document': fileTypes.word,
+  //dotx
+  'application/vnd.openxmlformats-officedocument.wordprocessingml.template': fileTypes.word,
+  //xlsx
+  'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': fileTypes.excel,
 }
 
 export const officeSuffixTypes: Record<string, fileTypes> = {
-    'docx': fileTypes.word,
-    'dotx': fileTypes.word,
-    'xlsx': fileTypes.excel,
+  docx: fileTypes.word,
+  dotx: fileTypes.word,
+  xlsx: fileTypes.excel,
 }
 
 export function fileType(file: File): fileTypes {
-    return officeMIMETypes[file.type] ?? fileTypes.unknown
+  return officeMIMETypes[file.type] ?? fileTypes.unknown
 }
 
 export function fileTypeByName(name: string): fileTypes {
-    return officeSuffixTypes[urlSuffix(name)] ?? fileTypes.unknown
+  return officeSuffixTypes[urlSuffix(name)] ?? fileTypes.unknown
 }
 
-export async function fileTypeByBuffer(buffer: Uint8Array|ArrayBuffer|Blob): Promise<fileTypes> {
-    if (buffer instanceof Blob) {
-        if (buffer.type && officeMIMETypes[buffer.type]) {
-            return officeMIMETypes[buffer.type]
-        }
-        buffer = await buffer.arrayBuffer()
+export async function fileTypeByBuffer(
+  buffer: Uint8Array | ArrayBuffer | Blob,
+): Promise<fileTypes> {
+  if (buffer instanceof Blob) {
+    if (buffer.type && officeMIMETypes[buffer.type]) {
+      return officeMIMETypes[buffer.type]
     }
-    const type = await fileTypeFromBuffer(buffer)
+    buffer = await buffer.arrayBuffer()
+  }
+  const type = await fileTypeFromBuffer(buffer)
 
-    if (type && officeMIMETypes[type.mime]) {
-        return officeMIMETypes[type.mime]
-    }
-    return fileTypes.unknown
+  if (type && officeMIMETypes[type.mime]) {
+    return officeMIMETypes[type.mime]
+  }
+  return fileTypes.unknown
 }
 
 export function generateId(): string {
-    return crypto.randomUUID()
+  return crypto.randomUUID()
 }
 
 export type fileArrayBufferData = {
-    name: string
-    buffer: ArrayBuffer
-}
-
-export function filesReaderArrayBuffer(files: File[]): Promise<fileArrayBufferData[]> {
-    const awaits: Promise<fileArrayBufferData>[] = []
-    for (const file of files) {
-        awaits.push(new Promise((resolve, reject) => {
-            try {
-                file.arrayBuffer().then(buffer => {
-                    resolve({
-                        name: file.name,
-                        buffer
-                    })
-                }).catch(reject)
-            } catch (error) {
-                reject(error)
-            }
-        }))
-    }
-    return Promise.all(awaits)
+  name: string
+  buffer: ArrayBuffer
+}
+
+export function filesReaderArrayBuffer(
+  files: File[],
+): Promise<fileArrayBufferData[]> {
+  const awaits: Promise<fileArrayBufferData>[] = []
+  for (const file of files) {
+    awaits.push(
+      new Promise((resolve, reject) => {
+        try {
+          file
+            .arrayBuffer()
+            .then((buffer) => {
+              resolve({
+                name: file.name,
+                buffer,
+              })
+            })
+            .catch(reject)
+        } catch (error) {
+          reject(error)
+        }
+      }),
+    )
+  }
+  return Promise.all(awaits)
 }
 
-
 export type fileBase64Data = {
-    name: string
-    base64: string
+  name: string
+  base64: string
 }
 
 export function filesReaderBase64(files: File[]): Promise<fileBase64Data[]> {
-    const awaits: Promise<fileBase64Data>[] = []
-    for (const file of files) {
-        awaits.push(new Promise((resolve, reject) => {
-            const fileReader = new FileReader()
-            fileReader.onload = function(e) {
-                let base64 = e.target?.result as string
-                if (!base64) {
-                    resolve({
-                        name: file.name,
-                        base64: ''
-                    })
-                    return
-                }
-                const index = base64.indexOf(",")
-                if (index != -1) {
-                    base64 = base64.slice(index + 1)
-                }
-                resolve({
-                    name: file.name,
-                    base64: base64
-                })
-            }
-            fileReader.onerror = function (e) {
-                reject(e)
-            }
-            fileReader.readAsDataURL(file)
-        }))
-    }
-    return Promise.all(awaits)
+  const awaits: Promise<fileBase64Data>[] = []
+  for (const file of files) {
+    awaits.push(
+      new Promise((resolve, reject) => {
+        const fileReader = new FileReader()
+        fileReader.onload = function (e) {
+          let base64 = e.target?.result as string
+          if (!base64) {
+            resolve({
+              name: file.name,
+              base64: '',
+            })
+            return
+          }
+          const index = base64.indexOf(',')
+          if (index != -1) {
+            base64 = base64.slice(index + 1)
+          }
+          resolve({
+            name: file.name,
+            base64: base64,
+          })
+        }
+        fileReader.onerror = function (e) {
+          reject(e)
+        }
+        fileReader.readAsDataURL(file)
+      }),
+    )
+  }
+  return Promise.all(awaits)
 }
 
 export function base64ToBlob(base64: string): Blob {
-    const arr = base64.split(',')
-    let mime
-    if (arr.length > 1) {
-        const m: RegExpMatchArray | null = arr[0].match(/:(.*?);/)
-        if (m?.length) {
-            mime = m[1]
-            base64 = arr[1]
-        }
-    }
-    if (!mime) {
-        mime = 'application/octet-stream'
+  const arr = base64.split(',')
+  let mime
+  if (arr.length > 1) {
+    const m: RegExpMatchArray | null = arr[0].match(/:(.*?);/)
+    if (m?.length) {
+      mime = m[1]
+      base64 = arr[1]
     }
+  }
+  if (!mime) {
+    mime = 'application/octet-stream'
+  }
 
-    const byteCharacters = atob(base64)
-    const byteArray = new Uint8Array(byteCharacters.length)
-    for (let i = 0; i < byteCharacters.length; i++) {
-        byteArray[i] = byteCharacters.charCodeAt(i)
-    }
-    return new Blob([byteArray], { type: mime })
+  const byteCharacters = atob(base64)
+  const byteArray = new Uint8Array(byteCharacters.length)
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteArray[i] = byteCharacters.charCodeAt(i)
+  }
+  return new Blob([byteArray], { type: mime })
 }
 
 //urls提取为文件二进制数据
-export async function urlsToFileBlobs(urls: string[], onDownloadProgress?: (progressEvent: any) => void): Promise<(Blob|undefined)[]> {
-    const task = new urlDownloadTask(urls)
-    if(onDownloadProgress) {
-        task.onDownloadProgress(onDownloadProgress)
-    }
-    return await task.start()
+export function urlsToFileBlobs(
+  urls: string[],
+  onDownloadProgress?: (progressEvent: unknown) => void,
+): Promise<(Blob | undefined)[]> {
+  const task = new urlDownloadTask(urls)
+  if (onDownloadProgress) {
+    task.onDownloadProgress(onDownloadProgress)
+  }
+  return task.start()
 }
 
 export function splitArrayIntoChunks<T>(array: T[], chunkSize: number): T[][] {
-    const result: T[][] = []
-    for (let i = 0; i < array.length; i += chunkSize) {
-        const chunk = array.slice(i, i + chunkSize)
-        result.push(chunk)
-    }
-    return result
+  const result: T[][] = []
+  for (let i = 0; i < array.length; i += chunkSize) {
+    const chunk = array.slice(i, i + chunkSize)
+    result.push(chunk)
+  }
+  return result
 }
 
 // 字符串SHA-1哈希值
 export async function hashString(str: string): Promise<string> {
-    const encoder = new TextEncoder();
-    const data = encoder.encode(str);
-    const hashBuffer = await window.crypto.subtle.digest("SHA-1", data);
-    const hashArray = Array.from(new Uint8Array(hashBuffer));
-    return hashArray
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("");
+  const encoder = new TextEncoder()
+  const data = encoder.encode(str)
+  const hashBuffer = await window.crypto.subtle.digest('SHA-1', data)
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
 }

package/index.ts

@@ -6,13 +6,13 @@ import ReplaceInterface from './replace/interface'
 
 export const General = general
 
-export const  Sign = sign
+export const Sign = sign
 
 export const WorkerGeneral = workerGeneral
 
 export const WorkerSign = workerSign
 
-type signFun = (data: any) => Promise<string>;
+type signFun = (data: unknown) => Promise<string>
 
 export default (concurrency?: number, signFn?: signFun): ReplaceInterface => {
   let res = undefined
@@ -20,16 +20,16 @@ export default (concurrency?: number, signFn?: signFun): ReplaceInterface => {
     if (signFn) {
       res = workerSign(concurrency)
       res.sign = signFn
-    }else{
+    } else {
       res = workerGeneral(concurrency)
     }
-  }else {
+  } else {
     if (signFn) {
       res = sign()
       res.sign = signFn
-    }else{
+    } else {
       res = general()
     }
   }
   return res
-}
+}

package/office/zip.ts

@@ -1,116 +1,125 @@
 import { stream } from '../download'
-import { FlateError, unzip, Unzipped, zip, strToU8, AsyncZipOptions, Zip as fflateZip, ZipDeflate } from 'fflate'
+import {
+  FlateError,
+  unzip,
+  Unzipped,
+  zip,
+  strToU8,
+  AsyncZipOptions,
+  Zip as fflateZip,
+  ZipDeflate,
+} from 'fflate'
 
-type InputType = string|Uint8Array|ArrayBuffer|Blob
+type InputType = string | Uint8Array | ArrayBuffer | Blob
 
 export default class Zip {
-    name: string = ''
-    fileBlob?: Blob
-    _unzipData?: Unzipped
-    _lastUpdateTime: number = 0;
+  name: string = ''
+  fileBlob?: Blob
+  private _unzipData?: Unzipped
+  private _lastUpdateTime: number = 0
 
-    constructor(file?: Blob) {
-        if (!file) {
-            return
-        }
-        this.name = (file as File)?.name ?? ''
-        this.fileBlob = file
+  constructor(file?: Blob) {
+    if (!file) {
+      return
     }
+    this.name = (file as File)?.name ?? ''
+    this.fileBlob = file
+  }
 
-    getFileBlob(): Blob|undefined {
-        return this.fileBlob
-    }
+  getFileBlob(): Blob | undefined {
+    return this.fileBlob
+  }
 
-    async fileZip(): Promise<Unzipped> {
-        if (!this._unzipData) {
-            try {
-                const blob = this.getFileBlob()
-                if (blob) {
-                    const arrayBuffer = await blob.arrayBuffer()
-                    this._unzipData = await new Promise((resolve, reject) => {
-                        unzip(new Uint8Array(arrayBuffer), (err: FlateError | null, data: Unzipped) => {
-                            if (err) {
-                                return reject(err)
-                            }
-                            resolve(data)
-                        })
-                    })
-                }
-            } catch (e) {
-                console.warn(e)
-            }
-        }
-        if (!this._unzipData) {
-            this._unzipData = {}
+  async fileZip(): Promise<Unzipped> {
+    if (!this._unzipData) {
+      try {
+        const blob = this.getFileBlob()
+        if (blob) {
+          const arrayBuffer = await blob.arrayBuffer()
+          this._unzipData = await new Promise((resolve, reject) => {
+            unzip(
+              new Uint8Array(arrayBuffer),
+              (err: FlateError | null, data: Unzipped) => {
+                resolve(data)
+              },
+            )
+          })
         }
-        return this._unzipData
+      } catch (e) {
+        console.warn(e)
+      }
     }
-
-    async setZipData(path: string, data: InputType): Promise<void> {
-        const fileZip = await this.fileZip()
-        switch (true) {
-            case data instanceof Blob:
-                data = new Uint8Array(await data.arrayBuffer())
-                break
-            case data instanceof Uint8Array:
-                break
-            case data instanceof ArrayBuffer:
-                data = new Uint8Array(data)
-                break
-            case data instanceof String:
-                data = strToU8(data as string)
-                break
-            default:
-                throw new Error('Invalid data type')
-        }
-        fileZip[path] = data as Uint8Array
-        this._lastUpdateTime = (new Date()).getTime()
+    if (!this._unzipData) {
+      this._unzipData = {}
     }
+    return this._unzipData
+  }
 
-    async generate(options: AsyncZipOptions): Promise<Blob|undefined> {
-        const data = await this.fileZip()
-        if (!Object.keys(data).length) {
-            return undefined
-        }
-        return await new Promise((resolve, reject) => {
-            zip(data, options,  (err: FlateError | null, data: Uint8Array) => {
-                if (err) {
-                    return reject(err)
-                }
-                resolve(new Blob([data as BlobPart]))
-            })
-        })
+  async setZipData(path: string, data: InputType): Promise<void> {
+    const fileZip = await this.fileZip()
+    switch (true) {
+      case data instanceof Blob:
+        data = new Uint8Array(await data.arrayBuffer())
+        break
+      case data instanceof Uint8Array:
+        break
+      case data instanceof ArrayBuffer:
+        data = new Uint8Array(data)
+        break
+      case data instanceof String:
+        data = strToU8(data as string)
+        break
+      default:
+        throw new Error('Invalid data type')
     }
+    fileZip[path] = data as Uint8Array
+    this._lastUpdateTime = new Date().getTime()
+  }
 
-    async download(fileName: string): Promise<void> {
-        const data = await this.fileZip()
-        if (!Object.keys(data).length) {
-            return
+  async generate(options: AsyncZipOptions): Promise<Blob | undefined> {
+    const data = await this.fileZip()
+    if (!Object.keys(data).length) {
+      return undefined
+    }
+    return await new Promise((resolve, reject) => {
+      zip(data, options, (err: FlateError | null, data: Uint8Array) => {
+        if (err) {
+          return reject(err)
         }
+        resolve(new Blob([data as BlobPart]))
+      })
+    })
+  }
 
-        if (fileName == undefined) {
-            fileName = this.name
-        }
+  async download(fileName: string): Promise<void> {
+    const data = await this.fileZip()
+    if (!Object.keys(data).length) {
+      return
+    }
 
-        const downloadStream = stream(fileName)
-        const zip = new fflateZip((err, dat, final) => {
-            if (err) {
-                downloadStream.abort(err)
-                return
-            }
-            downloadStream.write(dat)
-            if (final) {
-                downloadStream.close()
-            }
-        })
+    if (fileName == undefined) {
+      fileName = this.name
+    }
 
-        for (const key in data) {
-            const deflate = new ZipDeflate(key, {
-                level: 9
-            });
-            zip.add(deflate)
-            deflate.push(data[key], true);
-        }
-        zip.end()
+    const downloadStream = stream(fileName)
+    const zip = new fflateZip((err, dat, final) => {
+      if (err) {
+        downloadStream.abort(err)
+        return
+      }
+      downloadStream.write(dat)
+      if (final) {
+        downloadStream.close()
+      }
+    })
+
+    for (const key in data) {
+      const deflate = new ZipDeflate(key, {
+        level: 9,
+      })
+      zip.add(deflate)
+      deflate.push(data[key], true)
     }
-}
+    zip.end()
+  }
+}

package/package.json

@@ -1,31 +1,37 @@
 {
   "name": "template-replacement",
   "description": "模板文件替换",
-  "version": "3.3.3",
+  "version": "3.4.0",
   "author": "fushiliang <994301536@qq.com>",
   "type": "module",
   "main": "index.ts",
   "license": "Apache 2.0",
   "scripts": {
-    "build": "npx vite build --config vite.config.ts"
+    "build": "vite build --config vite.config.ts",
+    "lint": "npx oxlint && npx eslint"
   },
   "dependencies": {
     "axios": "^1.13.2",
     "fflate": "^0.8.2",
     "file-type": "^19.6.0",
     "streamsaver": "^2.0.6",
-    "template-replacement-core-wasm": "^1.4.0",
-    "template-replacement-sign-core-wasm": "^1.4.0"
+    "template-replacement-core-wasm": "^1.7.2",
+    "template-replacement-sign-core-wasm": "^1.7.2"
   },
   "devDependencies": {
+    "@rollup/pluginutils": "^5.3.0",
     "@types/streamsaver": "^2.0.5",
+    "@typescript-eslint/eslint-plugin": "^8.50.0",
+    "@typescript-eslint/parser": "^8.50.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-oxlint": "^1.33.0",
+    "oxfmt": "^0.16.0",
+    "oxlint": "^1.33.0",
     "terser": "^5.44.1",
     "typescript": "^5.9.3",
-    "vite": "^7.2.2",
-    "vite-plugin-dts": "^4.5.4",
-    "vite-plugin-wasm-pack": "^0.1.12"
+    "vite": "^7.3.0"
   },
   "keywords": [
     "template-replacement"
   ]
-}
+}