@lingxia/rong 0.0.1

package/src/http.ts

@@ -0,0 +1,151 @@
+/**
+ * HTTP module type definitions
+ * Corresponds to: modules/rong_http
+ *
+ * The HTTP module provides the standard `fetch` API for making HTTP requests.
+ * It does NOT provide an `http` object or `download` function.
+ */
+
+export interface FetchOptions {
+  method?: string;
+  headers?: HeadersInit | Headers;
+  body?: BodyInit | null;
+  signal?: AbortSignal | null;
+  redirect?: 'follow' | 'error' | 'manual';
+}
+
+export interface FetchResponse {
+  /** HTTP status code */
+  readonly status: number;
+
+  /** HTTP status text */
+  readonly statusText: string;
+
+  /** Whether the response was successful (status in 200-299) */
+  readonly ok: boolean;
+
+  /** Response headers */
+  readonly headers: Headers;
+
+  /** Whether the response body has been read */
+  readonly bodyUsed: boolean;
+
+  /** Response type */
+  readonly type: string;
+
+  /** Whether the response was redirected */
+  readonly redirected: boolean;
+
+  /** Response URL */
+  readonly url: string;
+
+  /** Parse response body as text */
+  text(): Promise<string>;
+
+  /** Parse response body as JSON */
+  json<T = any>(): Promise<T>;
+
+  /** Get response body as ArrayBuffer */
+  arrayBuffer(): Promise<ArrayBuffer>;
+
+  /** Get response body as Blob */
+  blob(): Promise<Blob>;
+
+  /** Get response body as FormData */
+  formData(): Promise<FormData>;
+
+  /** Get response body as ReadableStream */
+  readonly body: ReadableStream<Uint8Array> | null;
+}
+
+declare global {
+  /**
+   * Fetch API - Make HTTP requests
+   *
+   * @example
+   * ```typescript
+   * const response = await fetch('https://api.example.com/data', {
+   *   method: 'POST',
+   *   headers: { 'Content-Type': 'application/json' },
+   *   body: JSON.stringify({ key: 'value' })
+   * });
+   * const data = await response.json();
+   * ```
+   */
+  function fetch(url: RequestInfo | URL, options?: RequestInit): Promise<Response>;
+
+}
+
+export {};
+
+export type BodyInit =
+  | string
+  | Blob
+  | ArrayBuffer
+  | ArrayBufferView
+  | FormData
+  | URLSearchParams
+  | ReadableStream<Uint8Array>;
+
+export interface Body {
+  /** Consumes the body and returns a promise that resolves with a Blob */
+  blob(): Promise<Blob>;
+  /** Consumes the body and returns a promise that resolves with a FormData */
+  formData(): Promise<FormData>;
+  /** Consumes the body and returns a promise that resolves with the result of parsing the body text as JSON */
+  json<T = any>(): Promise<T>;
+  /** Consumes the body and returns a promise that resolves with the result of parsing the body text as a String */
+  text(): Promise<string>;
+  /** Consumes the body and returns a promise that resolves with an ArrayBuffer */
+  arrayBuffer(): Promise<ArrayBuffer>;
+  /** Returns a boolean indicating whether body has been consumed */
+  readonly bodyUsed: boolean;
+  /** The body content */
+  readonly body: ReadableStream<Uint8Array> | null;
+}
+
+export interface RequestInit {
+  method?: string;
+  headers?: HeadersInit | Headers;
+  body?: BodyInit | null;
+  redirect?: 'follow' | 'error' | 'manual';
+  signal?: AbortSignal | null;
+}
+
+export interface Request extends Body {
+  readonly method: string;
+  readonly headers: Headers;
+  readonly redirect: string;
+  readonly signal: AbortSignal | null;
+  readonly url: string;
+  clone(): Request;
+}
+
+export interface RequestConstructor {
+  new(input: RequestInfo | string, init?: RequestInit): Request;
+  prototype: Request;
+}
+
+export type RequestInfo = string | Request | URL;
+
+export type HeadersInit = Record<string, string> | Array<[string, string]> | Headers;
+
+export interface Headers {
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  get(name: string): string | null;
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  forEach(callback: (value: string, name: string, self: Headers) => void, thisArg?: any): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+
+  /** Returns all Set-Cookie values (Rong extension) */
+  getSetCookie(): string[];
+}
+
+export interface HeadersConstructor {
+  new(init?: HeadersInit): Headers;
+  prototype: Headers;
+}

