@yodaos-pkg/ink 0.1.0

package/dist/env.js

@@ -0,0 +1,336 @@
+let wasmExports = null;
+const allocationSizes = new Map();
+const textDecoder = new TextDecoder('utf-8', { fatal: false });
+const textEncoder = new TextEncoder();
+
+export function __setWasmInstance(exports) {
+  wasmExports = exports;
+}
+
+function requireWasm() {
+  if (!wasmExports) {
+    throw new Error('Wasm exports are not initialized');
+  }
+  return wasmExports;
+}
+
+function memoryBytes() {
+  return new Uint8Array(requireWasm().memory.buffer);
+}
+
+function memoryView() {
+  return new DataView(requireWasm().memory.buffer);
+}
+
+function readCString(ptr) {
+  ptr >>>= 0;
+  const bytes = memoryBytes();
+  let end = ptr;
+  while (end < bytes.length && bytes[end] !== 0) {
+    end += 1;
+  }
+  return textDecoder.decode(bytes.subarray(ptr, end));
+}
+
+function writeCString(ptr, maxBytes, value) {
+  ptr >>>= 0;
+  maxBytes >>>= 0;
+  if (maxBytes === 0) {
+    return textEncoder.encode(value).length;
+  }
+  const encoded = textEncoder.encode(value);
+  const bytes = memoryBytes();
+  const writeLen = Math.min(encoded.length, maxBytes - 1);
+  bytes.set(encoded.subarray(0, writeLen), ptr);
+  bytes[ptr + writeLen] = 0;
+  return encoded.length;
+}
+
+function trackedMalloc(size, align = 1) {
+  const wasm = requireWasm();
+  const normalizedSize = Math.max(1, size >>> 0);
+  const ptr = wasm.__wbindgen_export(normalizedSize, align >>> 0) >>> 0;
+  allocationSizes.set(ptr, normalizedSize);
+  return ptr;
+}
+
+function trackedFree(ptr) {
+  ptr >>>= 0;
+  if (ptr === 0) {
+    return;
+  }
+  const wasm = requireWasm();
+  const size = allocationSizes.get(ptr);
+  if (size === undefined) {
+    return;
+  }
+  allocationSizes.delete(ptr);
+  wasm.__wbindgen_export4(ptr, size, 1);
+}
+
+function consoleWrite(prefix, text) {
+  const value = prefix ? `${prefix}${text}` : text;
+  console.log(value);
+}
+
+function formatPrintf(fmtPtr) {
+  return readCString(fmtPtr);
+}
+
+function parseNumberPrefix(text) {
+  const trimmed = text.match(/^\s*/)?.[0] ?? '';
+  const rest = text.slice(trimmed.length);
+  const match = rest.match(
+    /^[+-]?(?:inf(?:inity)?|nan(?:\([^)]+\))?|(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?)/i,
+  );
+  if (!match) {
+    return { value: 0, consumed: 0 };
+  }
+  const literal = match[0];
+  return {
+    value: Number.parseFloat(literal),
+    consumed: trimmed.length + literal.length,
+  };
+}
+
+function dayOfYear(date) {
+  const start = Date.UTC(date.getUTCFullYear(), 0, 1);
+  const now = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+  return Math.floor((now - start) / 86400000);
+}
+
+export function __assert_fail(assertionPtr, filePtr, line, functionPtr) {
+  const assertion = readCString(assertionPtr);
+  const file = readCString(filePtr);
+  const func = readCString(functionPtr);
+  throw new Error(`assertion failed: ${assertion} at ${file}:${line} in ${func}`);
+}
+
+export function printf(fmtPtr, _argsPtr) {
+  const message = formatPrintf(fmtPtr);
+  consoleWrite('', message);
+  return message.length | 0;
+}
+
+export function abort() {
+  throw new Error('abort() called from wasm');
+}
+
+export function puts(ptr) {
+  const message = readCString(ptr);
+  consoleWrite('', message);
+  return message.length | 0;
+}
+
+export function putchar(ch) {
+  const value = String.fromCharCode(ch & 0xff);
+  consoleWrite('', value);
+  return ch | 0;
+}
+
+export function fprintf(_stream, fmtPtr, _argsPtr) {
+  const message = formatPrintf(fmtPtr);
+  consoleWrite('', message);
+  return message.length | 0;
+}
+
+export function fwrite(ptr, size, nmemb, _stream) {
+  const total = (size >>> 0) * (nmemb >>> 0);
+  const bytes = memoryBytes().subarray(ptr >>> 0, (ptr >>> 0) + total);
+  consoleWrite('', textDecoder.decode(bytes));
+  return nmemb | 0;
+}
+
+export function fputc(ch, _stream) {
+  return putchar(ch);
+}
+
+export function vsnprintf(dst, size, fmtPtr, _argsPtr) {
+  return writeCString(dst, size, formatPrintf(fmtPtr)) | 0;
+}
+
+export function snprintf(dst, size, fmtPtr, _arg3) {
+  return writeCString(dst, size, formatPrintf(fmtPtr)) | 0;
+}
+
+export function scalbn(x, n) {
+  return x * Math.pow(2, n | 0);
+}
+
+export function lrint(x) {
+  if (!Number.isFinite(x)) {
+    return 0;
+  }
+  return Math.round(x) | 0;
+}
+
+export function realloc(ptr, size) {
+  ptr >>>= 0;
+  size >>>= 0;
+  if (ptr === 0) {
+    return trackedMalloc(size);
+  }
+  const oldSize = allocationSizes.get(ptr) ?? 0;
+  const nextPtr = trackedMalloc(size);
+  if (oldSize > 0) {
+    const bytes = memoryBytes();
+    bytes.copyWithin(nextPtr, ptr, ptr + Math.min(oldSize, size));
+    trackedFree(ptr);
+  }
+  return nextPtr;
+}
+
+export function strchr(ptr, ch) {
+  ptr >>>= 0;
+  const target = ch & 0xff;
+  const bytes = memoryBytes();
+  for (let i = ptr; i < bytes.length; i += 1) {
+    const value = bytes[i];
+    if (value === target) {
+      return i >>> 0;
+    }
+    if (value === 0) {
+      return target === 0 ? i >>> 0 : 0;
+    }
+  }
+  return 0;
+}
+
+export function free(ptr) {
+  trackedFree(ptr);
+}
+
+export function strncmp(aPtr, bPtr, count) {
+  const bytes = memoryBytes();
+  let a = aPtr >>> 0;
+  let b = bPtr >>> 0;
+  const limit = count >>> 0;
+  for (let i = 0; i < limit; i += 1) {
+    const av = bytes[a + i] ?? 0;
+    const bv = bytes[b + i] ?? 0;
+    if (av !== bv) {
+      return av < bv ? -1 : 1;
+    }
+    if (av === 0) {
+      return 0;
+    }
+  }
+  return 0;
+}
+
+export function strcmp(aPtr, bPtr) {
+  const bytes = memoryBytes();
+  let a = aPtr >>> 0;
+  let b = bPtr >>> 0;
+  while (true) {
+    const av = bytes[a] ?? 0;
+    const bv = bytes[b] ?? 0;
+    if (av !== bv) {
+      return av < bv ? -1 : 1;
+    }
+    if (av === 0) {
+      return 0;
+    }
+    a += 1;
+    b += 1;
+  }
+}
+
+export function memchr(ptr, ch, count) {
+  ptr >>>= 0;
+  const target = ch & 0xff;
+  const limit = count >>> 0;
+  const bytes = memoryBytes();
+  for (let i = 0; i < limit; i += 1) {
+    if (bytes[ptr + i] === target) {
+      return (ptr + i) >>> 0;
+    }
+  }
+  return 0;
+}
+
+export function calloc(nmemb, size) {
+  const total = (nmemb >>> 0) * (size >>> 0);
+  const ptr = trackedMalloc(total);
+  memoryBytes().fill(0, ptr, ptr + total);
+  return ptr;
+}
+
+export function malloc(size) {
+  return trackedMalloc(size);
+}
+
+export function frexp(value, expPtr) {
+  if (value === 0 || !Number.isFinite(value)) {
+    memoryView().setInt32(expPtr >>> 0, 0, true);
+    return value;
+  }
+  const exponent = Math.floor(Math.log2(Math.abs(value))) + 1;
+  memoryView().setInt32(expPtr >>> 0, exponent, true);
+  return value / Math.pow(2, exponent);
+}
+
+export function strrchr(ptr, ch) {
+  ptr >>>= 0;
+  const target = ch & 0xff;
+  const bytes = memoryBytes();
+  let found = 0;
+  for (let i = ptr; i < bytes.length; i += 1) {
+    const value = bytes[i];
+    if (value === target) {
+      found = i >>> 0;
+    }
+    if (value === 0) {
+      return target === 0 ? i >>> 0 : found;
+    }
+  }
+  return found;
+}
+
+export function vfprintf(stream, fmtPtr, argsPtr) {
+  return fprintf(stream, fmtPtr, argsPtr);
+}
+
+export function strtod(ptr, endPtrPtr) {
+  const text = readCString(ptr);
+  const { value, consumed } = parseNumberPrefix(text);
+  if (endPtrPtr >>> 0 !== 0) {
+    memoryView().setUint32(endPtrPtr >>> 0, ((ptr >>> 0) + consumed) >>> 0, true);
+  }
+  return value;
+}
+
+export function localtime_r(timePtr, resultPtr) {
+  const view = memoryView();
+  const ptr = timePtr >>> 0;
+  let seconds = 0;
+  try {
+    seconds = Number(view.getBigInt64(ptr, true));
+  } catch {
+    seconds = view.getInt32(ptr, true);
+  }
+  const date = new Date(seconds * 1000);
+  const out = resultPtr >>> 0;
+  view.setInt32(out + 0, date.getSeconds(), true);
+  view.setInt32(out + 4, date.getMinutes(), true);
+  view.setInt32(out + 8, date.getHours(), true);
+  view.setInt32(out + 12, date.getDate(), true);
+  view.setInt32(out + 16, date.getMonth(), true);
+  view.setInt32(out + 20, date.getFullYear() - 1900, true);
+  view.setInt32(out + 24, date.getDay(), true);
+  view.setInt32(out + 28, dayOfYear(date), true);
+  view.setInt32(out + 32, 0, true);
+  return out;
+}
+
+export function acosh(x) {
+  return Math.acosh(x);
+}
+
+export function asinh(x) {
+  return Math.asinh(x);
+}
+
+export function atanh(x) {
+  return Math.atanh(x);
+}

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+export type BundleFileInput =
+  | string
+  | Uint8Array
+  | ArrayBuffer
+  | ArrayBufferView;
+
+export type BundleFiles =
+  | Map<string, BundleFileInput>
+  | Array<[string, BundleFileInput]>
+  | Record<string, BundleFileInput>;
+
+export interface InitInkOptions {
+  wasmUrl?: string | URL | Request;
+  moduleOrPath?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+}
+
+export interface CreateInkViewOptions {
+  width: number;
+  height: number;
+  scaleFactor?: number;
+  canvas?: HTMLCanvasElement;
+  wasm?: InitInkOptions;
+}
+
+export interface OpenBundleOptions {
+  appId: string;
+  files: BundleFiles;
+  initialPage?: string | null;
+  query?: string | Record<string, unknown> | null;
+}
+
+export interface LoadBundleFromVfsOptions {
+  appId: string;
+  baseUrl: string;
+  fetch?: typeof globalThis.fetch;
+  signal?: AbortSignal;
+  headers?: HeadersInit;
+}
+
+export interface OpenFromVfsOptions extends LoadBundleFromVfsOptions {
+  initialPage?: string | null;
+  query?: string | Record<string, unknown> | null;
+}
+
+export interface VfsManifestEntry {
+  path: string;
+  size?: number;
+  contentType?: string;
+  etag?: string;
+}
+
+export interface VfsManifest {
+  appId: string;
+  files: VfsManifestEntry[];
+}
+
+export interface LoadedVfsBundle {
+  appId: string;
+  manifest: VfsManifest;
+  files: Map<string, Uint8Array>;
+}
+
+export interface BindDomEventsOptions {
+  canvas?: HTMLCanvasElement;
+  keyboardTarget?: EventTarget | null;
+  focusTarget?: HTMLElement | HTMLCanvasElement | null;
+  preventWheelDefault?: boolean;
+}
+
+export declare function initInk(options?: InitInkOptions): Promise<{
+  InkWebView: unknown;
+  getInkVersion: () => string;
+}>;
+
+export declare function getInkVersion(): string;
+
+export declare function normalizeBundleFiles(files: BundleFiles): Map<string, Uint8Array>;
+
+export declare function serializeQuery(query: string | Record<string, unknown> | null | undefined): string | null;
+
+export declare function createVfsUrls(input: {
+  baseUrl: string;
+  appId: string;
+}): {
+  manifestUrl: string;
+  fileUrl(filePath: string): string;
+};
+
+export declare function loadBundleFromVfs(options: LoadBundleFromVfsOptions): Promise<LoadedVfsBundle>;
+
+export declare class InkView {
+  static create(options: CreateInkViewOptions): Promise<InkView>;
+  bindCanvas(canvas: HTMLCanvasElement): this;
+  bindDomEvents(options?: BindDomEventsOptions): () => void;
+  openBundle(options: OpenBundleOptions): this;
+  openFromVfs(options: OpenFromVfsOptions): Promise<LoadedVfsBundle>;
+  resize(width: number, height: number, scaleFactor?: number): this;
+  focus(): this;
+  blur(): this;
+  notifyUserInteraction(): this;
+  render(): boolean;
+  requestRender(): this;
+  startRendering(): this;
+  stopRendering(): this;
+  isRunning(): boolean;
+  destroy(): void;
+}
+
+export declare function createInkView(options: CreateInkViewOptions): Promise<InkView>;
+
+export declare function createFrameworkBindings(): {
+  ensureLeadingSlash(path: string): string;
+  initInk: typeof initInk;
+  createInkView: typeof createInkView;
+};