feat: remove woff ts impl

Author: nonzzz

bindings/javascript/wasm.ts

@@ -40,6 +40,9 @@ export interface WASMInstance {
   ) => number
   save_subset_to_file: (subset_handle: number, path_ptr: number, path_len: number) => number
 
+  convert_ttf_to_woff: (font_ptr: number, font_len: number, output_ptr: number, output_len: number) => number
+  convert_ttf_to_woff_from_reader: (reader_handle: number, output_ptr: number, output_len: number) => number
+
   get_error_message_length: (error_code: number) => number
   get_error_message: (error_code: number, buffer_ptr: number, buffer_len: number) => number
 }
@@ -48,6 +51,7 @@ export interface WASMZigEnv extends WebAssembly.ModuleImports {
   host_read_file: (pathPtr: number, pathLen: number, outPtrPtr: number, outLenPtr: number) => boolean
   host_write_file: (pathPtr: number, pathLen: number, dataPtr: number, dataLen: number) => boolean
   host_head_modified_time: (outTimestampPtr: number) => boolean
+  host_compress_data: (inputPtr: number, inputLen: number, outputPtrPtr: number, outputLenPtr: number) => boolean
 }
 
 const MAC_EPOCH_OFFSET = 2082844800 // Offset from Unix epoch to Mac epoch
@@ -59,7 +63,8 @@ export const ERR_CODE = {
   PARSE_FAILED: 3,
   INVALID_UTF8: 4,
   MISSING_TABLE: 5,
-  OUT_OF_BOUNDS: 6
+  OUT_OF_BOUNDS: 6,
+  COMPRESSION_FAILED: 7
 } as const
 
 export interface FontMetrics {
@@ -87,9 +92,13 @@ const IS_NODE_PLATFORM = typeof process !== 'undefined' && process.versions?.nod
 let FS_WRAP: Promise<typeof import('fs')> | null = null
 let fs: typeof import('fs') | null = null
 
+let ZLIB_WRAP: Promise<typeof import('zlib')> | null = null
+let zlib: typeof import('zlib') | null = null
+
 if (IS_NODE_PLATFORM) {
   try {
     FS_WRAP = import('fs').then((fsModule) => fsModule.default || fsModule)
+    ZLIB_WRAP = import('zlib').then((zlibModule) => zlibModule.default || zlibModule)
   } catch {
   }
 }
@@ -107,6 +116,51 @@ export class FontSubset {
     this.instance = instance
   }
 
+  static async convertTtfToWoff(instance: WASMInstance, fontData: Uint8Array) {
+    if (!zlib && IS_NODE_PLATFORM && ZLIB_WRAP) {
+      zlib = await ZLIB_WRAP
+    }
+    const fontPtr = instance.allocate_memory(fontData.length)
+    if (fontPtr === null) { return null }
+
+    const outputPtrPtr = instance.allocate_memory(4)
+    const outputLenPtr = instance.allocate_memory(4)
+
+    if (outputPtrPtr === null || outputLenPtr === null) {
+      instance.free_memory(fontPtr, fontData.length)
+      if (outputPtrPtr) { instance.free_memory(outputPtrPtr, 4) }
+      if (outputLenPtr) { instance.free_memory(outputLenPtr, 4) }
+      return null
+    }
+
+    try {
+      const memory = new Uint8Array(instance.memory.buffer)
+      memory.set(fontData, fontPtr)
+
+      const errorCode = instance.convert_ttf_to_woff(fontPtr, fontData.length, outputPtrPtr, outputLenPtr)
+
+      if (errorCode !== ERR_CODE.SUCCESS) {
+        return null
+      }
+
+      const outputPtr = new Uint32Array(instance.memory.buffer, outputPtrPtr, 1)[0]
+      const outputLen = new Uint32Array(instance.memory.buffer, outputLenPtr, 1)[0]
+
+      if (outputLen === 0) { return new Uint8Array(0) }
+
+      const result = new Uint8Array(instance.memory.buffer, outputPtr, outputLen)
+      const copy = new Uint8Array(result)
+
+      instance.free_memory(outputPtr, outputLen)
+
+      return copy
+    } finally {
+      instance.free_memory(fontPtr, fontData.length)
+      instance.free_memory(outputPtrPtr, 4)
+      instance.free_memory(outputLenPtr, 4)
+    }
+  }
+
   static createSubsetFromText(instance: WASMInstance, fontData: Uint8Array, text: string): Uint8Array | null {
     const fontPtr = instance.allocate_memory(fontData.length)
     if (fontPtr === null) { return null }
@@ -504,6 +558,34 @@ export function createSubsetEngine(binary: Uint8Array): FontSubset {
       } catch {
         return false
       }
+    },
+    host_compress_data(inputPtr, inputLen, outputPtrPtr, outputLenPtr) {
+      try {
+        if (!WASM_INSTANCE) { return false }
+        if (IS_NODE_PLATFORM && zlib) {
+          const memory = new Uint8Array(WASM_INSTANCE.memory.buffer)
+          const inputData = memory.slice(inputPtr, inputPtr + inputLen)
+
+          const compressedData = zlib.deflateSync(inputData)
+
+          const outputPtr = WASM_INSTANCE.allocate_memory(compressedData.length)
+          if (outputPtr === null) { return false }
+
+          const outputMemory = new Uint8Array(WASM_INSTANCE.memory.buffer)
+          outputMemory.set(compressedData, outputPtr)
+
+          const outPtrView = new Uint32Array(WASM_INSTANCE.memory.buffer, outputPtrPtr, 1)
+          const outLenView = new Uint32Array(WASM_INSTANCE.memory.buffer, outputLenPtr, 1)
+
+          outPtrView[0] = outputPtr
+          outLenView[0] = compressedData.length
+
+          return true
+        }
+        return false
+      } catch {
+        return false
+      }
     }
   }
   WASM_INSTANCE = new WebAssembly.Instance(compiledWASM, { env }).exports as unknown as WASMInstance
