@openworkers/workers-types 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @openworkers/workers-types
+
+TypeScript types for the OpenWorkers runtime.
+
+## Installation
+
+```bash
+bun add -d @openworkers/workers-types
+```
+
+## Usage
+
+Add to your `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "types": ["@openworkers/workers-types"]
+  }
+}
+```
+
+Or use a triple-slash directive:
+
+```typescript
+/// <reference types="@openworkers/workers-types" />
+```
+
+## Structure
+
+- `types/fetch.d.ts` - Request, Response, Headers, fetch
+- `types/url.d.ts` - URL, URLSearchParams
+- `types/streams.d.ts` - ReadableStream, WritableStream
+- `types/crypto.d.ts` - Web Crypto API
+- `types/encoding.d.ts` - TextEncoder, TextDecoder, atob, btoa
+- `types/console.d.ts` - Console API
+- `types/timers.d.ts` - setTimeout, setInterval
+- `types/events.d.ts` - Event, EventTarget
+- `types/abort.d.ts` - AbortController, AbortSignal
+- `types/blob.d.ts` - Blob, File, FormData
+- `types/workers.d.ts` - ExecutionContext, ScheduledEvent, ExportedHandler
+- `types/bindings.d.ts` - BindingAssets, BindingStorage, BindingKV, BindingDatabase, BindingWorker

package/index.d.ts

@@ -0,0 +1,14 @@
+// OpenWorkers Runtime Types
+
+/// <reference path="./types/events.d.ts" />
+/// <reference path="./types/abort.d.ts" />
+/// <reference path="./types/streams.d.ts" />
+/// <reference path="./types/blob.d.ts" />
+/// <reference path="./types/url.d.ts" />
+/// <reference path="./types/fetch.d.ts" />
+/// <reference path="./types/encoding.d.ts" />
+/// <reference path="./types/crypto.d.ts" />
+/// <reference path="./types/console.d.ts" />
+/// <reference path="./types/timers.d.ts" />
+/// <reference path="./types/workers.d.ts" />
+/// <reference path="./types/bindings.d.ts" />

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@openworkers/workers-types",
+  "version": "0.1.0",
+  "description": "TypeScript types for the OpenWorkers runtime",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openworkers/workers-types"
+  },
+  "keywords": [
+    "openworkers",
+    "workers",
+    "typescript",
+    "types"
+  ],
+  "types": "index.d.ts",
+  "files": [
+    "index.d.ts",
+    "types/*.d.ts"
+  ],
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true
+  }
+}

package/types/abort.d.ts

@@ -0,0 +1,12 @@
+// AbortController API types
+
+interface AbortSignal extends EventTarget {
+  readonly aborted: boolean;
+  readonly reason: unknown;
+  throwIfAborted(): void;
+}
+
+declare class AbortController {
+  readonly signal: AbortSignal;
+  abort(reason?: unknown): void;
+}

package/types/bindings.d.ts

@@ -0,0 +1,52 @@
+// OpenWorkers Bindings types
+
+interface BindingAssets {
+  fetch(path: string, options?: RequestInit): Promise<Response>;
+}
+
+interface StorageHeadResult {
+  size: number;
+  etag?: string;
+}
+
+interface StorageListOptions {
+  prefix?: string;
+  limit?: number;
+}
+
+interface StorageListResult {
+  keys: string[];
+  truncated: boolean;
+}
+
+interface BindingStorage {
+  get(key: string): Promise<string | null>;
+  put(key: string, value: string | Uint8Array): Promise<void>;
+  head(key: string): Promise<StorageHeadResult>;
+  list(options?: StorageListOptions): Promise<StorageListResult>;
+  delete(key: string): Promise<void>;
+}
+
+interface KVPutOptions {
+  expiresIn?: number;
+}
+
+interface KVListOptions {
+  prefix?: string;
+  limit?: number;
+}
+
+interface BindingKV {
+  get(key: string): Promise<string | null>;
+  put(key: string, value: string, options?: KVPutOptions): Promise<void>;
+  delete(key: string): Promise<void>;
+  list(options?: KVListOptions): Promise<string[]>;
+}
+
+interface BindingDatabase {
+  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+}
+
+interface BindingWorker {
+  fetch(request: Request | string, init?: RequestInit): Promise<Response>;
+}