package/src/index.ts

@@ -0,0 +1,67 @@
+/**
+ * Rong JavaScript Runtime Type Definitions
+ *
+ * This package provides TypeScript type definitions for all Rust-driven
+ * JavaScript APIs in the Rong runtime.
+ *
+ * ## Quick Start
+ *
+ * Add to your tsconfig.json:
+ * ```json
+ * {
+ *   "compilerOptions": {
+ *     "types": ["@lingxia/rong"]
+ *   }
+ * }
+ * ```
+ *
+ * Then use the global APIs:
+ * ```typescript
+ * // File system
+ * const text = await Rong.readTextFile('/path/to/file.txt');
+ * await Rong.writeTextFile('/output.txt', 'Hello World');
+ *
+ * // Process
+ * console.log(process.pid);
+ * console.log(process.env.PATH);
+ *
+ * // HTTP
+ * const response = await fetch('https://api.example.com');
+ *
+ * // Child process
+ * const child = child_process.spawn('ls', ['-la']);
+ * ```
+ *
+ * For detailed API documentation, see individual module exports below.
+ */
+
+// Global API declarations - Import this for full IDE autocomplete
+import './global';
+
+// Core runtime modules
+export * from './process';
+export * from './child_process';
+export * from './stream';
+export * from './encoding';
+export * from './storage';
+export * from './http';
+
+// File system
+export * from './fs';
+
+// Web APIs
+export * from './url';
+export * from './buffer';
+export * from './event';
+export * from './abort';
+export * from './exception';
+
+// Utility modules
+export * from './navigator';
+export * from './timer';
+export * from './path';
+export * from './assert';
+export * from './console';
+
+// Error types
+export * from './error';

package/src/navigator.ts

@@ -0,0 +1,20 @@
+/**
+ * Navigator module type definitions
+ * Corresponds to: modules/rong_navigator
+ */
+
+// Extend the global Navigator interface with Rong-specific properties
+declare global {
+  interface Navigator {
+    /** User agent string */
+    readonly userAgent: string;
+
+    /** Platform identifier (e.g., "macos", "linux", "windows") */
+    readonly platform: string;
+
+    /** CPU architecture (e.g., "x86_64", "aarch64") */
+    readonly arch: string;
+  }
+}
+
+export {};

package/src/path.ts

@@ -0,0 +1,83 @@
+/**
+ * Path module type definitions
+ * Corresponds to: modules/rong_path
+ */
+
+export interface ParsedPath {
+  /** Root directory (e.g., "/" on Unix, "C:\\" on Windows) */
+  root: string;
+  /** Directory path */
+  dir: string;
+  /** File name with extension */
+  base: string;
+  /** File extension (including the dot) */
+  ext: string;
+  /** File name without extension */
+  name: string;
+}
+
+export interface PathModule {
+  /**
+   * Returns the last portion of a path
+   * @param path - The path to process
+   * @param suffix - Optional suffix to remove from the result
+   */
+  basename(path: string, suffix?: string): string;
+
+  /**
+   * Returns the directory name of a path
+   * @param path - The path to process
+   */
+  dirname(path: string): string;
+
+  /**
+   * Returns the extension of a path (including the dot)
+   * @param path - The path to process
+   */
+  extname(path: string): string;
+
+  /**
+   * Determines whether a path is absolute
+   * @param path - The path to check
+   */
+  isAbsolute(path: string): boolean;
+
+  /**
+   * Joins path segments together
+   * @param paths - Path segments to join
+   */
+  join(...paths: string[]): string;
+
+  /**
+   * Normalizes a path by resolving '..' and '.' segments
+   * @param path - The path to normalize
+   */
+  normalize(path: string): string;
+
+  /**
+   * Resolves a sequence of paths to an absolute path
+   * @param paths - Paths to resolve
+   */
+  resolve(...paths: string[]): string;
+
+  /**
+   * Parses a path into an object
+   * @param path - The path to parse
+   */
+  parse(path: string): ParsedPath;
+
+  /**
+   * Formats a path object into a path string
+   * @param pathObject - Path object to format
+   */
+  format(pathObject: Partial<ParsedPath>): string;
+
+  /** Platform-specific path segment separator ("/" on Unix, "\\" on Windows) */
+  readonly sep: string;
+
+  /** Platform-specific PATH delimiter (":" on Unix, ";" on Windows) */
+  readonly delimiter: string;
+}
+
+// Note: path is declared as a global in global.d.ts
+export {};

