@solidrt/flux-types 0.0.11 → 0.0.14

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@solidrt/flux-types",
-  "version": "0.0.11",
+  "version": "0.0.14",
   "license": "MIT",
   "author": "Antoine van Wel",
   "types": "index.d.ts",
   "files": [
     "index.d.ts",
+    "modules",
+    "gui",
+    "standards",
     "README.md",
     "LICENSE"
   ]

package/standards/console.d.ts

@@ -0,0 +1,10 @@
+// The web-standard `console` global. flux provides exactly these four methods
+// (no info/trace/table/group/...). A global script file: these declarations
+// stand in for the ones lib.dom would otherwise supply.
+
+declare let console: {
+  debug(...args: any[]): void
+  log(...args: any[]): void
+  warn(...args: any[]): void
+  error(...args: any[]): void
+}

package/standards/fetch.d.ts

@@ -0,0 +1,104 @@
+// The Fetch API cluster (Headers, Request, Response, fetch). A deliberate subset
+// of the WHATWG Fetch standard: flux provides exactly these members and no more
+// (no Blob, FormData, ReadableStream, arrayBuffer(), clone(), AbortSignal, ...).
+// Grouped in one file because the four share BodyInit/HeadersInit and reference
+// each other.
+
+/** Header initializer: a plain name -> value object, or another Headers. */
+type HeadersInit = Record<string, string> | Headers
+
+/**
+ * A message body: a string, raw bytes, or an async-iterable of string/byte
+ * chunks (e.g. an `async function*`), which is sent as a stream.
+ */
+type BodyInit = string | Uint8Array | AsyncIterable<string | Uint8Array>
+
+/** A subset of the WHATWG Headers API. Names are case-insensitive. */
+interface Headers {
+  /** The value for `name` (multiple values comma-joined), or null if absent. */
+  get(name: string): string | null
+  /** Set `name` to `value`, replacing any existing values. */
+  set(name: string, value: string): void
+  /** Whether any value for `name` exists. */
+  has(name: string): boolean
+  /** Remove `name`. */
+  delete(name: string): void
+  /** Add a value for `name` without replacing existing ones. */
+  append(name: string, value: string): void
+}
+
+declare let Headers: {
+  new (init?: HeadersInit): Headers
+}
+
+interface RequestInit {
+  /** HTTP method; uppercased. Defaults to "GET". */
+  method?: string
+  /** Request body. */
+  body?: BodyInit | null
+  /** Request headers. */
+  headers?: HeadersInit
+}
+
+/**
+ * A subset of the WHATWG Request. flux adds `params` (route params) for requests
+ * the `flux:http` server passes to handlers. The body is read-once.
+ */
+interface Request {
+  readonly method: string
+  readonly url: string
+  readonly headers: Headers
+  /** Route params from the matched pattern; an empty object for a JS-constructed Request. */
+  readonly params: Record<string, string>
+  /** The body as an async-iterable of byte chunks (read once). */
+  readonly body: AsyncIterable<Uint8Array>
+  /** Read the whole body as UTF-8 text. */
+  text(): Promise<string>
+  /** Read the whole body as raw bytes. */
+  bytes(): Promise<Uint8Array>
+  /** Read and parse the whole body as JSON. */
+  json(): Promise<any>
+}
+
+declare let Request: {
+  new (url: string, init?: RequestInit): Request
+}
+
+interface ResponseInit {
+  /** Status code. Defaults to 200. */
+  status?: number
+  /** Status text. */
+  statusText?: string
+  /** Response headers. */
+  headers?: HeadersInit
+}
+
+/** A subset of the WHATWG Response. The body is read-once. */
+interface Response {
+  readonly status: number
+  readonly statusText: string
+  /** True when `status` is in the range 200..299. */
+  readonly ok: boolean
+  readonly url: string
+  readonly headers: Headers
+  /** The body as an async-iterable of byte chunks (read once). */
+  readonly body: AsyncIterable<Uint8Array>
+  /** Read the whole body as UTF-8 text. */
+  text(): Promise<string>
+  /** Read the whole body as raw bytes. */
+  bytes(): Promise<Uint8Array>
+  /** Read and parse the whole body as JSON. */
+  json(): Promise<any>
+}
+
+declare let Response: {
+  new (body?: BodyInit | null, init?: ResponseInit): Response
+  /** Build a JSON response (sets Content-Type to application/json when unset). */
+  json(data: any, init?: ResponseInit): Response
+}
+
+/**
+ * Fetch a resource over HTTP(S). The body may be a string, Uint8Array, or an
+ * async-iterable (streamed). Resolves to a {@link Response}.
+ */
+declare function fetch(url: string, options?: RequestInit): Promise<Response>

package/standards/text.d.ts

