template-replacement 3.0.8

package/dist/sign.d.ts

@@ -0,0 +1 @@
+export {}

package/download/index.ts

@@ -0,0 +1,22 @@
+import streamClass 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)
+}
+
+export default (fileName: string, blob: Blob): void => {
+    download(fileName, blob)
+}
+
+//流式下载
+export function stream(fileName: string, size?: number): streamClass {
+    return new streamClass(fileName, size)
+}

package/download/stream.ts

@@ -0,0 +1,38 @@
+import streamSaver from "streamsaver"
+
+export function setMitm(mitm: string) {
+    streamSaver.mitm = mitm
+}
+
+export default class Stream {
+    tasks: Promise<any>[] = []
+    writer: WritableStreamDefaultWriter<any>
+    fileStream: WritableStream
+
+    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
+    }
+
+    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)
+    }
+}

package/helper/index.ts

@@ -0,0 +1,162 @@
+import { nanoid } from 'nanoid'
+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)
+}
+
+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 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,
+}
+
+export const officeSuffixTypes: Record<string, fileTypes> = {
+    'docx': fileTypes.word,
+    'dotx': fileTypes.word,
+    'xlsx': fileTypes.excel,
+}
+
+export function fileType(file: File): fileTypes {
+    return officeMIMETypes[file.type] ?? fileTypes.unknown
+}
+
+export function fileTypeByName(name: string): fileTypes {
+    return officeSuffixTypes[urlSuffix(name)] ?? fileTypes.unknown
+}
+
+export async function fileTypeByBuffer(buffer: Uint8Array|ArrayBuffer|Blob): Promise<fileTypes> {
+    if (buffer instanceof Blob) {
+        buffer = await buffer.arrayBuffer()
+    }
+    const type = await fileTypeFromBuffer(buffer)
+    if (type && officeMIMETypes[type.mime]) {
+        return officeMIMETypes[type.mime]
+    }
+    return fileTypes.unknown
+}
+
+export function generateId(): string {
+    return nanoid()
+}
+
+export type fileArrayBufferData = {
+    name: string
+    buffer: ArrayBuffer
+}
+
+export async function filesReaderArrayBuffer(files: File[]): Promise<fileArrayBufferData[]> {
+    const awaits = []
+    files.forEach
+    for (const file of files) {
+        awaits.push(new Promise(async (resolve, reject) => {
+            try {
+                resolve({
+                    name: file.name,
+                    buffer: await file.arrayBuffer()
+                } as fileArrayBufferData)
+            } catch (error) {
+                reject(error)
+            }
+        }))
+    }
+    return (await Promise.all(awaits)) as fileArrayBufferData[]
+}
+
+
+export type fileBase64Data = {
+    name: string
+    base64: string
+}
+
+export async function filesReaderBase64(files: File[]): Promise<fileBase64Data[]> {
+    const awaits = []
+    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 await Promise.all(awaits) as fileBase64Data[]
+}
+
+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 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 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
+  }

package/index.ts

@@ -0,0 +1,21 @@
+import general from './dispatcher/general'
+import sign from './dispatcher/sign'
+import workerGeneral from './dispatcher/workerGeneral'
+import workerSign from './dispatcher/workerSign'
+import ReplaceInterface from './replace/interface'
+
+export function General(): ReplaceInterface {
+  return general()
+}
+
+export function Sign(): ReplaceInterface {
+  return sign()
+}
+
+export function WorkerGeneral(concurrency?: number): ReplaceInterface {
+  return workerGeneral(concurrency)
+}
+
+export function WorkerSign(concurrency?: number): ReplaceInterface {
+  return workerSign(concurrency)
+}

package/office/zip.ts

