@laisuk/opencc-fmmseg-wasm 0.1.0 → 0.2.1

package/README.md

@@ -1,5 +1,10 @@
 # opencc-fmmseg-wasm
 
+[![npm version](https://img.shields.io/npm/v/@laisuk/opencc-fmmseg-wasm)](https://www.npmjs.com/package/@laisuk/opencc-fmmseg-wasm)
+[![npm downloads](https://img.shields.io/npm/dm/@laisuk/opencc-fmmseg-wasm)](https://www.npmjs.com/package/@laisuk/opencc-fmmseg-wasm)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![WebAssembly](https://img.shields.io/badge/WebAssembly-enabled-blue)](https://webassembly.org/)
+
 OpenCC FMM segmentation WebAssembly bindings for browsers and JavaScript runtimes.
 
 This package provides high-quality Simplified Chinese ↔ Traditional Chinese conversion powered by the Rust [
@@ -16,6 +21,8 @@ Features:
 * Traditional Chinese regional variants
 * Japanese Shinjitai conversion support
 * Chinese script detection (`zho_check`)
+* In-memory Office / EPUB document conversion
+* Zero-dependency Node.js CLI
 
 ---
 
@@ -190,6 +197,88 @@ Returns:
 
 ---
 
+## Office / EPUB Conversion
+
+Office and EPUB conversion runs fully locally in the browser or Node.js. Files are passed in and returned as bytes;
+nothing is uploaded to a backend server.
+
+This is useful for converting text inside:
+
+```text
+docx, xlsx, pptx, odt, ods, odp, epub
+```
+
+File size is limited by available browser or Node.js memory, but there is no upload or server-side limit. Font
+preservation is supported with the `keepFont` option.
+
+```javascript
+convert_office_bytes(inputBytes, format, config, punctuation, keepFont)
+```
+
+Parameters:
+
+* `inputBytes`: `Uint8Array` document bytes
+* `format`: `docx`, `xlsx`, `pptx`, `odt`, `ods`, `odp`, or `epub`
+* `config`: OpenCC config string, such as `"s2t"`
+* `punctuation`: whether to convert punctuation variants
+* `keepFont`: whether to preserve font declarations where supported
+
+Returns:
+
+* converted output bytes
+
+### Browser Office Example
+
+```javascript
+import init, {convert_office_bytes} from "@laisuk/opencc-fmmseg-wasm";
+
+await init();
+
+const file = document.querySelector("input[type=file]").files[0];
+const inputBytes = new Uint8Array(await file.arrayBuffer());
+
+const outputBytes = convert_office_bytes(
+    inputBytes,
+    "docx",
+    "s2t",
+    true,
+    true
+);
+
+const blob = new Blob([outputBytes], {
+    type: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+});
+
+const a = document.createElement("a");
+a.href = URL.createObjectURL(blob);
+a.download = "converted.docx";
+a.click();
+URL.revokeObjectURL(a.href);
+```
+
+### Node.js Office Example
+
+```javascript
+import fs from "fs";
+import init, {convert_office_bytes} from "@laisuk/opencc-fmmseg-wasm";
+
+await init();
+
+const inputBytes = fs.readFileSync("input.docx");
+
+const outputBytes = convert_office_bytes(
+    inputBytes,
+    "docx",
+    "s2t",
+    true,
+    true
+);
+
+fs.writeFileSync("output.docx", outputBytes);
+```
+
+---
+
 ## Browser Example
 
 ```html
@@ -221,6 +310,52 @@ Returns:
 
 ---
 
+## Node.js CLI
+
+The package includes a zero-dependency Node.js CLI:
+
+```bash
+opencc-fmmseg convert -i input.txt -o output.txt -c s2t -p
+```
+
+```bash
+opencc-fmmseg office -i input.docx -o output.docx -c s2t -p --keep-font
+```
+
+### Text Conversion Options
+
+```text
+-i, --input <file>          Input text file
+-o, --output <file>         Output text file
+-c, --config <conversion>   Conversion config
+-p, --punct                 Enable punctuation conversion
+--in-enc <encoding>         Input encoding
+--out-enc <encoding>        Output encoding
+```
+
+### Office / EPUB Options
+
+```text
+-i, --input <file>          Input Office / EPUB file
+-o, --output <file>         Output file
+-c, --config <conversion>   Conversion config
+-p, --punct                 Enable punctuation conversion
+--format <format>           docx | xlsx | pptx | odt | ods | odp | epub
+--auto-ext                  Append extension to output if missing
+--keep-font                 Preserve font-family information
+--no-keep-font              Do not preserve font-family information
+```
+
+For `office`, the format is inferred from the input file extension when `--format` is omitted.
+
+If `-o, --output` is omitted, `office` writes:
+
+```text
+<input-name>_converted.<ext>
+```
+
+---
+
 ## TypeScript Support
 
 The package includes generated TypeScript definitions from `wasm-bindgen`.

package/bin/opencc.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+
+import fs from "fs";
+import path from "path";
+import process from "process";
+
+import init, {
+    OpenccWasm,
+    convert_office_bytes
+} from "../pkg/opencc_fmmseg_wasm.js";
+
+const OFFICE_FORMATS = new Set([
+    "docx",
+    "xlsx",
+    "pptx",
+    "odt",
+    "ods",
+    "odp",
+    "epub"
+]);
+
+let wasmInitialized = false;
+
+async function ensureWasmInitialized() {
+    if (wasmInitialized) {
+        return;
+    }
+
+    const wasmPath = new URL("../pkg/opencc_fmmseg_wasm_bg.wasm", import.meta.url);
+    const wasmBytes = fs.readFileSync(wasmPath);
+
+    await init({
+        module_or_path: wasmBytes
+    });
+
+    wasmInitialized = true;
+}
+
+function printHelp() {
+    console.log(`
+opencc-fmmseg WASM CLI
+
+Usage:
+  opencc.js convert [options]
+  opencc.js office  [options]
+
+Commands:
+  convert                     Convert plain text
+  office                      Convert Office / EPUB documents
+
+Convert options:
+  -i, --input <file>          Input text file; stdin if omitted
+  -o, --output <file>         Output text file; stdout if omitted
+  -c, --config <conversion>   Conversion config (default: s2t)
+  -p, --punct                 Enable punctuation conversion
+  --in-enc <encoding>         Input encoding (default: utf8)
+  --out-enc <encoding>        Output encoding (default: utf8)
+
+Office options:
+  -i, --input <file>          Input Office / EPUB file
+  -o, --output <file>         Output file
+  -c, --config <conversion>   Conversion config (default: s2t)
+  -p, --punct                 Enable punctuation conversion
+  --format <format>           docx | xlsx | pptx | odt | ods | odp | epub
+  --auto-ext                  Append extension to output if missing
+  --keep-font                 Preserve font-family information (default)
+  --no-keep-font              Do not preserve font-family information
+
+General options:
+  -h, --help                  Show help
+
+Examples:
+  node ./bin/opencc.js convert -i a.txt -o b.txt -c s2t
+  node ./bin/opencc.js convert -i a.txt -o b.txt -c s2tw -p
+  cat a.txt | node ./bin/opencc.js convert -c t2s
+
+  node ./bin/opencc.js office -i a.docx -o b.docx -c s2t -p
+  node ./bin/opencc.js office -i a.epub -c s2tw --auto-ext
+`);
+}
+
+function getArg(args, shortName, longName, defaultValue = null) {
+    const candidates = [];
+
+    if (shortName) {
+        candidates.push(shortName);
+    }
+    if (longName) {
+        candidates.push(longName);
+    }
+
+    for (const name of candidates) {
+        const index = args.indexOf(name);
+
+        if (index !== -1 && index + 1 < args.length) {
+            return args[index + 1];
+        }
+    }
+
+    return defaultValue;
+}
+
+function hasFlag(args, shortName, longName) {
+    return (
+        (shortName && args.includes(shortName)) ||
+        (longName && args.includes(longName))
+    );
+}
+
+function readInputText(filePath, encoding) {
+    if (!filePath) {
+        return fs.readFileSync(0, encoding);
+    }
+
+    if (!fs.existsSync(filePath)) {
+        console.error(`Error: Input file not found: ${filePath}`);
+        process.exit(1);
+    }
+
+    return fs.readFileSync(filePath, encoding);
+}
+
+function writeOutputText(filePath, text, encoding) {
+    if (!filePath) {
+        process.stdout.write(text);
+        return;
+    }
+
+    fs.writeFileSync(filePath, text, encoding);
+}
+
+function inferOfficeFormat(inputFile, explicitFormat) {
+    if (explicitFormat) {
+        const normalized = explicitFormat.trim().toLowerCase();
+
+        if (!OFFICE_FORMATS.has(normalized)) {
+            throw new Error(
+                `Invalid office format: ${explicitFormat}. ` +
+                `Valid formats: ${Array.from(OFFICE_FORMATS).join(", ")}`
+            );
+        }
+
+        return normalized;
+    }
+
+    const ext = path.extname(inputFile).slice(1).toLowerCase();
+
+    if (!OFFICE_FORMATS.has(ext)) {
+        throw new Error(
+            `Invalid Office file extension: .${ext || "(none)"}. ` +
+            "Valid extensions: .docx | .xlsx | .pptx | .odt | .ods | .odp | .epub"
+        );
+    }
+
+    return ext;
+}
+
+function makeDefaultOfficeOutput(inputFile, officeFormat, autoExt) {
+    const parsed = path.parse(inputFile);
+    const ext = autoExt && OFFICE_FORMATS.has(officeFormat)
+        ? `.${officeFormat}`
+        : parsed.ext;
+
+    return path.join(
+        parsed.dir || process.cwd(),
+        `${parsed.name}_converted${ext}`
+    );
+}
+
+function applyAutoExt(outputFile, officeFormat, autoExt) {
+    if (!autoExt || path.extname(outputFile)) {
+        return outputFile;
+    }
+
+    if (!OFFICE_FORMATS.has(officeFormat)) {
+        return outputFile;
+    }
+
+    return `${outputFile}.${officeFormat}`;
+}
+
+async function runConvert(args) {
+    const input = getArg(args, "-i", "--input");
+    const output = getArg(args, "-o", "--output");
+    const config = getArg(args, "-c", "--config", "s2t");
+    const inEnc = getArg(args, null, "--in-enc", "utf8");
+    const outEnc = getArg(args, null, "--out-enc", "utf8");
+    const punct = hasFlag(args, "-p", "--punct");
+
+    await ensureWasmInitialized();
+
+    const cc = new OpenccWasm(config);
+
+    const inputText = readInputText(input, inEnc);
+    const outputText = cc.convert(inputText, punct);
+
+    writeOutputText(output, outputText, outEnc);
+
+    const inFrom = input || "<stdin>";
+    const outTo = output || "stdout";
+
+    if (process.stderr.isTTY) {
+        if (!output && outputText && !outputText.endsWith("\n")) {
+            console.error();
+        }
+
+        console.error(`Conversion completed (${config}): ${inFrom} -> ${outTo}`);
+    }
+}
+
+async function runOffice(args) {
+    const input = getArg(args, "-i", "--input");
+    let output = getArg(args, "-o", "--output");
+    const config = getArg(args, "-c", "--config", "s2t");
+    const explicitFormat = getArg(args, null, "--format");
+    const punct = hasFlag(args, "-p", "--punct");
+    const autoExt = hasFlag(args, null, "--auto-ext");
+    const keepFont = !hasFlag(args, null, "--no-keep-font");
+
+    if (!input) {
+        throw new Error("Input file is missing.");
+    }
+
+    if (!fs.existsSync(input) || !fs.statSync(input).isFile()) {
+        throw new Error(`Input file not found: ${input}`);
+    }
+
+    const officeFormat = inferOfficeFormat(input, explicitFormat);
+
+    if (!output) {
+        output = makeDefaultOfficeOutput(input, officeFormat, autoExt);
+        console.error(`Output file not specified. Using: ${output}`);
+    } else {
+        output = applyAutoExt(output, officeFormat, autoExt);
+    }
+
+    await ensureWasmInitialized();
+
+    const inputBytes = fs.readFileSync(input);
+
+    const outputBytes = convert_office_bytes(
+        inputBytes,
+        officeFormat,
+        config,
+        punct,
+        keepFont
+    );
+
+    fs.writeFileSync(output, outputBytes);
+
+    console.error(`Conversion completed (${config}, ${officeFormat}): ${input} -> ${output}`);
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+
+    if (args.length === 0 || hasFlag(args, "-h", "--help")) {
+        printHelp();
+        return;
+    }
+
+    const command = args[0];
+
+    switch (command) {
+        case "convert":
+            if (hasFlag(args.slice(1), "-h", "--help")) {
+                printHelp();
+                return;
+            }
+            await runConvert(args.slice(1));
+            break;
+
+        case "office":
+            if (hasFlag(args.slice(1), "-h", "--help")) {
+                printHelp();
+                return;
+            }
+            await runOffice(args.slice(1));
+            break;
+
+        default:
+            console.error(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error(err && err.message ? err.message : err);
+    process.exit(1);
+});

package/opencc_fmmseg_wasm.d.ts

@@ -36,11 +36,14 @@ export enum WasmOpenccConfig {
     T2jp = 16,
 }
 
+export function convert_office_bytes(input: Uint8Array, format: string, config: string, punctuation: boolean, keep_font: boolean): Uint8Array;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_openccwasm_free: (a: number, b: number) => void;
+    readonly convert_office_bytes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number, number, number];
     readonly openccwasm_convert: (a: number, b: number, c: number, d: number) => [number, number];
     readonly openccwasm_debugPing: (a: number) => [number, number];
     readonly openccwasm_getConfig: (a: number) => [number, number];
@@ -55,9 +58,9 @@ export interface InitOutput {
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
     readonly __externref_drop_slice: (a: number, b: number) => void;
-    readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_start: () => void;
 }
 

package/opencc_fmmseg_wasm.js

@@ -167,6 +167,30 @@ export const WasmOpenccConfig = Object.freeze({
     Jp2t: 15, "15": "Jp2t",
     T2jp: 16, "16": "T2jp",
 });
+
+/**
+ * @param {Uint8Array} input
+ * @param {string} format
+ * @param {string} config
+ * @param {boolean} punctuation
+ * @param {boolean} keep_font
+ * @returns {Uint8Array}
+ */
+export function convert_office_bytes(input, format, config, punctuation, keep_font) {
+    const ptr0 = passArray8ToWasm0(input, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(config, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.convert_office_bytes(ptr0, len0, ptr1, len1, ptr2, len2, punctuation, keep_font);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v4 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v4;
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -209,6 +233,11 @@ function getArrayJsValueFromWasm0(ptr, len) {
     return result;
 }
 
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -233,6 +262,13 @@ function isLikeNone(x) {
     return x === undefined || x === null;
 }
 
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);

package/package.json

@@ -2,13 +2,30 @@
   "name": "@laisuk/opencc-fmmseg-wasm",
   "type": "module",
   "description": "WebAssembly bindings for opencc-fmmseg, a high-performance OpenCC-compatible Simplified/Traditional Chinese converter.",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/laisuk/opencc-fmmseg-wasm"
+    "url": "git+https://github.com/laisuk/opencc-fmmseg-wasm.git"
+  },
+  "keywords": [
+    "opencc",
+    "chinese",
+    "simplified-chinese",
+    "traditional-chinese",
+    "wasm",
+    "webassembly",
+    "opencc-fmmseg",
+    "text-conversion",
+    "cjk",
+    "zh-hans",
+    "zh-hant"
+  ],
+  "bin": {
+    "opencc-fmmseg": "bin/opencc.js"
   },
   "files": [
+    "bin/",
     "opencc_fmmseg_wasm_bg.wasm",
     "opencc_fmmseg_wasm.js",
     "opencc_fmmseg_wasm.d.ts"