@effindomv2/fui-as 0.1.1 → 0.1.3

package/scripts/generate-host-services.ts

@@ -21,6 +21,11 @@ function relativeImport(fromFile: string, targetFile: string): string {
   return toPosix(relative);
 }
 
+function sourcePathForHeader(sourceModulePath: string): string {
+  const relative = path.relative(process.cwd(), sourceModulePath);
+  return toPosix(relative.startsWith(".") ? relative : `./${relative}`);
+}
+
 function asTypeName(type: HostServiceTypeName): string {
   switch (type) {
     case "string":
@@ -29,28 +34,71 @@ function asTypeName(type: HostServiceTypeName): string {
       return "bool";
     case "i32":
       return "i32";
+    case "u32":
+      return "u32";
+    case "i64":
+      return "i64";
+    case "u64":
+      return "u64";
     case "f64":
       return "f64";
+    case "bytes":
+      return "Uint8Array";
+    case "i32_array":
+      return "Int32Array";
+    case "u32_array":
+      return "Uint32Array";
+    case "i64_array":
+      return "Int64Array";
+    case "u64_array":
+      return "Uint64Array";
+    case "f64_array":
+      return "Float64Array";
     case "void":
       return "void";
   }
 }
 
-function emitExternalSignature(importName: string, args: readonly HostServiceTypeName[], returns: HostServiceTypeName): string {
+function isPointerLengthType(type: HostServiceTypeName): boolean {
+  return type === "string" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array";
+}
+
+function returnsBufferType(type: HostServiceTypeName): boolean {
+  return type === "string" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array";
+}
+
+function emitExternalSignature(
+  importName: string,
+  args: readonly HostServiceTypeName[],
+  returns: HostServiceTypeName,
+  moduleName: string,
+): string {
   const signatureParts: Array<string> = [];
   args.forEach((type, index) => {
-    if (type === "string") {
+    if (isPointerLengthType(type)) {
       signatureParts.push(`arg${String(index)}Ptr: usize`, `arg${String(index)}Len: u32`);
       return;
     }
     signatureParts.push(`arg${String(index)}: ${asTypeName(type)}`);
   });
-  if (returns === "string") {
+  if (returnsBufferType(returns)) {
     signatureParts.push("resultPtr: usize", "resultCap: u32");
   }
-  const returnType = returns === "string" ? "u32" : asTypeName(returns);
+  const returnType = returnsBufferType(returns) ? "u32" : asTypeName(returns);
   return [
-    `@external("fui_host_service", "${importName}")`,
+    `@external("${moduleName}", "${importName}")`,
     `declare function __host_${importName}(${signatureParts.join(", ")}): ${returnType};`,
   ].join("\n");
 }
@@ -61,6 +109,10 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
   args.forEach((type, index) => {
     if (type === "string") {
       lines.push(`  const arg${String(index)}Bytes = Uint8Array.wrap(String.UTF8.encode(arg${String(index)}, false));`);
+      return;
+    }
+    if (type === "bytes" || type === "i32_array" || type === "u32_array" || type === "i64_array" || type === "u64_array" || type === "f64_array") {
+      lines.push(`  const arg${String(index)}Bytes = arg${String(index)};`);
     }
   });
   const callArgs: Array<string> = [];
@@ -70,14 +122,38 @@ function emitWrapper(importName: string, args: readonly HostServiceTypeName[], r
       callArgs.push(`<u32>arg${String(index)}Bytes.length`);
       return;
     }
+    if (type === "bytes") {
+      callArgs.push(`arg${String(index)}Bytes.length > 0 ? arg${String(index)}Bytes.dataStart : 0`);
+      callArgs.push(`<u32>arg${String(index)}Bytes.length`);
+      return;
+    }
+    if (type === "i32_array" || type === "u32_array" || type === "i64_array" || type === "u64_array" || type === "f64_array") {
+      callArgs.push(`arg${String(index)}Bytes.length > 0 ? arg${String(index)}Bytes.dataStart : 0`);
+      callArgs.push(`<u32>arg${String(index)}Bytes.length`);
+      return;
+    }
     callArgs.push(`arg${String(index)}`);
   });
-  if (returns === "string") {
+  if (returnsBufferType(returns)) {
     lines.push("  const resultPtr = hostServiceResultBufferPtr();");
     lines.push("  const resultCap = hostServiceResultBufferSize();");
     callArgs.push("resultPtr", "resultCap");
     lines.push(`  const resultLen = __host_${importName}(${callArgs.join(", ")});`);
-    lines.push(`  return decodeHostServiceStringResult(resultPtr, resultLen, "${importName}");`);
+    if (returns === "string") {
+      lines.push(`  return decodeHostServiceStringResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "bytes") {
+      lines.push(`  return decodeHostServiceBytesResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "i32_array") {
+      lines.push(`  return decodeHostServiceI32ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "u32_array") {
+      lines.push(`  return decodeHostServiceU32ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "i64_array") {
+      lines.push(`  return decodeHostServiceI64ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else if (returns === "u64_array") {
+      lines.push(`  return decodeHostServiceU64ArrayResult(resultPtr, resultLen, "${importName}");`);
+    } else {
+      lines.push(`  return decodeHostServiceF64ArrayResult(resultPtr, resultLen, "${importName}");`);
+    }
   } else if (returns === "void") {
     lines.push(`  __host_${importName}(${callArgs.join(", ")});`);
   } else {
@@ -118,19 +194,51 @@ function emitBindingsFile(
   exportName: string,
   outputPath: string,
   methods: ReturnType<typeof listHostServiceMethods>,
+  primitivesImportOverride: string | undefined,
+  moduleName: string,
 ): string {
-  const runtimeImport = relativeImport(outputPath, path.resolve(PACKAGE_DIR, "src/FuiPrimitives.ts"));
+  const runtimeImport = primitivesImportOverride ?? relativeImport(outputPath, path.resolve(PACKAGE_DIR, "src/FuiPrimitives.ts"));
   const blocks: Array<string> = [
-    `// Generated by scripts/generate-host-services.ts from ${toPosix(sourceModulePath)}#${exportName}.`,
+    `// Generated by scripts/generate-host-services.ts from ${sourcePathForHeader(sourceModulePath)}#${exportName}.`,
   ];
-  if (methods.some((method) => method.returns === "string")) {
-    blocks.push(`import { decodeHostServiceStringResult, hostServiceResultBufferPtr, hostServiceResultBufferSize } from "${runtimeImport}";`);
+  if (methods.some((method) => returnsBufferType(method.returns))) {
+    const helpers = [
+      "hostServiceResultBufferPtr",
+      "hostServiceResultBufferSize",
+      ...new Set(
+        methods
+          .map((method) => method.returns)
+          .filter((type) => returnsBufferType(type))
+          .map((type) => {
+            if (type === "string") {
+              return "decodeHostServiceStringResult";
+            }
+            if (type === "bytes") {
+              return "decodeHostServiceBytesResult";
+            }
+            if (type === "i32_array") {
+              return "decodeHostServiceI32ArrayResult";
+            }
+            if (type === "u32_array") {
+              return "decodeHostServiceU32ArrayResult";
+            }
+            if (type === "i64_array") {
+              return "decodeHostServiceI64ArrayResult";
+            }
+            if (type === "u64_array") {
+              return "decodeHostServiceU64ArrayResult";
+            }
+            return "decodeHostServiceF64ArrayResult";
+          }),
+      ),
+    ];
+    blocks.push(`import { ${helpers.join(", ")} } from "${runtimeImport}";`);
     blocks.push("");
   } else {
     blocks.push("");
   }
   methods.forEach((method, index) => {
-    blocks.push(emitExternalSignature(method.importName, method.args, method.returns));
+    blocks.push(emitExternalSignature(method.importName, method.args, method.returns, moduleName));
     blocks.push("");
     blocks.push(emitWrapper(method.importName, method.args, method.returns));
     if (index + 1 < methods.length) {
@@ -141,15 +249,24 @@ function emitBindingsFile(
 }
 
 async function main(): Promise<void> {
-  const [moduleArg, exportName, outputArg] = process.argv.slice(2);
+  const [moduleArg, exportName, outputArg, primitivesImportArg, hostModuleArg] = process.argv.slice(2);
   if (moduleArg === undefined || exportName === undefined || outputArg === undefined) {
-    throw new Error("Usage: generate-host-services <module-path> <export-name> <output-path>");
+    throw new Error(
+      "Usage: generate-host-services <module-path> <export-name> <output-path> [primitives-import] [host-import-module]",
+    );
   }
   const modulePath = path.resolve(process.cwd(), moduleArg);
   const outputPath = path.resolve(process.cwd(), outputArg);
   const registry = await loadHostServices(modulePath, exportName);
   const methods = listHostServiceMethods(registry as never);
-  const content = emitBindingsFile(modulePath, exportName, outputPath, methods);
+  const content = emitBindingsFile(
+    modulePath,
+    exportName,
+    outputPath,
+    methods,
+    primitivesImportArg,
+    hostModuleArg ?? "fui_host_service",
+  );
   await fs.mkdir(path.dirname(outputPath), { recursive: true });
   await fs.writeFile(outputPath, content, "utf8");
 }

package/src/FuiPrimitives.ts

@@ -12,4 +12,14 @@ export {
 } from "./core/BoundCallback";
 export { bind0, bind1, bind2, bindResult0, bindResult1 } from "./core/bind";
 export { clearCurrentSelection, tryGetBounds } from "./bindings/ui";
-export { decodeHostServiceStringResult, hostServiceResultBufferPtr, hostServiceResultBufferSize } from "./host-services/runtime";
+export {
+  decodeHostServiceBytesResult,
+  decodeHostServiceF64ArrayResult,
+  decodeHostServiceI64ArrayResult,
+  decodeHostServiceI32ArrayResult,
+  decodeHostServiceStringResult,
+  decodeHostServiceU64ArrayResult,
+  decodeHostServiceU32ArrayResult,
+  hostServiceResultBufferPtr,
+  hostServiceResultBufferSize,
+} from "./host-services/runtime";

package/src/core/ffi.ts

@@ -1,3 +1,11 @@
+export {
+  fui_get_accent_color,
+  fui_get_platform_family,
+  fui_is_coarse_pointer,
+  fui_is_dark_mode,
+  fui_now_ms,
+} from "./generated/FrameworkHostServices";
+
 export enum HandleValue {
   Invalid = 0,
 }
@@ -569,24 +577,9 @@ export declare function fui_start_timer(timerId: u32, delayMs: i32): void;
 @external("fui_host", "fui_cancel_timer")
 export declare function fui_cancel_timer(timerId: u32): void;
 
-@external("fui_host", "fui_now_ms")
-export declare function fui_now_ms(): f64;
-
 @external("fui_host", "fui_set_cursor")
 export declare function fui_set_cursor(style: u32): void;
 
-@external("fui_host", "fui_is_dark_mode")
-export declare function fui_is_dark_mode(): bool;
-
-@external("fui_host", "fui_get_accent_color")
-export declare function fui_get_accent_color(): u32;
-
-@external("fui_host", "fui_get_platform_family")
-export declare function fui_get_platform_family(): u32;
-
-@external("fui_host", "fui_is_coarse_pointer")
-export declare function fui_is_coarse_pointer(): bool;
-
 @external("fui_host", "fui_show_url_preview")
 export declare function fui_show_url_preview(ptr: usize, len: u32): void;
 

package/src/core/generated/FrameworkHostServices.ts

@@ -0,0 +1,36 @@
+// Generated by scripts/generate-host-services.ts from ./scripts/framework-host-services.ts#frameworkHostServices.
+
+@external("fui_host", "fui_get_accent_color")
+declare function __host_fui_get_accent_color(): u32;
+
+export function fui_get_accent_color(): u32 {
+  return __host_fui_get_accent_color();
+}
+
+@external("fui_host", "fui_get_platform_family")
+declare function __host_fui_get_platform_family(): u32;
+
+export function fui_get_platform_family(): u32 {
+  return __host_fui_get_platform_family();
+}
+
+@external("fui_host", "fui_is_coarse_pointer")
+declare function __host_fui_is_coarse_pointer(): bool;
+
+export function fui_is_coarse_pointer(): bool {
+  return __host_fui_is_coarse_pointer();
+}
+
+@external("fui_host", "fui_is_dark_mode")
+declare function __host_fui_is_dark_mode(): bool;
+
+export function fui_is_dark_mode(): bool {
+  return __host_fui_is_dark_mode();
+}
+
+@external("fui_host", "fui_now_ms")
+declare function __host_fui_now_ms(): f64;
+
+export function fui_now_ms(): f64 {
+  return __host_fui_now_ms();
+}

package/src/host-services/runtime.ts

@@ -8,7 +8,7 @@ export function hostServiceResultBufferSize(): u32 {
   return __fui_text_buffer_size();
 }
 
-export function decodeHostServiceStringResult(resultPtr: usize, resultLen: u32, importName: string): string {
+function assertResultByteLength(resultLen: u32, importName: string): void {
   const capacity = __fui_text_buffer_size();
   if (resultLen > capacity) {
     throw new Error(
@@ -21,5 +21,78 @@ export function decodeHostServiceStringResult(resultPtr: usize, resultLen: u32,
       ".",
     );
   }
+}
+
+export function decodeHostServiceStringResult(resultPtr: usize, resultLen: u32, importName: string): string {
+  assertResultByteLength(resultLen, importName);
   return resultLen == 0 ? "" : String.UTF8.decodeUnsafe(resultPtr, <usize>resultLen, false);
 }
+
+export function decodeHostServiceBytesResult(resultPtr: usize, resultLen: u32, importName: string): Uint8Array {
+  assertResultByteLength(resultLen, importName);
+  const bytes = new Uint8Array(<i32>resultLen);
+  if (resultLen > 0) {
+    memory.copy(bytes.dataStart, resultPtr, <usize>resultLen);
+  }
+  return bytes;
+}
+
+export function decodeHostServiceI32ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Int32Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 3) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Int32Array byte length.");
+  }
+  const values = new Int32Array(<i32>(resultLen >> 2));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceU32ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Uint32Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 3) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Uint32Array byte length.");
+  }
+  const values = new Uint32Array(<i32>(resultLen >> 2));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceI64ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Int64Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 7) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Int64Array byte length.");
+  }
+  const values = new Int64Array(<i32>(resultLen >> 3));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceU64ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Uint64Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 7) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Uint64Array byte length.");
+  }
+  const values = new Uint64Array(<i32>(resultLen >> 3));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}
+
+export function decodeHostServiceF64ArrayResult(resultPtr: usize, resultLen: u32, importName: string): Float64Array {
+  assertResultByteLength(resultLen, importName);
+  if ((resultLen & 7) != 0) {
+    throw new Error("Host service " + importName + " returned misaligned Float64Array byte length.");
+  }
+  const values = new Float64Array(<i32>(resultLen >> 3));
+  if (resultLen > 0) {
+    memory.copy(values.dataStart, resultPtr, <usize>resultLen);
+  }
+  return values;
+}