@@ -0,0 +1,116 @@
+import { stream } from '../download'
+import { FlateError, unzip, Unzipped, zip, strToU8, AsyncZipOptions, Zip as fflateZip, ZipDeflate } from 'fflate'
+
+type InputType = string|Uint8Array|ArrayBuffer|Blob
+
+export default class Zip {
+    name: string = ''
+    fileBlob?: Blob
+    _unzipData?: Unzipped
+    _lastUpdateTime: number = 0;
+
+    constructor(file?: Blob) {
+        if (!file) {
+            return
+        }
+        this.name = (file as File)?.name ?? ''
+        this.fileBlob = file
+    }
+
+    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(async (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 = {}
+        }
+        return this._unzipData
+    }
+
+    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 generate(options: AsyncZipOptions): Promise<Blob|undefined> {
+        const data = await this.fileZip()
+        if (!Object.keys(data).length) {
+            return undefined
+        }
+        return await new Promise(async (resolve, reject) => {
+            zip(data, options,  (err: FlateError | null, data: Uint8Array) => {
+                if (err) {
+                    return reject(err)
+                }
+                resolve(new Blob([data]))
+            })
+        })
+    }
+
+    async download(fileName: string): Promise<void> {
+        const data = await this.fileZip()
+        if (!Object.keys(data).length) {
+            return
+        }
+
+        if (fileName == undefined) {
+            fileName = this.name
+        }
+
+        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

@@ -0,0 +1,33 @@
+{
+  "name": "template-replacement",
+  "description": "模板文件替换",
+  "version": "3.0.8",
+  "author": "fushiliang <994301536@qq.com>",
+  "license": "ISC",
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "build": "npx vite build --config vite.config.ts"
+  },
+  "dependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/streamsaver": "^2.0.5",
+    "axios": "^1.7.9",
+    "fflate": "^0.8.2",
+    "file-type": "^19.6.0",
+    "nanoid": "^4.0.2",
+    "streamsaver": "^2.0.6",
+    "template-replacement-core-wasm": "^1.0.0",
+    "template-replacement-sign-core-wasm": "^1.0.1",
+    "vite-plugin-wasm-pack": "^0.1.12"
+  },
+  "devDependencies": {
+    "@types/js-md5": "^0.7.2",
+    "typescript": "^5.7.3",
+    "vite": "^6.1.0",
+    "vite-plugin-dts": "^4.5.0"
+  },
+  "keywords": [
+    "template-replacement"
+  ]
+}

package/replace/base.ts

@@ -0,0 +1,124 @@
+import Interface, { media } from './interface';
+import { Interface as CoreInterface } from '../core/base';
+import paramsData from './paramsData';
+import Temp from '../temp';
+import { fileTypes } from '../helper';
+
+export default class Base implements Interface{
+    #files: Temp[] = []
+    #core: CoreInterface
+
+    constructor(core: CoreInterface) {
+        this.#core = core
+    }
+
+    addTempFile(tempFile: Temp){
+        this.#files.push(tempFile)
+    }
+
+    clear(): void {
+        this.#files.length = 0
+    }
+
+    async extractVariables(files: Temp[] | undefined): Promise<Record<string, string[]>> {
+        if (!files) {
+            files = this.#files
+        }
+        const data: Record<string, string[]> = {}
+        const tasks = []
+        for (const file of files) {
+            tasks.push(new Promise<void>(async (resolve, reject) => {
+                const buffer = await file.getBuffer()
+                if (buffer && (await file.type()) !== fileTypes.unknown) {
+                    data[file.name] = await this.#core.extract_one_file_variable_names(buffer)
+                }
+                resolve()
+            }))
+        }
+        await Promise.all(tasks)
+        return data
+    }
+
+    async extractMedias(files: Temp[] | undefined): Promise<Record<string, media[]>> {
+        if (!files) {
+            files = this.#files
+        }
+        const data: Record<string, media[]> = {}
+        const tasks = []
+        for (const file of files) {
+            tasks.push(new Promise<void>(async (resolve, reject) => {
+                const buffer = await file.getBuffer()
+                if (buffer && (await file.type()) !== fileTypes.unknown) {
+                    let medias = await this.#core.extract_one_file_medias(buffer)
+                    data[file.name] = []
+                    if (medias && Array.isArray(medias)) {
+                        medias.forEach(m => {
+                            if (m.id && m.data) {
+                                data[file.name].push({
+                                    id: m.id,
+                                    data: new Uint8Array(m.data)
+                                })
+                            }
+                        })
+                    }
+                }
+                resolve()
+            }))
+        }
+        await Promise.all(tasks)
+        return data
+    }
+
+    async handle(paramsData: paramsData, files: Uint8Array[]): Promise<Uint8Array[]> {
+        return []
+    }
+
+    async sign(data: any): Promise<string> {
+        return ""
+    }
+
+    async execute(params: paramsData, files: Temp[] | undefined): Promise<Record<string, Uint8Array>> {
+        if (!files) {
+            files = this.#files
+        }
+
+        const fileData: { names: string[], uint8Arrays: Uint8Array[] } = {
+            names: [],
+            uint8Arrays: [],
+        }
+
+        const tasks = []
+        for (const file of files) {
+            tasks.push(new Promise<Uint8Array|undefined>(async (resolve, reject) => {
+                resolve(file.getBuffer())
+            }))
+        }
+        await Promise.all(tasks)
+
+        for (const file of files) {
+            if (file.uint8Array) {
+                fileData.names.push(file.name)
+                fileData.uint8Arrays.push(file.uint8Array)
+            }
+        }
+
+        if(!fileData.uint8Arrays.length) {
+            return {}
+        }
+
+        const res = await this.handle(params, fileData.uint8Arrays)
+        const finishStatusCount = {
+            success: 0,
+            total: fileData.uint8Arrays.length
+        } //完成状态统计
+        const resData: Record<string, Uint8Array> = {}
+
+        res.forEach((file, i) => {
+            if (file.length) {
+                resData[fileData.names[i]] = file
+                finishStatusCount.success++
+            }
+        })
+        return resData
+    }
+}