@@ -0,0 +1,47 @@
+// TextEncoder / TextDecoder. UTF-8 only (the only encoding the runtime needs).
+
+interface TextEncoder {
+  /** Always "utf-8". */
+  readonly encoding: string
+  /** Encode `input` (default "") to its UTF-8 bytes. */
+  encode(input?: string): Uint8Array
+}
+
+declare let TextEncoder: {
+  new (): TextEncoder
+}
+
+/** Options for the {@link TextDecoder} constructor. */
+interface TextDecoderOptions {
+  /** Throw on invalid UTF-8 instead of substituting U+FFFD. */
+  fatal?: boolean
+  /** Keep a leading byte-order mark instead of stripping it. */
+  ignoreBOM?: boolean
+}
+
+/** Options for {@link TextDecoder.decode}. */
+interface TextDecodeOptions {
+  /** Hold an incomplete trailing UTF-8 sequence for the next call. */
+  stream?: boolean
+}
+
+interface TextDecoder {
+  /** Always "utf-8". */
+  readonly encoding: string
+  readonly fatal: boolean
+  readonly ignoreBOM: boolean
+  /**
+   * Decode UTF-8 `input` (a Uint8Array or ArrayBuffer; default empty) to a
+   * string. With `{ stream: true }`, an incomplete trailing sequence is held for
+   * the next call.
+   */
+  decode(input?: Uint8Array | ArrayBuffer, options?: TextDecodeOptions): string
+}
+
+declare let TextDecoder: {
+  /**
+   * `label` must be a UTF-8 encoding label (the runtime is UTF-8 only); any other
+   * label throws a RangeError.
+   */
+  new (label?: string, options?: TextDecoderOptions): TextDecoder
+}

package/standards/time.d.ts

@@ -0,0 +1,31 @@
+// Timers, microtask scheduling, and the monotonic clock. flux's timers differ
+// from the browser in two ways: the delay is required, and no extra callback
+// arguments are forwarded.
+
+/**
+ * Run `callback` after at least `ms` milliseconds. Returns a timer id for
+ * {@link clearTimeout}.
+ */
+declare function setTimeout(callback: () => void, ms: number): number
+/** Cancel a pending timeout. Throws on an unknown id. */
+declare function clearTimeout(id: number): void
+/**
+ * Run `callback` every `ms` milliseconds. Returns a timer id for
+ * {@link clearInterval}.
+ */
+declare function setInterval(callback: () => void, ms: number): number
+/** Cancel a running interval. Throws on an unknown id. */
+declare function clearInterval(id: number): void
+/**
+ * Queue `callback` to run as a microtask: after the current job finishes, before
+ * any timer fires.
+ */
+declare function queueMicrotask(callback: () => void): void
+
+declare let performance: {
+  /**
+   * Milliseconds since a monotonic origin (high-resolution, not wall-clock). Use
+   * for measuring durations, not for calendar time.
+   */
+  now(): number
+}

package/standards/websocket.d.ts

@@ -0,0 +1,62 @@
+// The web-standard WebSocket client. A deliberate subset: handler properties
+// only (no addEventListener), plain-object events (not Event instances), ws://
+// only (wss:// is not supported yet), and send accepts only string or Uint8Array.
+
+/** The event passed to {@link WebSocket.onopen}. */
+interface WebSocketOpenEvent {
+  type: "open"
+}
+
+/** The event passed to {@link WebSocket.onmessage}. */
+interface WebSocketMessageEvent {
+  type: "message"
+  /** Text frames arrive as a string, binary frames as a Uint8Array. */
+  data: string | Uint8Array
+}
+
+/** The event passed to {@link WebSocket.onerror}. */
+interface WebSocketErrorEvent {
+  type: "error"
+  message: string
+}
+
+/** The event passed to {@link WebSocket.onclose}. */
+interface WebSocketCloseEvent {
+  type: "close"
+  code: number
+  reason: string
+  wasClean: boolean
+}
+
+interface WebSocket {
+  readonly url: string
+  /** Connection state: CONNECTING 0, OPEN 1, CLOSING 2, CLOSED 3. */
+  readonly readyState: number
+  onopen: ((event: WebSocketOpenEvent) => void) | null
+  onmessage: ((event: WebSocketMessageEvent) => void) | null
+  onerror: ((event: WebSocketErrorEvent) => void) | null
+  onclose: ((event: WebSocketCloseEvent) => void) | null
+  /**
+   * Queue a message: a string sends a text frame, a Uint8Array a binary frame.
+   * Throws while CONNECTING; dropped once the socket is closing or closed.
+   */
+  send(data: string | Uint8Array): void
+  /**
+   * Start the closing handshake. `code` must be 1000 or in 3000..4999; `reason`
+   * must be 123 bytes or fewer.
+   */
+  close(code?: number, reason?: string): void
+  readonly CONNECTING: 0
+  readonly OPEN: 1
+  readonly CLOSING: 2
+  readonly CLOSED: 3
+}
+
+declare let WebSocket: {
+  /** Open a connection. `url` must be ws:// (wss:// is not supported yet). */
+  new (url: string): WebSocket
+  readonly CONNECTING: 0
+  readonly OPEN: 1
+  readonly CLOSING: 2
+  readonly CLOSED: 3
+}