@effindomv2/fui-rs 0.1.3

package/scripts/hostgen/registry.ts

@@ -0,0 +1,159 @@
+export type HostServiceTypeName =
+  | "string"
+  | "bool"
+  | "i32"
+  | "u32"
+  | "i64"
+  | "u64"
+  | "f64"
+  | "bytes"
+  | "i32_array"
+  | "u32_array"
+  | "i64_array"
+  | "u64_array"
+  | "f64_array"
+  | "void";
+
+interface HostServiceMethodDefinition {
+  readonly importName?: string;
+  readonly args: readonly HostServiceTypeName[];
+  readonly returns: HostServiceTypeName;
+  readonly implementation: (...args: readonly unknown[]) => unknown;
+}
+
+type HostServicesDefinition = Record<string, Record<string, HostServiceMethodDefinition>>;
+
+interface HostEventMethodDefinition {
+  readonly args: readonly HostServiceTypeName[];
+  readonly subscribe: (emit: (...args: readonly unknown[]) => void) => (() => void) | undefined;
+}
+
+type HostEventsDefinition = Record<string, Record<string, HostEventMethodDefinition>>;
+
+export interface NormalizedHostServiceMethod {
+  readonly serviceName: string;
+  readonly methodName: string;
+  readonly importName: string;
+  readonly args: readonly HostServiceTypeName[];
+  readonly returns: HostServiceTypeName;
+  readonly implementation: (...args: readonly unknown[]) => unknown;
+}
+
+export interface NormalizedHostEventMethod {
+  readonly serviceName: string;
+  readonly methodName: string;
+  readonly eventName: string;
+  readonly exportName: string;
+  readonly args: readonly HostServiceTypeName[];
+  readonly subscribe: (emit: (...args: readonly unknown[]) => void) => (() => void) | undefined;
+}
+
+const IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function assertIdentifier(value: string, context: string): void {
+  if (!IDENTIFIER_RE.test(value)) {
+    throw new Error(`${context} "${value}" must be a valid identifier.`);
+  }
+}
+
+function capitalize(value: string): string {
+  return value.length === 0 ? value : `${value.slice(0, 1).toUpperCase()}${value.slice(1)}`;
+}
+
+function validateServiceType(type: string, context: string): asserts type is HostServiceTypeName {
+  if (
+    type === "string" ||
+    type === "bool" ||
+    type === "i32" ||
+    type === "u32" ||
+    type === "i64" ||
+    type === "u64" ||
+    type === "f64" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array" ||
+    type === "void"
+  ) {
+    return;
+  }
+  throw new Error(`${context} uses unsupported host-service type "${type}".`);
+}
+
+function validateEventType(type: string, context: string): asserts type is HostServiceTypeName {
+  if (type !== "void") {
+    validateServiceType(type, context);
+    return;
+  }
+  throw new Error(`${context} uses unsupported host-event type "${type}".`);
+}
+
+export function listHostServiceMethods(services: HostServicesDefinition | undefined): readonly NormalizedHostServiceMethod[] {
+  if (services === undefined) {
+    return [];
+  }
+  const methods: NormalizedHostServiceMethod[] = [];
+  const seenImports = new Set<string>();
+  for (const [serviceName, serviceMethods] of Object.entries(services)) {
+    assertIdentifier(serviceName, "Host service");
+    for (const [methodName, definition] of Object.entries(serviceMethods)) {
+      assertIdentifier(methodName, `Host service ${serviceName} method`);
+      const importName = definition.importName ?? `${serviceName}${capitalize(methodName)}`;
+      assertIdentifier(importName, `Host service ${serviceName}.${methodName} import`);
+      if (seenImports.has(importName)) {
+        throw new Error(`Duplicate host-service import name "${importName}".`);
+      }
+      seenImports.add(importName);
+      const args = [...definition.args];
+      args.forEach((type, index) => {
+        validateServiceType(type, `Host service ${serviceName}.${methodName} arg ${String(index)}`);
+      });
+      validateServiceType(definition.returns, `Host service ${serviceName}.${methodName} return`);
+      methods.push({
+        serviceName,
+        methodName,
+        importName,
+        args,
+        returns: definition.returns,
+        implementation: definition.implementation,
+      });
+    }
+  }
+  methods.sort((left, right) => left.importName.localeCompare(right.importName));
+  return methods;
+}
+
+export function listHostEventMethods(events: HostEventsDefinition | undefined): readonly NormalizedHostEventMethod[] {
+  if (events === undefined) {
+    return [];
+  }
+  const methods: NormalizedHostEventMethod[] = [];
+  const seenEvents = new Set<string>();
+  for (const [serviceName, serviceMethods] of Object.entries(events)) {
+    assertIdentifier(serviceName, "Host event service");
+    for (const [methodName, definition] of Object.entries(serviceMethods)) {
+      assertIdentifier(methodName, `Host event ${serviceName} method`);
+      const eventName = `${serviceName}${capitalize(methodName)}`;
+      if (seenEvents.has(eventName)) {
+        throw new Error(`Duplicate host-event name "${eventName}".`);
+      }
+      seenEvents.add(eventName);
+      const args = [...definition.args];
+      args.forEach((type, index) => {
+        validateEventType(type, `Host event ${serviceName}.${methodName} arg ${String(index)}`);
+      });
+      methods.push({
+        serviceName,
+        methodName,
+        eventName,
+        exportName: `__fui_host_event_${eventName}`,
+        args,
+        subscribe: definition.subscribe,
+      });
+    }
+  }
+  methods.sort((left, right) => left.eventName.localeCompare(right.eventName));
+  return methods;
+}