package/replace/general.ts

@@ -0,0 +1,14 @@
+import Base from './base';
+import core, { replace_batch } from '../core/general'
+import paramsData from './paramsData';
+
+export default class General extends Base {
+    constructor() {
+        super(core())
+    }
+
+    async handle(paramsData: paramsData, files: Uint8Array[]): Promise<Uint8Array[]> {
+      const [params, mediaBuffers] = await paramsData.toReplaceParams()
+      return replace_batch(params, mediaBuffers, files)
+    }
+}

package/replace/image.ts

@@ -0,0 +1,116 @@
+// import { add_media } from "template-replacement-core-wasm"
+
+export function pxToEMU(px: number): number {
+    return px * (914400 / 96)
+}
+
+export function cmToEMU(cm: number): number {
+    return cm * 914400
+}
+
+export enum textWrapTypes {
+    embed = "Embed",//嵌入型
+    belowText = "BelowText",//嵌于文字下方
+    aboveText = "AboveText",//嵌于文字上方
+}
+
+function getFileExtension(filename: string): string {
+    const ext = filename.split('.').pop()
+    if (ext === undefined) {
+        return ''
+    }
+    return '.' + ext
+}
+
+// async function generateId(file: Blob): Promise<string> {
+//     const buffer = await file.arrayBuffer()
+//     return await add_media(new Uint8Array(buffer))
+// }
+
+export type extent = {
+    cy: number,
+    cx: number,
+}
+
+//图片替换
+export default class image {
+    file: Blob
+    relationship = 'image'
+    id?: string
+
+    wpExtent?: extent //图片宽高
+    textWrap = textWrapTypes.embed //文字环绕
+
+    awaitInitQueue?: Function[] = []
+
+    constructor(file: Blob) {
+        if (file instanceof Blob) {
+            this.file = file
+            this.init()
+        } else {
+            throw new Error("不支持的数据类型");
+        }
+    }
+
+    async init(): Promise<void> {
+        this.awaitInitQueue = []
+        await this.getExtent()
+        for (const resolve of this.awaitInitQueue) {
+            resolve()
+        }
+        delete this.awaitInitQueue
+    }
+
+    // async generateId(): Promise<string> {
+    //     this.id = await generateId(this.file)
+    //     return this.id
+    // }
+
+    async awaitInit(): Promise<void> {
+        if (this.awaitInitQueue) {
+            await new Promise(resolve => {
+                this.awaitInitQueue?.push(resolve)
+            })
+        }
+    }
+
+    async getExtent(): Promise<extent> {
+        if (!this.wpExtent) {
+            const bitmap = await createImageBitmap(this.file)
+            !this.wpExtent && this.setPxExtent(bitmap.width, bitmap.height)
+            bitmap.close()
+        }
+        return this.wpExtent as extent
+    }
+
+    //设置图片范围（像素）
+    setPxExtent(width: number, height: number): void {
+        this.wpExtent = {
+            cy: pxToEMU(height),
+            cx: pxToEMU(width),
+        }
+    }
+
+    //设置图片范围（厘米）
+    setCmExtent(width: number, height: number): void {
+        this.wpExtent = {
+            cy: cmToEMU(height),
+            cx: cmToEMU(width),
+        }
+    }
+
+    async outJson(): Promise<Record<string, any>> {
+        await this.awaitInit()
+        const data: Record<string, any> = {}
+        for (const key in this) {
+            data[key] = this[key]
+        }
+        return data
+    }
+
+    setPropertys(data: Record<string, any>) {
+        for (const key in data) {
+            this[key as keyof image] = data[key]
+        }
+    }
+}

package/replace/interface.ts

@@ -0,0 +1,29 @@
+import paramsData from "./paramsData"
+import Temp from "../temp"
+
+export type media = {
+    id: string,
+    data: Uint8Array
+}
+
+export default interface ReplaceInterface {
+
+    //添加模板文件
+    addTempFile(tempFile: Temp): void
+
+    //清空文件和链接
+    clear(): void
+
+    //提取变量
+    extractVariables(files: Temp[] | undefined): Promise<Record<string, string[]>>
+
+    //提取媒体
+    extractMedias(files: Temp[] | undefined): Promise<Record<string, media[]>>
+
+    //签名方法
+    sign(data: any): Promise<string>
+
+    //执行替换任务
+    execute(params: paramsData, files: Temp[] | undefined): Promise<Record<string, Uint8Array>>
+
+}