package/src/process.ts

@@ -0,0 +1,74 @@
+/**
+ * Process module type definitions
+ * Corresponds to: modules/rong_process
+ */
+
+import type { EventEmitter } from './event';
+
+export interface ProcessEnv {
+  [key: string]: string | undefined;
+}
+
+export interface ProcessStdin extends ReadableStream<Uint8Array> {
+  readonly isTTY: boolean;
+}
+
+export interface ProcessStdout {
+  write(data: string): boolean;
+  readonly isTTY: boolean;
+}
+
+export interface ProcessStderr {
+  write(data: string): boolean;
+  readonly isTTY: boolean;
+}
+
+export interface Process extends EventEmitter {
+  /** Process ID */
+  readonly pid: number;
+
+  /** Current working directory */
+  cwd(): string;
+
+  /** Change working directory */
+  chdir(directory: string): void;
+
+  /** Environment variables */
+  readonly env: ProcessEnv;
+
+  /** Platform (e.g., 'darwin', 'linux', 'win32') */
+  readonly platform: string;
+
+  /** CPU architecture (e.g., 'x64', 'arm64') */
+  readonly arch: string;
+
+  /** Process version */
+  readonly version: string;
+
+  /** Command line arguments */
+  readonly argv: string[];
+
+  /** Exit the process */
+  exit(code?: number): never;
+
+  /** Process uptime in seconds */
+  uptime(): number;
+
+  /** High-resolution real time - returns [seconds, nanoseconds] since arbitrary point */
+  hrtime(prev?: [number, number]): [number, number];
+
+  /** Schedule callback for next tick (microtask) */
+  nextTick(callback: (...args: any[]) => void, ...args: any[]): void;
+
+  /** Standard input stream */
+  readonly stdin: ProcessStdin;
+
+  /** Standard output stream */
+  readonly stdout: ProcessStdout;
+
+  /** Standard error stream */
+  readonly stderr: ProcessStderr;
+}
+
+// Note: process is declared as a global in global.d.ts
+export {};

package/src/storage.ts

@@ -0,0 +1,64 @@
+/**
+ * Storage module type definitions
+ * Corresponds to: modules/rong_storage
+ *
+ * IMPORTANT: Storage is accessed via `Rong.storage.open(path)` or `new Rong.Storage(path)`
+ */
+
+export interface StorageInfo {
+  /** Current storage size in bytes */
+  currentSize: number;
+  /** Size limit in bytes */
+  limitSize: number;
+  /** Number of keys */
+  keyCount: number;
+}
+
+export interface Storage {
+  /** Set a key-value pair */
+  set(key: string, value: any): Promise<void>;
+
+  /** Get value by key */
+  get(key: string): Promise<any>;
+
+  /** Delete a key */
+  delete(key: string): Promise<void>;
+
+  /** Clear all items */
+  clear(): Promise<void>;
+
+  /** Get all keys (returns async iterator) */
+  list(prefix?: string): Promise<IterableIterator<string>>;
+
+  /** Get storage info */
+  info(): Promise<StorageInfo>;
+}
+
+export interface StorageConstructor {
+  /** Create a new Storage instance for the given database path */
+  new(path: string, options?: StorageOptionsInput): Storage;
+}
+
+export interface StorageOptionsInput {
+  maxKeySize?: number;
+  maxValueSize?: number;
+  maxDataSize?: number;
+}
+
+export interface StorageModule {
+  /**
+   * Open a storage database at the given path
+   * @param path - Path to the database file
+   * @returns Storage instance
+   *
+   * @example
+   * ```typescript
+   * const storage = Rong.storage.open('/path/to/db.sqlite');
+   * await storage.set('key', 'value');
+   * ```
+   */
+  open(path: string, options?: StorageOptionsInput): Promise<Storage>;
+}
+
+// Note: Storage is accessed via Rong.storage.open() or new Rong.Storage()
+export {};

package/src/stream.ts