package/scripts/hostgen/rust-host-events.ts

@@ -0,0 +1,171 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { listHostEventMethods, type HostServiceTypeName } from "./registry";
+import { loadModuleExport, snakeCaseIdentifier, sourcePathForHeader } from "./common";
+
+function rustValueType(type: HostServiceTypeName): string {
+  switch (type) {
+    case "string":
+      return "String";
+    case "bool":
+      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 "Vec<u8>";
+    case "i32_array":
+      return "Vec<i32>";
+    case "u32_array":
+      return "Vec<u32>";
+    case "i64_array":
+      return "Vec<i64>";
+    case "u64_array":
+      return "Vec<u64>";
+    case "f64_array":
+      return "Vec<f64>";
+    case "void":
+      return "()";
+  }
+}
+
+function callbackType(args: readonly HostServiceTypeName[]): string {
+  if (args.length === 0) {
+    return "Box<dyn Fn()>";
+  }
+  return `Box<dyn Fn(${args.map((arg) => rustValueType(arg)).join(", ")})>`;
+}
+
+function emitExportArgs(args: readonly HostServiceTypeName[]): string {
+  const parts: string[] = [];
+  args.forEach((type, index) => {
+    if (type === "string" || type === "bytes") {
+      parts.push(`arg${String(index)}_ptr: *const u8`, `arg${String(index)}_len: u32`);
+      return;
+    }
+    if (type === "i32_array" || type === "u32_array") {
+      parts.push(`arg${String(index)}_ptr: *const u32`, `arg${String(index)}_len: u32`);
+      return;
+    }
+    if (type === "i64_array" || type === "u64_array" || type === "f64_array") {
+      parts.push(`arg${String(index)}_ptr: *const u64`, `arg${String(index)}_len: u32`);
+      return;
+    }
+    parts.push(`arg${String(index)}: ${rustValueType(type)}`);
+  });
+  return parts.join(", ");
+}
+
+function emitDecodedArgs(args: readonly HostServiceTypeName[]): string[] {
+  const lines: string[] = [];
+  args.forEach((type, index) => {
+    if (type === "string") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { String::new() } else { String::from_utf8_lossy(unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr, arg${String(index)}_len as usize) }).into_owned() };`,
+      );
+      return;
+    }
+    if (type === "bytes") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { Vec::new() } else { unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr, arg${String(index)}_len as usize) }.to_vec() };`,
+      );
+      return;
+    }
+    if (type === "i32_array") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { Vec::new() } else { unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr as *const i32, arg${String(index)}_len as usize) }.to_vec() };`,
+      );
+      return;
+    }
+    if (type === "u32_array") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { Vec::new() } else { unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr as *const u32, arg${String(index)}_len as usize) }.to_vec() };`,
+      );
+      return;
+    }
+    if (type === "i64_array") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { Vec::new() } else { unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr as *const i64, arg${String(index)}_len as usize) }.to_vec() };`,
+      );
+      return;
+    }
+    if (type === "u64_array") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { Vec::new() } else { unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr as *const u64, arg${String(index)}_len as usize) }.to_vec() };`,
+      );
+      return;
+    }
+    if (type === "f64_array") {
+      lines.push(
+        `    let arg${String(index)} = if arg${String(index)}_ptr.is_null() || arg${String(index)}_len == 0 { Vec::new() } else { unsafe { std::slice::from_raw_parts(arg${String(index)}_ptr as *const f64, arg${String(index)}_len as usize) }.to_vec() };`,
+      );
+    }
+  });
+  return lines;
+}
+
+export async function generateRustHostEventsFile(
+  modulePath: string,
+  exportName: string,
+  outputPath: string,
+): Promise<void> {
+  const registry = await loadModuleExport(modulePath, exportName, "fui-rs-host-events-");
+  const methods = listHostEventMethods(registry as never);
+  const lines: string[] = [
+    `// Generated by hostgen from ${sourcePathForHeader(modulePath)}#${exportName}.`,
+    "// Do not edit by hand.",
+    "",
+    "#![allow(dead_code)]",
+    "#![allow(non_snake_case)]",
+    "",
+    "use std::cell::RefCell;",
+    "",
+  ];
+  methods.forEach((method) => {
+    const handlerName = snakeCaseIdentifier(method.eventName);
+    const callbackTy = callbackType(method.args);
+    lines.push("thread_local! {");
+    lines.push(
+      `    static ${handlerName.toUpperCase()}_HANDLER: RefCell<Option<${callbackTy}>> = const { RefCell::new(None) };`,
+    );
+    lines.push("}");
+    lines.push("");
+    lines.push(
+      `pub fn on_${handlerName}(callback: impl Fn(${method.args.map((arg) => rustValueType(arg)).join(", ")}) + 'static) {`,
+    );
+    lines.push(
+      `    ${handlerName.toUpperCase()}_HANDLER.with(|slot| *slot.borrow_mut() = Some(Box::new(callback)));`,
+    );
+    lines.push("}");
+    lines.push("");
+    lines.push(`pub fn clear_${handlerName}() {`);
+    lines.push(`    ${handlerName.toUpperCase()}_HANDLER.with(|slot| *slot.borrow_mut() = None);`);
+    lines.push("}");
+    lines.push("");
+    lines.push("#[no_mangle]");
+    lines.push(`pub extern "C" fn ${method.exportName}(${emitExportArgs(method.args)}) {`);
+    lines.push(`    ${handlerName.toUpperCase()}_HANDLER.with(|slot| {`);
+    lines.push("        let handler = slot.borrow();");
+    lines.push("        let Some(callback) = handler.as_ref() else {");
+    lines.push("            return;");
+    lines.push("        };");
+    lines.push(...emitDecodedArgs(method.args));
+    if (method.args.length === 0) {
+      lines.push("        callback();");
+    } else {
+      lines.push(`        callback(${method.args.map((_arg, index) => `arg${String(index)}`).join(", ")});`);
+    }
+    lines.push("    });");
+    lines.push("}");
+    lines.push("");
+  });
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, `${lines.join("\n")}\n`, "utf8");
+}