package/types/blob.d.ts

@@ -0,0 +1,36 @@
+// Blob & FormData API types
+
+declare class Blob {
+  constructor(
+    blobParts?: (ArrayBuffer | Uint8Array | Blob | string)[],
+    options?: { type?: string }
+  );
+  readonly size: number;
+  readonly type: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  slice(start?: number, end?: number, contentType?: string): Blob;
+  stream(): ReadableStream<Uint8Array>;
+  text(): Promise<string>;
+}
+
+interface File extends Blob {
+  readonly lastModified: number;
+  readonly name: string;
+}
+
+declare class FormData {
+  constructor();
+  append(name: string, value: string | Blob, filename?: string): void;
+  delete(name: string): void;
+  get(name: string): string | File | null;
+  getAll(name: string): (string | File)[];
+  has(name: string): boolean;
+  set(name: string, value: string | Blob, filename?: string): void;
+  forEach(
+    callback: (value: string | File, key: string, parent: FormData) => void
+  ): void;
+  entries(): IterableIterator<[string, string | File]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string | File>;
+  [Symbol.iterator](): IterableIterator<[string, string | File]>;
+}

package/types/console.d.ts

@@ -0,0 +1,15 @@
+// Console API types
+
+interface Console {
+  log(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  trace(...args: unknown[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
+  timeLog(label?: string, ...args: unknown[]): void;
+}
+
+declare var console: Console;

package/types/crypto.d.ts

@@ -0,0 +1,78 @@
+// Web Crypto API types
+
+interface SubtleCrypto {
+  digest(
+    algorithm: string | { name: string },
+    data: ArrayBuffer | Uint8Array
+  ): Promise<ArrayBuffer>;
+  encrypt(
+    algorithm: unknown,
+    key: CryptoKey,
+    data: ArrayBuffer | Uint8Array
+  ): Promise<ArrayBuffer>;
+  decrypt(
+    algorithm: unknown,
+    key: CryptoKey,
+    data: ArrayBuffer | Uint8Array
+  ): Promise<ArrayBuffer>;
+  sign(
+    algorithm: unknown,
+    key: CryptoKey,
+    data: ArrayBuffer | Uint8Array
+  ): Promise<ArrayBuffer>;
+  verify(
+    algorithm: unknown,
+    key: CryptoKey,
+    signature: ArrayBuffer | Uint8Array,
+    data: ArrayBuffer | Uint8Array
+  ): Promise<boolean>;
+  generateKey(
+    algorithm: unknown,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey | CryptoKeyPair>;
+  importKey(
+    format: string,
+    keyData: unknown,
+    algorithm: unknown,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey>;
+  exportKey(format: string, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
+  deriveBits(
+    algorithm: unknown,
+    baseKey: CryptoKey,
+    length: number
+  ): Promise<ArrayBuffer>;
+  deriveKey(
+    algorithm: unknown,
+    baseKey: CryptoKey,
+    derivedKeyType: unknown,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey>;
+}
+
+interface CryptoKey {
+  readonly algorithm: unknown;
+  readonly extractable: boolean;
+  readonly type: string;
+  readonly usages: string[];
+}
+
+interface CryptoKeyPair {
+  readonly privateKey: CryptoKey;
+  readonly publicKey: CryptoKey;
+}
+
+interface JsonWebKey {
+  [key: string]: unknown;
+}
+
+interface Crypto {
+  readonly subtle: SubtleCrypto;
+  getRandomValues<T extends ArrayBufferView>(array: T): T;
+  randomUUID(): string;
+}
+
+declare var crypto: Crypto;

package/types/encoding.d.ts

@@ -0,0 +1,21 @@
+// Encoding API types
+
+declare class TextEncoder {
+  readonly encoding: string;
+  encode(input?: string): Uint8Array;
+  encodeInto(
+    source: string,
+    destination: Uint8Array
+  ): { read: number; written: number };
+}
+
+declare class TextDecoder {
+  constructor(label?: string, options?: { fatal?: boolean; ignoreBOM?: boolean });
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+  decode(input?: ArrayBuffer | Uint8Array, options?: { stream?: boolean }): string;
+}
+
+declare function atob(data: string): string;
+declare function btoa(data: string): string;

package/types/events.d.ts

@@ -0,0 +1,48 @@
+// Event API types
+
+interface EventTarget {
+  addEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject | null,
+    options?: boolean | AddEventListenerOptions
+  ): void;
+  removeEventListener(
+    type: string,
+    listener: EventListenerOrEventListenerObject | null,
+    options?: boolean | EventListenerOptions
+  ): void;
+  dispatchEvent(event: Event): boolean;
+}
+
+interface Event {
+  readonly type: string;
+  readonly target: EventTarget | null;
+  readonly currentTarget: EventTarget | null;
+  readonly bubbles: boolean;
+  readonly cancelable: boolean;
+  readonly defaultPrevented: boolean;
+  readonly timeStamp: number;
+  preventDefault(): void;
+  stopPropagation(): void;
+  stopImmediatePropagation(): void;
+}
+
+interface EventListenerOptions {
+  capture?: boolean;
+}
+
+interface AddEventListenerOptions extends EventListenerOptions {
+  once?: boolean;
+  passive?: boolean;
+  signal?: AbortSignal;
+}
+
+interface EventListener {
+  (evt: Event): void;
+}
+
+interface EventListenerObject {
+  handleEvent(object: Event): void;
+}
+
+type EventListenerOrEventListenerObject = EventListener | EventListenerObject;

package/types/fetch.d.ts

@@ -0,0 +1,79 @@
+// Fetch API types
+
+type BodyInit =
+  | ReadableStream
+  | Blob
+  | ArrayBuffer
+  | Uint8Array
+  | FormData
+  | URLSearchParams
+  | string;
+
+type HeadersInit = Headers | Record<string, string> | [string, string][];
+
+declare class Headers {
+  constructor(init?: HeadersInit);
+  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, key: string, parent: Headers) => void): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
+interface RequestInit {
+  method?: string;
+  headers?: HeadersInit;
+  body?: BodyInit | null;
+  redirect?: "follow" | "error" | "manual";
+  signal?: AbortSignal;
+}
+
+declare class Request {
+  constructor(input: Request | string | URL, init?: RequestInit);
+  readonly method: string;
+  readonly url: string;
+  readonly headers: Headers;
+  readonly body: ReadableStream<Uint8Array> | null;
+  readonly bodyUsed: boolean;
+  clone(): Request;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  blob(): Promise<Blob>;
+  formData(): Promise<FormData>;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+}
+
+interface ResponseInit {
+  status?: number;
+  statusText?: string;
+  headers?: HeadersInit;
+}
+
+declare class Response {
+  constructor(body?: BodyInit | null, init?: ResponseInit);
+  static json(data: unknown, init?: ResponseInit): Response;
+  static redirect(url: string | URL, status?: number): Response;
+  static error(): Response;
+  readonly ok: boolean;
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: Headers;
+  readonly body: ReadableStream<Uint8Array> | null;
+  readonly bodyUsed: boolean;
+  clone(): Response;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  blob(): Promise<Blob>;
+  formData(): Promise<FormData>;
+  json(): Promise<unknown>;
+  text(): Promise<string>;
+}
+
+declare function fetch(
+  input: Request | string | URL,
+  init?: RequestInit
+): Promise<Response>;

package/types/streams.d.ts

@@ -0,0 +1,67 @@
+// Streams API types
+
+interface ReadableStreamDefaultReader<R = unknown> {
+  readonly closed: Promise<undefined>;
+  cancel(reason?: unknown): Promise<void>;
+  read(): Promise<{ done: false; value: R } | { done: true; value?: undefined }>;
+  releaseLock(): void;
+}
+
+interface ReadableStream<R = unknown> {
+  readonly locked: boolean;
+  cancel(reason?: unknown): Promise<void>;
+  getReader(): ReadableStreamDefaultReader<R>;
+  pipeThrough<T>(transform: {
+    writable: WritableStream<R>;
+    readable: ReadableStream<T>;
+  }): ReadableStream<T>;
+  pipeTo(dest: WritableStream<R>): Promise<void>;
+  tee(): [ReadableStream<R>, ReadableStream<R>];
+}
+
+interface ReadableStreamDefaultController<R = unknown> {
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk: R): void;
+  error(e?: unknown): void;
+}
+
+declare var ReadableStream: {
+  prototype: ReadableStream;
+  new <R = unknown>(source?: {
+    start?(controller: ReadableStreamDefaultController<R>): void | Promise<void>;
+    pull?(controller: ReadableStreamDefaultController<R>): void | Promise<void>;
+    cancel?(reason?: unknown): void | Promise<void>;
+  }): ReadableStream<R>;
+};
+
+interface WritableStreamDefaultWriter<W = unknown> {
+  readonly closed: Promise<undefined>;
+  readonly desiredSize: number | null;
+  readonly ready: Promise<undefined>;
+  abort(reason?: unknown): Promise<void>;
+  close(): Promise<void>;
+  releaseLock(): void;
+  write(chunk: W): Promise<void>;
+}
+
+interface WritableStream<W = unknown> {
+  readonly locked: boolean;
+  abort(reason?: unknown): Promise<void>;
+  close(): Promise<void>;
+  getWriter(): WritableStreamDefaultWriter<W>;
+}
+
+interface WritableStreamDefaultController {
+  error(e?: unknown): void;
+}
+
+declare var WritableStream: {
+  prototype: WritableStream;
+  new <W = unknown>(sink?: {
+    start?(controller: WritableStreamDefaultController): void | Promise<void>;
+    write?(chunk: W, controller: WritableStreamDefaultController): void | Promise<void>;
+    close?(controller: WritableStreamDefaultController): void | Promise<void>;
+    abort?(reason?: unknown): void | Promise<void>;
+  }): WritableStream<W>;
+};

package/types/timers.d.ts

@@ -0,0 +1,17 @@
+// Timer API types
+
+declare function setTimeout(
+  callback: (...args: unknown[]) => void,
+  ms?: number,
+  ...args: unknown[]
+): number;
+
+declare function clearTimeout(id: number): void;
+
+declare function setInterval(
+  callback: (...args: unknown[]) => void,
+  ms?: number,
+  ...args: unknown[]
+): number;
+
+declare function clearInterval(id: number): void;

package/types/url.d.ts

@@ -0,0 +1,40 @@
+// URL API types
+
+declare class URL {
+  constructor(url: string | URL, base?: string | URL);
+  hash: string;
+  host: string;
+  hostname: string;
+  href: string;
+  readonly origin: string;
+  password: string;
+  pathname: string;
+  port: string;
+  protocol: string;
+  search: string;
+  readonly searchParams: URLSearchParams;
+  username: string;
+  toString(): string;
+  toJSON(): string;
+}
+
+declare class URLSearchParams {
+  constructor(
+    init?: string | URLSearchParams | Record<string, string> | [string, string][]
+  );
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  get(name: string): string | null;
+  getAll(name: string): string[];
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  sort(): void;
+  toString(): string;
+  forEach(
+    callback: (value: string, key: string, parent: URLSearchParams) => void
+  ): void;
+  entries(): IterableIterator<[string, string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}

package/types/workers.d.ts

@@ -0,0 +1,48 @@
+// OpenWorkers-specific types
+
+interface ScheduledEvent {
+  scheduledTime: number;
+  cron?: string;
+  waitUntil(promise: Promise<unknown>): void;
+}
+
+interface ExecutionContext {
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+}
+
+interface ExportedHandler<Env = unknown> {
+  fetch?(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext
+  ): Response | Promise<Response>;
+  scheduled?(
+    event: ScheduledEvent,
+    env: Env,
+    ctx: ExecutionContext
+  ): void | Promise<void>;
+}
+
+// addEventListener pattern
+
+interface FetchEvent extends Event {
+  readonly request: Request;
+  respondWith(response: Response | Promise<Response>): void;
+  waitUntil(promise: Promise<unknown>): void;
+  passThroughOnException(): void;
+}
+
+interface ScheduledEventListener {
+  (event: ScheduledEvent & { waitUntil(promise: Promise<unknown>): void }): void;
+}
+
+declare function addEventListener(
+  type: "fetch",
+  listener: (event: FetchEvent) => void
+): void;
+
+declare function addEventListener(
+  type: "scheduled",
+  listener: ScheduledEventListener
+): void;