@@ -518,3 +600,8 @@ export function createSubsetFromText(
   if (!WASM_INSTANCE) { return null }
   return FontSubset.createSubsetFromText(WASM_INSTANCE, fontData, text)
 }
+
+export async function convertTtfToWoff(fontData: Uint8Array) {
+  if (!WASM_INSTANCE) { return null }
+  return FontSubset.convertTtfToWoff(WASM_INSTANCE, fontData)
+}

bindings/wasm/mod.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
 const lib = @import("ttf");
 
+const woff = lib.woff;
 var gpa = std.heap.wasm_allocator;
 
 const SubsetHandle = opaque {};
@@ -14,6 +15,7 @@ pub const ErrorCode = enum(u32) {
     invalid_utf8 = 4,
     missing_table = 5,
     out_of_bounds = 6,
+    compression_failed = 7,
 };
 
 export fn allocate_memory(size: u32) ?[*]u8 {
@@ -44,6 +46,58 @@ extern "env" fn host_write_file(path_ptr: [*]const u8, path_len: u32, data_ptr:
 
 extern "env" fn host_head_modified_time(out_timestamp: *u64) bool;
 
+extern "env" fn host_compress_data(input_ptr: [*]const u8, input_len: u32, output_ptr: *[*]u8, output_len: *u32) bool;
+
+fn wasm_compressor(allocator: std.mem.Allocator, data: []const u8) ![]u8 {
+    var output_ptr: [*]u8 = undefined;
+    var output_len: u32 = undefined;
+
+    if (!host_compress_data(data.ptr, @intCast(data.len), &output_ptr, &output_len)) {
+        return woff.woff_impl.Error.CompressionFailed;
+    }
+
+    const result = try allocator.alloc(u8, output_len);
+    @memcpy(result, output_ptr[0..output_len]);
+
+    free_memory(output_ptr, output_len);
+
+    return result;
+}
+
+export fn convert_ttf_to_woff(font_ptr: [*]const u8, font_len: u32, output_ptr: *[*]u8, output_len: *u32) ErrorCode {
+    const font_data = font_ptr[0..font_len];
+
+    const woff_data = woff.woff_v1.ttf_to_woff_v1(gpa, @constCast(font_data), wasm_compressor) catch |err| {
+        return switch (err) {
+            error.OutOfMemory => .allocation_failed,
+            error.CompressionFailed => .compression_failed,
+            else => .parse_failed,
+        };
+    };
+
+    output_ptr.* = woff_data.ptr;
+    output_len.* = @intCast(woff_data.len);
+
+    return .success;
+}
+
+export fn convert_ttf_to_woff_from_reader(reader_handle: ?*FontReaderHandle, output_ptr: *[*]u8, output_len: *u32) ErrorCode {
+    const reader: *lib.FontReader = @ptrCast(@alignCast(reader_handle orelse return .invalid_pointer));
+
+    const woff_data = woff.woff_v1.ttf_woff_v1_with_parser(gpa, &reader.subset.parser, wasm_compressor) catch |err| {
+        return switch (err) {
+            error.OutOfMemory => .allocation_failed,
+            error.CompressionFailed => .compression_failed,
+            else => .parse_failed,
+        };
+    };
+
+    output_ptr.* = woff_data.ptr;
+    output_len.* = @intCast(woff_data.len);
+
+    return .success;
+}
+
 export fn load_font_from_file(path_ptr: [*]const u8, path_len: u32) ?*FontReaderHandle {
     var data_ptr: [*]u8 = undefined;
     var data_len: u32 = undefined;
@@ -278,6 +332,7 @@ export fn get_error_message_length(error_code: ErrorCode) u32 {
         .invalid_utf8 => "Invalid UTF-8 text",
         .missing_table => "Required font table missing",
         .out_of_bounds => "Index out of bounds",
+        .compression_failed => "Compression failed",
     };
     return @intCast(message.len);
 }
@@ -291,6 +346,7 @@ export fn get_error_message(error_code: ErrorCode, buffer_ptr: [*]u8, buffer_len
         .invalid_utf8 => "Invalid UTF-8 text",
         .missing_table => "Required font table missing",
         .out_of_bounds => "Index out of bounds",
+        .compression_failed => "Compression failed",
     };
 
     if (buffer_len < message.len) return .out_of_bounds;

npm/cli/src/index.ts

@@ -5,8 +5,8 @@ import { readFileSync, statSync, writeFileSync } from 'fs'
 import mri from 'mri'
 import { extname, resolve } from 'path'
 import { globSync } from 'tinyglobby'
-import { ttf } from 'ttf.zig'
-import { ttf2woff } from './woff'
+import { convertTtfToWoff, ttf } from 'ttf.zig'
+// import { ttf2woff } from './woff'
 
 interface CliOptions {
   content?: string[]
@@ -150,7 +150,7 @@ function formatFileSize(bytes: number): string {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
 }
 
-function main() {
+async function main() {
   const args = mri<CliOptions>(process.argv.slice(2), {
     alias: {
       c: 'content',
@@ -265,7 +265,11 @@ function main() {
 
       if (outputPath.endsWith('.woff')) {
         logVerbose(`Converting subset font to WOFF format for ${outputPath}...`, options.verbose || false)
-        outputData = ttf2woff(subsetFont)
+        const woffData = await convertTtfToWoff(subsetFont)
+        if (!woffData) {
+          throw new Error(`Failed to convert TTF to WOFF for ${outputPath}`)
+        }
+        outputData = woffData
       } else {
         outputData = subsetFont
       }
@@ -290,4 +294,4 @@ function main() {
   }
 }
 
-main()
+main().catch(() => {})