package/scripts/hostgen/rust-host-services.ts

@@ -0,0 +1,257 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { listHostServiceMethods, type HostServiceTypeName } from "./registry";
+import { loadModuleExport, snakeCaseIdentifier, sourcePathForHeader } from "./common";
+
+type RustMode = "framework" | "app";
+
+function rustArgType(type: HostServiceTypeName): string {
+  switch (type) {
+    case "string":
+      return "&str";
+    case "bool":
+      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 "&[u8]";
+    case "i32_array":
+      return "&[i32]";
+    case "u32_array":
+      return "&[u32]";
+    case "i64_array":
+      return "&[i64]";
+    case "u64_array":
+      return "&[u64]";
+    case "f64_array":
+      return "&[f64]";
+    case "void":
+      return "()";
+  }
+}
+
+function rustReturnType(type: HostServiceTypeName): string {
+  switch (type) {
+    case "string":
+      return "String";
+    case "bool":
+      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 "Vec<u8>";
+    case "i32_array":
+      return "Vec<i32>";
+    case "u32_array":
+      return "Vec<u32>";
+    case "i64_array":
+      return "Vec<i64>";
+    case "u64_array":
+      return "Vec<u64>";
+    case "f64_array":
+      return "Vec<f64>";
+    case "void":
+      return "()";
+  }
+}
+
+function isBufferType(type: HostServiceTypeName): boolean {
+  return (
+    type === "string" ||
+    type === "bytes" ||
+    type === "i32_array" ||
+    type === "u32_array" ||
+    type === "i64_array" ||
+    type === "u64_array" ||
+    type === "f64_array"
+  );
+}
+
+
+function emitWasmImportArgs(args: readonly HostServiceTypeName[], returns: HostServiceTypeName): string {
+  const parts: string[] = [];
+  args.forEach((type, index) => {
+    if (type === "string" || type === "bytes") {
+      parts.push(`arg${String(index)}_ptr: *const u8`, `arg${String(index)}_len: u32`);
+      return;
+    }
+    if (type === "i32_array" || type === "u32_array") {
+      parts.push(`arg${String(index)}_ptr: *const u32`, `arg${String(index)}_len: u32`);
+      return;
+    }
+    if (type === "i64_array" || type === "u64_array" || type === "f64_array") {
+      parts.push(`arg${String(index)}_ptr: *const u64`, `arg${String(index)}_len: u32`);
+      return;
+    }
+    parts.push(`arg${String(index)}: ${rustReturnType(type)}`);
+  });
+  if (isBufferType(returns)) {
+    parts.push("result_ptr: *mut u8", "result_cap: u32");
+  }
+  return parts.join(", ");
+}
+
+function emitWrapperArgs(args: readonly HostServiceTypeName[]): string {
+  return args.map((type, index) => `arg${String(index)}: ${rustArgType(type)}`).join(", ");
+}
+
+function emitWasmCallArgs(args: readonly HostServiceTypeName[]): string {
+  const parts: string[] = [];
+  args.forEach((type, index) => {
+    if (type === "string") {
+      parts.push(`arg${String(index)}.as_ptr()`, `arg${String(index)}.len() as u32`);
+      return;
+    }
+    if (type === "bytes") {
+      parts.push(`arg${String(index)}.as_ptr()`, `arg${String(index)}.len() as u32`);
+      return;
+    }
+    if (
+      type === "i32_array" ||
+      type === "u32_array" ||
+      type === "i64_array" ||
+      type === "u64_array" ||
+      type === "f64_array"
+    ) {
+      parts.push(`arg${String(index)}.as_ptr() as *const _`, `arg${String(index)}.len() as u32`);
+      return;
+    }
+    parts.push(`arg${String(index)}`);
+  });
+  return parts.join(", ");
+}
+
+function emitFrameworkNonWasmBody(importName: string, args: readonly HostServiceTypeName[]): string[] {
+  const argNames = args.map((_type, index) => `arg${String(index)}`);
+  if (importName === "fui_now_ms") {
+    return ["    crate::ffi::test::host_now_ms()"];
+  }
+  return [`    unsafe { crate::ffi::${importName}(${argNames.join(", ")}) }`];
+}
+
+function emitDecodeReturn(
+  returns: HostServiceTypeName,
+  runtimePath: string,
+  importName: string,
+): string[] {
+  if (returns === "void") {
+    return [];
+  }
+  if (!isBufferType(returns)) {
+    return ["    raw_result"];
+  }
+  const decodeFn =
+    returns === "string" ? "decode_host_service_string_result" :
+    returns === "bytes" ? "decode_host_service_bytes_result" :
+    returns === "i32_array" ? "decode_host_service_i32_array_result" :
+    returns === "u32_array" ? "decode_host_service_u32_array_result" :
+    returns === "i64_array" ? "decode_host_service_i64_array_result" :
+    returns === "u64_array" ? "decode_host_service_u64_array_result" :
+    "decode_host_service_f64_array_result";
+  return [
+    `    ${runtimePath}::${decodeFn}(result_ptr, raw_result, "${importName}")`,
+  ];
+}
+
+export async function generateRustHostServicesFile(
+  modulePath: string,
+  exportName: string,
+  outputPath: string,
+  runtimePathArg: string | undefined,
+  hostImportModule: string,
+): Promise<void> {
+  const registry = await loadModuleExport(modulePath, exportName, "fui-rs-host-services-");
+  const methods = listHostServiceMethods(registry as never);
+  const mode: RustMode = hostImportModule === "fui_host" ? "framework" : "app";
+  const hostImportCfg = mode === "framework"
+    ? 'any(target_family = "wasm", feature = "native-runtime")'
+    : 'target_family = "wasm"';
+  const fallbackCfg = mode === "framework"
+    ? 'all(not(target_family = "wasm"), not(feature = "native-runtime"))'
+    : 'not(target_family = "wasm")';
+  const runtimePath =
+    runtimePathArg === undefined || runtimePathArg.length === 0
+      ? mode === "framework"
+        ? "crate::host_services"
+        : "fui::host_services"
+      : runtimePathArg;
+  const header = [
+    `// Generated by hostgen from ${sourcePathForHeader(modulePath)}#${exportName}.`,
+    "// Do not edit by hand.",
+    "",
+    "#![allow(dead_code)]",
+    "#![allow(non_snake_case)]",
+    "",
+  ];
+  const wasmExterns: string[] = [
+    `#[cfg(${hostImportCfg})]`,
+    `#[cfg_attr(target_family = "wasm", link(wasm_import_module = "${hostImportModule}"))]`,
+    'unsafe extern "C" {',
+  ];
+  for (const method of methods) {
+    const returnType = isBufferType(method.returns) ? "u32" : rustReturnType(method.returns);
+    wasmExterns.push(
+      `    #[link_name = "${method.importName}"]`,
+    );
+    wasmExterns.push(
+      `    fn __host_${method.importName}(${emitWasmImportArgs(method.args, method.returns)}) -> ${returnType};`,
+    );
+  }
+  wasmExterns.push("}");
+  const wrappers: string[] = [];
+  for (const method of methods) {
+    const wrapperName = snakeCaseIdentifier(method.importName);
+    const returnType = rustReturnType(method.returns);
+    wrappers.push(`pub fn ${wrapperName}(${emitWrapperArgs(method.args)}) -> ${returnType} {`);
+    wrappers.push(`  #[cfg(${hostImportCfg})]`);
+    wrappers.push("  {");
+    if (isBufferType(method.returns)) {
+      wrappers.push(`    let result_ptr = ${runtimePath}::host_service_result_buffer_ptr();`);
+      wrappers.push(`    let result_cap = ${runtimePath}::host_service_result_buffer_size();`);
+      const wasmCallArgs = emitWasmCallArgs(method.args);
+      const callArgs = wasmCallArgs.length > 0 ? `${wasmCallArgs}, result_ptr, result_cap` : "result_ptr, result_cap";
+      wrappers.push(`    let raw_result = unsafe { __host_${method.importName}(${callArgs}) };`);
+      wrappers.push(...emitDecodeReturn(method.returns, runtimePath, method.importName));
+    } else if (method.returns === "void") {
+      const wasmCallArgs = emitWasmCallArgs(method.args);
+      wrappers.push(`    unsafe { __host_${method.importName}(${wasmCallArgs}) };`);
+    } else {
+      wrappers.push(`    unsafe { __host_${method.importName}(${emitWasmCallArgs(method.args)}) }`);
+    }
+    wrappers.push("  }");
+    wrappers.push(`  #[cfg(${fallbackCfg})]`);
+    wrappers.push("  {");
+    if (mode === "framework") {
+      wrappers.push(...emitFrameworkNonWasmBody(method.importName, method.args));
+    } else {
+      wrappers.push(
+        `    panic!("Host service ${method.importName} is only available in wasm/browser builds.");`,
+      );
+    }
+    wrappers.push("  }");
+    wrappers.push("}");
+    wrappers.push("");
+  }
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(
+    outputPath,
+    `${header.join("\n")}${wasmExterns.join("\n")}\n\n${wrappers.join("\n")}`,
+    "utf8",
+  );
+}