@jitl/opentui-core 0.1.97 → 0.2.15

package/index-5zwezmgj.js

@@ -0,0 +1,639 @@
+// @bun
+// src/platform/ffi.ts
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/platform/node22-ffi.ts
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { isAnyArrayBuffer, isArrayBuffer, isArrayBufferView } from "util/types";
+var requireModule = createRequire(import.meta.url);
+var emptyPtrSentinel = new Uint8Array(1);
+function createNode22Backend(modules = loadNode22Modules()) {
+  const { koffi, unsafePointerOf, unsafeArrayBufferAt } = modules;
+  const bunPtrType = koffi.pointer("BunPtr", koffi.opaque());
+  const bufferType = koffi.opaque("Buffer");
+  const napiEnvType = koffi.opaque("NapiEnv");
+  const napiValueType = koffi.opaque("NapiValue");
+  const ffiTypeToKoffiType = (type, position) => {
+    switch (type) {
+      case "char":
+        return koffi.types.char;
+      case "int8_t":
+      case "i8":
+        return koffi.types.int8_t;
+      case "uint8_t":
+      case "u8":
+        return koffi.types.uint8_t;
+      case "int16_t":
+      case "i16":
+        return koffi.types.int16_t;
+      case "uint16_t":
+      case "u16":
+        return koffi.types.uint16_t;
+      case "int32_t":
+      case "int":
+      case "i32":
+        return koffi.types.int32_t;
+      case "uint32_t":
+      case "u32":
+        return koffi.types.uint32_t;
+      case "int64_t":
+      case "i64":
+        return koffi.types.int64_t;
+      case "uint64_t":
+      case "u64":
+      case "usize":
+        return koffi.types.uint64_t;
+      case "double":
+      case "f64":
+        return koffi.types.double;
+      case "float":
+      case "f32":
+        return koffi.types.float;
+      case "bool":
+        return koffi.types.bool;
+      case "ptr":
+      case "pointer":
+      case "function":
+      case "callback":
+        return bunPtrType;
+      case "void":
+        return koffi.types.void;
+      case "cstring":
+        if (position === "result") {
+          throw new Error(NODE_STRING_RETURN);
+        }
+        return koffi.types.string;
+      case "buffer":
+        return bufferType;
+      case "napi_env":
+        throw new Error(NODE_NAPI_UNSUPPORTED, { cause: napiEnvType });
+      case "napi_value":
+        throw new Error(NODE_NAPI_UNSUPPORTED, { cause: napiValueType });
+      default:
+        return unsupportedNode22FFIType(type);
+    }
+  };
+  const argsToKoffiTypes = (args) => args?.map((type) => ffiTypeToKoffiType(type, "parameter")) ?? [];
+  const returnsToKoffiType = (returns) => ffiTypeToKoffiType(returns ?? "void", "result");
+  const createRawCallback = (callback, definition) => {
+    if (definition.ptr != null) {
+      throw new Error(NODE_POINTER_OVERRIDE);
+    }
+    if (definition.threadsafe) {
+      throw new Error(NODE_CALLBACK_THREADSAFE);
+    }
+    const pointerArgIndices = getTypeIndices(definition.args, isPointerType);
+    const wrappedCallback = pointerArgIndices.length === 0 ? callback : (...args) => {
+      for (const index of pointerArgIndices) {
+        args[index] = koffiPointerToPointer(koffi, args[index]);
+      }
+      return callback(...args);
+    };
+    const proto = koffi.proto(returnsToKoffiType(definition.returns), argsToKoffiTypes(definition.args));
+    let registeredCallback = koffi.register(wrappedCallback, koffi.pointer(proto));
+    return {
+      get ptr() {
+        return registeredCallback ? koffiPointerToPointer(koffi, registeredCallback) : null;
+      },
+      threadsafe: false,
+      close() {
+        if (!registeredCallback) {
+          return;
+        }
+        koffi.unregister(registeredCallback);
+        registeredCallback = null;
+      }
+    };
+  };
+  const createFunction = (lib, name, definition) => {
+    if (definition.ptr != null) {
+      throw new Error(NODE_POINTER_OVERRIDE);
+    }
+    const func = lib.func(name, returnsToKoffiType(definition.returns), argsToKoffiTypes(definition.args));
+    const pointerArgIndices = getTypeIndices(definition.args, isPointerType);
+    const boolArgIndices = getTypeIndices(definition.args, isBoolType);
+    const returnsPointer = isPointerType(definition.returns);
+    const returnsBigInt = isBigIntType(definition.returns);
+    if (pointerArgIndices.length === 0 && boolArgIndices.length === 0 && !returnsPointer && !returnsBigInt) {
+      return func;
+    }
+    const wrapper = (...args) => {
+      for (const index of boolArgIndices) {
+        args[index] = Boolean(args[index]);
+      }
+      for (const index of pointerArgIndices) {
+        args[index] = pointerArgToKoffiArg(args[index]);
+      }
+      const result = func(...args);
+      if (returnsPointer) {
+        return koffiPointerToPointer(koffi, result);
+      }
+      if (returnsBigInt) {
+        return typeof result === "bigint" ? result : BigInt(result);
+      }
+      return result;
+    };
+    Object.defineProperty(wrapper, "name", { value: name });
+    return wrapper;
+  };
+  return {
+    dlopen(path, symbols) {
+      if (path === null) {
+        throw new Error("Node 22 FFI backend does not support dlopen(null)");
+      }
+      const lib = koffi.load(path instanceof URL ? fileURLToPath(path) : path);
+      const callbacks = new Set;
+      let closed = false;
+      return {
+        symbols: Object.fromEntries(Object.entries(symbols).map(([name, definition]) => [name, createFunction(lib, name, definition)])),
+        createCallback(callback, definition) {
+          if (closed) {
+            throw new Error(LIBRARY_CLOSED);
+          }
+          const raw = createRawCallback(callback, definition);
+          const managed = createManagedCallback(raw, callbacks);
+          callbacks.add(managed);
+          return managed;
+        },
+        close() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            lib.unload();
+          } finally {
+            for (const callback of [...callbacks]) {
+              callback.close();
+            }
+          }
+        }
+      };
+    },
+    ptr(value) {
+      if (isArrayBufferView(value)) {
+        if (!isArrayBuffer(value.buffer)) {
+          throw new TypeError(NODE_PTR_VALUE);
+        }
+        return offsetPointer(unsafePointerOf(value.buffer), value.byteOffset);
+      }
+      if (isAnyArrayBuffer(value)) {
+        return unsafePointerOf(value);
+      }
+      throw new TypeError(NODE_PTR_VALUE);
+    },
+    suffix: koffi.extension.slice(1),
+    toArrayBuffer: unsafeArrayBufferAt
+  };
+}
+function loadNode22Modules() {
+  const koffiModule = requireModule("koffi");
+  const unsafePointerModule = requireModule("unsafe-pointer");
+  return {
+    koffi: koffiModule.default ?? koffiModule,
+    unsafePointerOf: unsafePointerModule.unsafePointerOf,
+    unsafeArrayBufferAt: unsafePointerModule.unsafeArrayBufferAt
+  };
+}
+function createManagedCallback(raw, callbacks) {
+  let ptr = raw.ptr;
+  let closed = false;
+  const instance = {
+    get ptr() {
+      return ptr;
+    },
+    get threadsafe() {
+      return raw.threadsafe;
+    },
+    close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      callbacks.delete(instance);
+      try {
+        raw.close();
+      } finally {
+        ptr = null;
+      }
+    }
+  };
+  return instance;
+}
+function getTypeIndices(types, predicate) {
+  const indices = [];
+  for (let index = 0;index < (types?.length ?? 0); index++) {
+    if (predicate(types?.[index])) {
+      indices.push(index);
+    }
+  }
+  return indices;
+}
+function isPointerType(type) {
+  return type === "ptr" || type === "pointer" || type === "function" || type === "callback";
+}
+function isBoolType(type) {
+  return type === "bool";
+}
+function isBigIntType(type) {
+  return type === "int64_t" || type === "i64" || type === "uint64_t" || type === "u64" || type === "usize";
+}
+function pointerArgToKoffiArg(arg) {
+  if (typeof arg === "number") {
+    return BigInt(arg);
+  }
+  if (typeof arg === "bigint") {
+    return arg;
+  }
+  if ((isArrayBufferView(arg) || isAnyArrayBuffer(arg)) && arg.byteLength === 0) {
+    return emptyPtrSentinel;
+  }
+  return arg;
+}
+function koffiPointerToPointer(koffi, pointer) {
+  if (pointer === null) {
+    return 0;
+  }
+  if (typeof pointer === "object") {
+    return toSafeNumberPointer(koffi.address(pointer));
+  }
+  return toSafeNumberPointer(pointer);
+}
+function offsetPointer(pointer, offset) {
+  return toSafeNumberPointer(BigInt(pointer) + BigInt(offset));
+}
+function toSafeNumberPointer(pointer) {
+  if (typeof pointer === "number") {
+    if (pointer < 0) {
+      throw new Error(POINTER_NEGATIVE);
+    }
+    if (!Number.isSafeInteger(pointer)) {
+      throw new Error(POINTER_UNSAFE);
+    }
+    return pointer;
+  }
+  if (pointer < 0n) {
+    throw new Error(POINTER_NEGATIVE);
+  }
+  if (pointer > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(POINTER_UNSAFE);
+  }
+  return Number(pointer);
+}
+function unsupportedNode22FFIType(type) {
+  throw new Error(`Unsupported FFIType for Node 22 koffi backend: ${String(type)}`);
+}
+
+// src/platform/ffi.ts
+var FFIType = {
+  char: "char",
+  int8_t: "int8_t",
+  i8: "i8",
+  uint8_t: "uint8_t",
+  u8: "u8",
+  int16_t: "int16_t",
+  i16: "i16",
+  uint16_t: "uint16_t",
+  u16: "u16",
+  int32_t: "int32_t",
+  i32: "i32",
+  int: "int",
+  uint32_t: "uint32_t",
+  u32: "u32",
+  int64_t: "int64_t",
+  i64: "i64",
+  uint64_t: "uint64_t",
+  u64: "u64",
+  double: "double",
+  f64: "f64",
+  float: "float",
+  f32: "f32",
+  bool: "bool",
+  ptr: "ptr",
+  pointer: "pointer",
+  void: "void",
+  cstring: "cstring",
+  function: "function",
+  usize: "usize",
+  callback: "callback",
+  napi_env: "napi_env",
+  napi_value: "napi_value",
+  buffer: "buffer"
+};
+var FFI_UNAVAILABLE = "OpenTUI native FFI is not available for this runtime yet";
+var BUN_DLOPEN_NULL = "Bun FFI backend does not support dlopen(null)";
+var LIBRARY_CLOSED = "Cannot create FFI callback after library.close() has been called";
+var NODE_CALLBACK_THREADSAFE = "Node FFI callbacks are same-thread only and do not support threadsafe callbacks";
+var NODE_NAPI_UNSUPPORTED = "Node FFI backend does not support Bun N-API FFI types";
+var NODE_POINTER_OVERRIDE = "Node FFI backend does not support FFIFunction.ptr overrides";
+var NODE_PTR_VALUE = "node:ffi ptr() only supports ArrayBuffer and ArrayBufferView values backed by ArrayBuffer";
+var NODE_STRING_RETURN = "Node FFI backend does not normalize string return values (yet)";
+var NODE_USIZE_UNSUPPORTED = "Node FFI backend does not support usize until (yet)";
+var POINTER_NEGATIVE = "Pointer must be non-negative";
+var POINTER_UNSAFE = "Pointer exceeds safe integer range";
+function unavailable(cause) {
+  throw new Error(FFI_UNAVAILABLE, { cause });
+}
+function createUnsupportedBackend(cause) {
+  return {
+    dlopen() {
+      return unavailable(cause);
+    },
+    ptr() {
+      return unavailable(cause);
+    },
+    suffix: "",
+    toArrayBuffer() {
+      return unavailable(cause);
+    }
+  };
+}
+var isBun = typeof process !== "undefined" && typeof process.versions === "object" && process.versions !== null && typeof process.versions.bun === "string";
+var requireModule2 = createRequire2(import.meta.url);
+var backend = loadBackend();
+function loadBackend() {
+  if (isBun) {
+    return createBunBackend(requireModule2("bun:ffi"));
+  }
+  try {
+    const nodeFfi = requireModule2("node:ffi");
+    return createNodeBackend(nodeFfi.default ?? nodeFfi);
+  } catch (error) {
+    try {
+      return createNode22Backend();
+    } catch (fallbackError) {
+      return createUnsupportedBackend(fallbackError ?? error);
+    }
+  }
+}
+function toPointer(value) {
+  if (isBun && typeof value === "bigint") {
+    return toSafeNumberPointer2(value);
+  }
+  if (!isBun && typeof value === "number") {
+    return toSafeBigIntPointer(value);
+  }
+  return value;
+}
+function ffiBool(value) {
+  return value ? 1 : 0;
+}
+function toSafeNumberPointer2(pointer) {
+  if (pointer < 0n) {
+    throw new Error(POINTER_NEGATIVE);
+  }
+  if (pointer > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(POINTER_UNSAFE);
+  }
+  return Number(pointer);
+}
+function toSafeBigIntPointer(pointer) {
+  if (pointer < 0) {
+    throw new Error(POINTER_NEGATIVE);
+  }
+  if (!Number.isSafeInteger(pointer)) {
+    throw new Error(POINTER_UNSAFE);
+  }
+  return BigInt(pointer);
+}
+function createManagedCallback2(raw, callbacks) {
+  let ptr = raw.ptr;
+  let closed = false;
+  const instance = {
+    get ptr() {
+      return ptr;
+    },
+    get threadsafe() {
+      return raw.threadsafe;
+    },
+    close() {
+      if (closed) {
+        return;
+      }
+      closed = true;
+      callbacks.delete(instance);
+      try {
+        raw.close();
+      } finally {
+        ptr = null;
+      }
+    }
+  };
+  callbacks.add(instance);
+  return instance;
+}
+function normalizeBunDefinitions(definitions) {
+  return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, normalizeBunDefinition(definition)]));
+}
+function normalizeBunDefinition(definition) {
+  return {
+    args: definition.args,
+    returns: definition.returns,
+    ptr: definition.ptr == null ? undefined : toBunPointer(definition.ptr),
+    threadsafe: definition.threadsafe
+  };
+}
+function toBunPointer(pointer) {
+  return typeof pointer === "bigint" ? toSafeNumberPointer2(pointer) : pointer;
+}
+function createBunBackend(bun) {
+  return {
+    dlopen(path, symbols) {
+      if (path === null) {
+        throw new Error(BUN_DLOPEN_NULL);
+      }
+      const library = bun.dlopen(path, normalizeBunDefinitions(symbols));
+      const callbacks = new Set;
+      let closed = false;
+      return {
+        symbols: library.symbols,
+        createCallback(callback, definition) {
+          if (closed) {
+            throw new Error(LIBRARY_CLOSED);
+          }
+          const raw = new bun.JSCallback(callback, normalizeBunDefinition(definition));
+          return createManagedCallback2(raw, callbacks);
+        },
+        close() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            library.close();
+          } finally {
+            for (const callback of [...callbacks]) {
+              callback.close();
+            }
+          }
+        }
+      };
+    },
+    ptr: bun.ptr,
+    suffix: bun.suffix,
+    toArrayBuffer(pointer, offset, length) {
+      return bun.toArrayBuffer(toBunPointer(pointer), offset, length);
+    }
+  };
+}
+function createNodeBackend(nodeFfi) {
+  return {
+    dlopen(path, symbols) {
+      const { lib, functions } = nodeFfi.dlopen(toNodeLibraryPath(path), normalizeNodeDefinitions(symbols));
+      const callbacks = new Set;
+      let closed = false;
+      let libraryClosed = false;
+      return {
+        symbols: functions,
+        createCallback(callback, definition) {
+          if (closed) {
+            throw new Error(LIBRARY_CLOSED);
+          }
+          if (definition.threadsafe) {
+            throw new Error(NODE_CALLBACK_THREADSAFE);
+          }
+          const callbackPointer = lib.registerCallback(normalizeNodeDefinition(definition), callback);
+          const raw = {
+            ptr: callbackPointer,
+            threadsafe: false,
+            close() {
+              if (!libraryClosed) {
+                lib.unregisterCallback(callbackPointer);
+              }
+            }
+          };
+          return createManagedCallback2(raw, callbacks);
+        },
+        close() {
+          if (closed) {
+            return;
+          }
+          closed = true;
+          try {
+            libraryClosed = true;
+            lib.close();
+          } finally {
+            for (const callback of [...callbacks]) {
+              callback.close();
+            }
+          }
+        }
+      };
+    },
+    ptr(value) {
+      if (ArrayBuffer.isView(value)) {
+        if (!(value.buffer instanceof ArrayBuffer)) {
+          throw new TypeError(NODE_PTR_VALUE);
+        }
+        return nodeFfi.getRawPointer(value.buffer) + BigInt(value.byteOffset);
+      }
+      if (value instanceof ArrayBuffer) {
+        return nodeFfi.getRawPointer(value);
+      }
+      throw new TypeError(NODE_PTR_VALUE);
+    },
+    suffix: nodeFfi.suffix,
+    toArrayBuffer(pointer, offset, length) {
+      return nodeFfi.toArrayBuffer(toBigIntPointer(pointer) + BigInt(offset ?? 0), length, false);
+    }
+  };
+}
+function toNodeLibraryPath(path) {
+  return path instanceof URL ? fileURLToPath2(path) : path;
+}
+function normalizeNodeDefinitions(definitions) {
+  return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [name, normalizeNodeDefinition(definition)]));
+}
+function normalizeNodeDefinition(definition) {
+  if (definition.ptr != null) {
+    throw new Error(NODE_POINTER_OVERRIDE);
+  }
+  return {
+    parameters: (definition.args ?? []).map((type) => toNodeFFIType(type, "parameter")),
+    result: toNodeFFIType(definition.returns ?? FFIType.void, "result")
+  };
+}
+function toNodeFFIType(type, position) {
+  switch (type) {
+    case FFIType.char:
+      return "char";
+    case FFIType.int8_t:
+    case FFIType.i8:
+      return "i8";
+    case FFIType.uint8_t:
+    case FFIType.u8:
+      return "u8";
+    case FFIType.int16_t:
+    case FFIType.i16:
+      return "i16";
+    case FFIType.uint16_t:
+    case FFIType.u16:
+      return "u16";
+    case FFIType.int32_t:
+    case FFIType.int:
+    case FFIType.i32:
+      return "i32";
+    case FFIType.uint32_t:
+    case FFIType.u32:
+      return "u32";
+    case FFIType.int64_t:
+    case FFIType.i64:
+      return "i64";
+    case FFIType.uint64_t:
+    case FFIType.u64:
+      return "u64";
+    case FFIType.double:
+    case FFIType.f64:
+      return "f64";
+    case FFIType.float:
+    case FFIType.f32:
+      return "f32";
+    case FFIType.bool:
+      return "bool";
+    case FFIType.ptr:
+    case FFIType.pointer:
+      return "pointer";
+    case FFIType.void:
+      return "void";
+    case FFIType.cstring:
+      if (position === "result") {
+        throw new Error(NODE_STRING_RETURN);
+      }
+      return "string";
+    case FFIType.function:
+    case FFIType.callback:
+      return "pointer";
+    case FFIType.usize:
+      throw new Error(NODE_USIZE_UNSUPPORTED);
+    case FFIType.napi_env:
+    case FFIType.napi_value:
+      throw new Error(NODE_NAPI_UNSUPPORTED);
+    case FFIType.buffer:
+      return "buffer";
+    default:
+      return unsupportedNodeFFIType(type);
+  }
+}
+function unsupportedNodeFFIType(type) {
+  throw new Error(`Unsupported FFIType for node:ffi: ${String(type)}`);
+}
+function toBigIntPointer(pointer) {
+  if (typeof pointer === "bigint") {
+    if (pointer < 0n) {
+      throw new Error(POINTER_NEGATIVE);
+    }
+    return pointer;
+  }
+  return toSafeBigIntPointer(pointer);
+}
+var dlopen = backend.dlopen;
+var ptr = backend.ptr;
+var suffix = backend.suffix;
+var toArrayBuffer = backend.toArrayBuffer;
+
+export { toPointer, ffiBool, dlopen, ptr, toArrayBuffer };
+
+//# debugId=4F23A8FFF12D7B5A64756E2164756E21
+//# sourceMappingURL=index-5zwezmgj.js.map