@@ -0,0 +1,98 @@
+/**
+ * Stream module type definitions
+ * Corresponds to: modules/rong_stream
+ *
+ * Rong runtime provides the Web Streams API, which is a standard for handling
+ * streaming data in JavaScript. These APIs are globally available.
+ *
+ * ## Available Stream Types
+ *
+ * ### ReadableStream<T>
+ * Represents a readable stream of data.
+ *
+ * Usage:
+ * ```typescript
+ * // From file
+ * const file = await Rong.open('/path/to/file.txt', { read: true });
+ * const readable = file.readable;
+ *
+ * // Read from stream
+ * const reader = readable.getReader();
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   console.log('Received:', value);
+ * }
+ * ```
+ *
+ * ### WritableStream<T>
+ * Represents a writable stream of data.
+ *
+ * Usage:
+ * ```typescript
+ * // To file
+ * const file = await Rong.open('/path/to/output.txt', { write: true, create: true });
+ * const writable = file.writable;
+ *
+ * // Write to stream
+ * const writer = writable.getWriter();
+ * await writer.write(new TextEncoder().encode('Hello World'));
+ * await writer.close();
+ * ```
+ *
+ * ### TransformStream<I, O>
+ * Represents a transform stream for processing data.
+ *
+ * Usage:
+ * ```typescript
+ * // Pipe with transformation
+ * await readable
+ *   .pipeThrough(new TransformStream({
+ *     transform(chunk, controller) {
+ *       // Process chunk
+ *       controller.enqueue(processedChunk);
+ *     }
+ *   }))
+ *   .pipeTo(writable);
+ * ```
+ *
+ * ## Common Use Cases
+ *
+ * ### Pipe streams
+ * ```typescript
+ * // Pipe stdin to stdout
+ * await process.stdin.pipeTo(process.stdout);
+ *
+ * // Pipe file to file
+ * const source = await Rong.open('/source.txt', { read: true });
+ * const dest = await Rong.open('/dest.txt', { write: true, create: true });
+ * await source.readable.pipeTo(dest.writable);
+ * ```
+ *
+ * ### Process data in chunks
+ * ```typescript
+ * const file = await Rong.open('/large-file.txt', { read: true });
+ * const reader = file.readable.getReader();
+ *
+ * let totalBytes = 0;
+ * while (true) {
+ *   const { done, value } = await reader.read();
+ *   if (done) break;
+ *   totalBytes += value.byteLength;
+ *   // Process chunk...
+ * }
+ * console.log(`Processed ${totalBytes} bytes`);
+ * ```
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Streams_API
+ */
+
+// Stream types are provided globally by the DOM library
+// When you include "DOM" in tsconfig.json lib array, these types are available:
+// - ReadableStream<T>
+// - WritableStream<T>
+// - TransformStream<I, O>
+// - ReadableStreamDefaultReader<T>
+// - WritableStreamDefaultWriter<T>
+
+export {};

package/src/timer.ts

@@ -0,0 +1,61 @@
+/**
+ * Timer module type definitions
+ * Corresponds to: modules/rong_timer
+ */
+
+export type TimerCallback = () => void;
+export type TimerId = number;
+
+export interface TimersNamespace {
+  /**
+   * Promise-based timeout that resolves with a timestamp (ms since epoch).
+   */
+  setTimeout(delay?: number): Promise<number>;
+
+  /**
+   * Promise-based immediate that resolves with a timestamp (ms since epoch).
+   */
+  setImmediate(): Promise<number>;
+
+  /**
+   * Async iterator that yields timestamps (ms since epoch) on each interval tick.
+   */
+  setInterval(delay?: number): AsyncIterableIterator<number>;
+}
+
+declare global {
+  /**
+   * Set a timer that executes a callback once after a delay
+   * @param callback - Function to execute
+   * @param delay - Delay in milliseconds (default: 0)
+   * @returns Timer ID that can be used with clearTimeout
+   */
+  function setTimeout(callback: TimerCallback, delay?: number): TimerId;
+
+  /**
+   * Clear a timer set with setTimeout
+   * @param id - Timer ID returned by setTimeout
+   */
+  function clearTimeout(id: TimerId): void;
+
+  /**
+   * Set a timer that executes a callback repeatedly with a delay between executions
+   * @param callback - Function to execute
+   * @param delay - Delay in milliseconds between executions (default: 0)
+   * @returns Timer ID that can be used with clearInterval
+   */
+  function setInterval(callback: TimerCallback, delay?: number): TimerId;
+
+  /**
+   * Clear a timer set with setInterval
+   * @param id - Timer ID returned by setInterval
+   */
+  function clearInterval(id: TimerId): void;
+
+  /**
+   * Promise-based timer namespace
+   */
+  const timers: TimersNamespace;
+}
+
+export {};