@meetploy/types 1.8.0 → 1.9.0

package/globals.d.ts

@@ -0,0 +1,660 @@
+/**
+ * Global type declarations for Ploy worker environments.
+ *
+ * Provides web platform types (Request, Response, URL, etc.) for workerd
+ * environments without the "dom" lib, plus global re-exports of all Ploy
+ * binding and handler types.
+ *
+ * Referenced via: /// <reference types="@meetploy/types/globals" />
+ */
+
+declare global {
+	// PloyEnv is augmented by the generated env.d.ts with project-specific bindings.
+	interface PloyEnv {}
+
+	// --- Ploy handler types ---
+	type PloyHandler<TEnv = unknown> =
+		import("@meetploy/types").PloyHandler<TEnv>;
+	type Ploy = PloyHandler<PloyEnv>;
+
+	// --- Binding types ---
+	type D1Database = import("@meetploy/types").D1Database;
+	type D1PreparedStatement = import("@meetploy/types").D1PreparedStatement;
+	type D1Result<T = unknown> = import("@meetploy/types").D1Result<T>;
+	type D1ResultMeta = import("@meetploy/types").D1ResultMeta;
+	type CacheBinding = import("@meetploy/types").CacheBinding;
+	type QueueBinding = import("@meetploy/types").QueueBinding;
+	type StateBinding = import("@meetploy/types").StateBinding;
+	type WorkflowBinding = import("@meetploy/types").WorkflowBinding;
+	type FileStorageBinding = import("@meetploy/types").FileStorageBinding;
+	type TimerBinding = import("@meetploy/types").TimerBinding;
+	type PloyAuth = import("@meetploy/types").PloyAuth;
+	type PloyUser = import("@meetploy/types").PloyUser;
+
+	// --- Handler and context types ---
+	type WorkflowContext<
+		TEnv = unknown,
+		TInput = unknown,
+	> = import("@meetploy/types").WorkflowContext<TEnv, TInput>;
+	type QueueMessageEvent = import("@meetploy/types").QueueMessageEvent;
+	type ScheduledEvent = import("@meetploy/types").ScheduledEvent;
+	type TimerEvent = import("@meetploy/types").TimerEvent;
+	type ExecutionContext = import("@meetploy/types").ExecutionContext;
+
+	// --- Web Platform Supporting types ---
+	type HeadersInit = Headers | Record<string, string> | [string, string][];
+	type BodyInit =
+		| string
+		| ArrayBuffer
+		| ArrayBufferView
+		| Blob
+		| FormData
+		| URLSearchParams
+		| ReadableStream;
+	type RequestInfo = string | Request | URL;
+	type RequestRedirect = "follow" | "error" | "manual";
+	type RequestMode = "navigate" | "same-origin" | "no-cors" | "cors";
+	type RequestCredentials = "omit" | "same-origin" | "include";
+	type RequestCache =
+		| "default"
+		| "no-store"
+		| "reload"
+		| "no-cache"
+		| "force-cache"
+		| "only-if-cached";
+	type ReferrerPolicy =
+		| ""
+		| "no-referrer"
+		| "no-referrer-when-downgrade"
+		| "same-origin"
+		| "origin"
+		| "strict-origin"
+		| "origin-when-cross-origin"
+		| "strict-origin-when-cross-origin"
+		| "unsafe-url";
+	type ResponseType =
+		| "basic"
+		| "cors"
+		| "default"
+		| "error"
+		| "opaque"
+		| "opaqueredirect";
+	type FormDataEntryValue = string | File;
+
+	interface RequestInit {
+		method?: string;
+		headers?: HeadersInit;
+		body?: BodyInit | null;
+		redirect?: RequestRedirect;
+		mode?: RequestMode;
+		credentials?: RequestCredentials;
+		cache?: RequestCache;
+		referrerPolicy?: ReferrerPolicy;
+		integrity?: string;
+		keepalive?: boolean;
+		signal?: AbortSignal | null;
+	}
+
+	interface ResponseInit {
+		status?: number;
+		statusText?: string;
+		headers?: HeadersInit;
+	}
+
+	interface BlobPropertyBag {
+		type?: string;
+		endings?: "native" | "transparent";
+	}
+
+	interface FilePropertyBag extends BlobPropertyBag {
+		lastModified?: number;
+	}
+
+	// --- Core Web API classes ---
+
+	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, name: string, parent: Headers) => void,
+		): void;
+		entries(): IterableIterator<[string, string]>;
+		keys(): IterableIterator<string>;
+		values(): IterableIterator<string>;
+		[Symbol.iterator](): IterableIterator<[string, string]>;
+	}
+
+	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;
+	}
+
+	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, name: string, parent: URLSearchParams) => void,
+		): void;
+		entries(): IterableIterator<[string, string]>;
+		keys(): IterableIterator<string>;
+		values(): IterableIterator<string>;
+		[Symbol.iterator](): IterableIterator<[string, string]>;
+	}
+
+	class Blob {
+		constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
+		readonly size: number;
+		readonly type: string;
+		arrayBuffer(): Promise<ArrayBuffer>;
+		bytes(): Promise<Uint8Array>;
+		slice(start?: number, end?: number, contentType?: string): Blob;
+		text(): Promise<string>;
+		stream(): ReadableStream;
+	}
+	type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob;
+
+	class File extends Blob {
+		constructor(
+			fileBits: BlobPart[],
+			fileName: string,
+			options?: FilePropertyBag,
+		);
+		readonly lastModified: number;
+		readonly name: string;
+	}
+
+	class FormData {
+		constructor();
+		append(name: string, value: string | Blob, fileName?: string): void;
+		delete(name: string): void;
+		get(name: string): FormDataEntryValue | null;
+		getAll(name: string): FormDataEntryValue[];
+		has(name: string): boolean;
+		set(name: string, value: string | Blob, fileName?: string): void;
+		forEach(
+			callback: (
+				value: FormDataEntryValue,
+				name: string,
+				parent: FormData,
+			) => void,
+		): void;
+		entries(): IterableIterator<[string, FormDataEntryValue]>;
+		keys(): IterableIterator<string>;
+		values(): IterableIterator<FormDataEntryValue>;
+		[Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
+	}
+
+	class AbortController {
+		readonly signal: AbortSignal;
+		abort(reason?: unknown): void;
+	}
+
+	class AbortSignal extends EventTarget {
+		static abort(reason?: unknown): AbortSignal;
+		static timeout(milliseconds: number): AbortSignal;
+		readonly aborted: boolean;
+		readonly reason: unknown;
+		throwIfAborted(): void;
+		onabort: ((this: AbortSignal, ev: Event) => unknown) | null;
+	}
+
+	class TextEncoder {
+		readonly encoding: "utf-8";
+		encode(input?: string): Uint8Array;
+		encodeInto(
+			input: string,
+			dest: Uint8Array,
+		): { read: number; written: number };
+	}
+
+	interface TextDecoderOptions {
+		fatal?: boolean;
+		ignoreBOM?: boolean;
+	}
+
+	interface TextDecodeOptions {
+		stream?: boolean;
+	}
+
+	class TextDecoder {
+		constructor(label?: string, options?: TextDecoderOptions);
+		readonly encoding: string;
+		readonly fatal: boolean;
+		readonly ignoreBOM: boolean;
+		decode(
+			input?: ArrayBuffer | ArrayBufferView,
+			options?: TextDecodeOptions,
+		): string;
+	}
+
+	// --- Request & Response classes ---
+
+	class Request {
+		constructor(input: RequestInfo, init?: RequestInit);
+		readonly method: string;
+		readonly url: string;
+		readonly headers: Headers;
+		readonly redirect: RequestRedirect;
+		readonly signal: AbortSignal;
+		readonly integrity: string;
+		readonly keepalive: boolean;
+		readonly mode: RequestMode;
+		readonly credentials: RequestCredentials;
+		readonly cache: RequestCache;
+		readonly referrerPolicy: ReferrerPolicy;
+		readonly body: ReadableStream | null;
+		readonly bodyUsed: boolean;
+		clone(): Request;
+		arrayBuffer(): Promise<ArrayBuffer>;
+		bytes(): Promise<Uint8Array>;
+		text(): Promise<string>;
+		json<T = unknown>(): Promise<T>;
+		formData(): Promise<FormData>;
+		blob(): Promise<Blob>;
+	}
+
+	class Response {
+		constructor(body?: BodyInit | null, init?: ResponseInit);
+		readonly status: number;
+		readonly statusText: string;
+		readonly headers: Headers;
+		readonly ok: boolean;
+		readonly redirected: boolean;
+		readonly url: string;
+		readonly type: ResponseType;
+		readonly body: ReadableStream | null;
+		readonly bodyUsed: boolean;
+		clone(): Response;
+		arrayBuffer(): Promise<ArrayBuffer>;
+		bytes(): Promise<Uint8Array>;
+		text(): Promise<string>;
+		json<T = unknown>(): Promise<T>;
+		formData(): Promise<FormData>;
+		blob(): Promise<Blob>;
+		static json(data: unknown, init?: ResponseInit): Response;
+		static redirect(url: string | URL, status?: number): Response;
+		static error(): Response;
+	}
+
+	// --- Streams ---
+
+	interface ReadableStreamReadResult<T> {
+		done: boolean;
+		value: T;
+	}
+
+	interface ReadableStreamDefaultReader<R = unknown> {
+		readonly closed: Promise<undefined>;
+		cancel(reason?: unknown): Promise<void>;
+		read(): Promise<ReadableStreamReadResult<R>>;
+		releaseLock(): void;
+	}
+
+	interface ReadableStreamDefaultController<R = unknown> {
+		readonly desiredSize: number | null;
+		close(): void;
+		enqueue(chunk?: R): void;
+		error(reason?: unknown): void;
+	}
+
+	interface UnderlyingSource<R = unknown> {
+		start?: (
+			controller: ReadableStreamDefaultController<R>,
+		) => void | Promise<void>;
+		pull?: (
+			controller: ReadableStreamDefaultController<R>,
+		) => void | Promise<void>;
+		cancel?: (reason?: unknown) => void | Promise<void>;
+		type?: undefined;
+	}
+
+	interface QueuingStrategy<T = unknown> {
+		highWaterMark?: number;
+		size?: (chunk: T) => number;
+	}
+
+	class ReadableStream<R = unknown> {
+		constructor(
+			underlyingSource?: UnderlyingSource<R>,
+			strategy?: QueuingStrategy<R>,
+		);
+		readonly locked: boolean;
+		cancel(reason?: unknown): Promise<void>;
+		getReader(): ReadableStreamDefaultReader<R>;
+		pipeThrough<T>(
+			transform: ReadableWritablePair<T, R>,
+			options?: StreamPipeOptions,
+		): ReadableStream<T>;
+		pipeTo(
+			destination: WritableStream<R>,
+			options?: StreamPipeOptions,
+		): Promise<void>;
+		tee(): [ReadableStream<R>, ReadableStream<R>];
+		values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
+		[Symbol.asyncIterator](options?: {
+			preventCancel?: boolean;
+		}): AsyncIterableIterator<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 WritableStreamDefaultController {
+		readonly signal: AbortSignal;
+		error(reason?: unknown): void;
+	}
+
+	interface UnderlyingSink<W = unknown> {
+		start?: (
+			controller: WritableStreamDefaultController,
+		) => void | Promise<void>;
+		write?: (
+			chunk: W,
+			controller: WritableStreamDefaultController,
+		) => void | Promise<void>;
+		close?: () => void | Promise<void>;
+		abort?: (reason?: unknown) => void | Promise<void>;
+		type?: undefined;
+	}
+
+	class WritableStream<W = unknown> {
+		constructor(
+			underlyingSink?: UnderlyingSink<W>,
+			strategy?: QueuingStrategy<W>,
+		);
+		readonly locked: boolean;
+		abort(reason?: unknown): Promise<void>;
+		close(): Promise<void>;
+		getWriter(): WritableStreamDefaultWriter<W>;
+	}
+
+	interface ReadableWritablePair<R = unknown, W = unknown> {
+		readable: ReadableStream<R>;
+		writable: WritableStream<W>;
+	}
+
+	interface StreamPipeOptions {
+		preventClose?: boolean;
+		preventAbort?: boolean;
+		preventCancel?: boolean;
+		signal?: AbortSignal;
+	}
+
+	interface TransformStreamDefaultController<O = unknown> {
+		readonly desiredSize: number | null;
+		enqueue(chunk?: O): void;
+		error(reason?: unknown): void;
+		terminate(): void;
+	}
+
+	interface Transformer<I = unknown, O = unknown> {
+		start?: (
+			controller: TransformStreamDefaultController<O>,
+		) => void | Promise<void>;
+		transform?: (
+			chunk: I,
+			controller: TransformStreamDefaultController<O>,
+		) => void | Promise<void>;
+		flush?: (
+			controller: TransformStreamDefaultController<O>,
+		) => void | Promise<void>;
+	}
+
+	class TransformStream<I = unknown, O = unknown> {
+		constructor(
+			transformer?: Transformer<I, O>,
+			writableStrategy?: QueuingStrategy<I>,
+			readableStrategy?: QueuingStrategy<O>,
+		);
+		readonly readable: ReadableStream<O>;
+		readonly writable: WritableStream<I>;
+	}
+
+	// --- Crypto ---
+
+	interface CryptoKey {
+		readonly type: string;
+		readonly extractable: boolean;
+		readonly algorithm: object;
+		readonly usages: string[];
+	}
+
+	interface CryptoKeyPair {
+		publicKey: CryptoKey;
+		privateKey: CryptoKey;
+	}
+
+	interface JsonWebKey {
+		kty: string;
+		use?: string;
+		key_ops?: string[];
+		alg?: string;
+		ext?: boolean;
+		crv?: string;
+		x?: string;
+		y?: string;
+		d?: string;
+		n?: string;
+		e?: string;
+		p?: string;
+		q?: string;
+		dp?: string;
+		dq?: string;
+		qi?: string;
+		oth?: { r: string; d: string; t: string }[];
+		k?: string;
+	}
+
+	interface SubtleCrypto {
+		encrypt(
+			algorithm: object,
+			key: CryptoKey,
+			data: ArrayBuffer | ArrayBufferView,
+		): Promise<ArrayBuffer>;
+		decrypt(
+			algorithm: object,
+			key: CryptoKey,
+			data: ArrayBuffer | ArrayBufferView,
+		): Promise<ArrayBuffer>;
+		sign(
+			algorithm: object,
+			key: CryptoKey,
+			data: ArrayBuffer | ArrayBufferView,
+		): Promise<ArrayBuffer>;
+		verify(
+			algorithm: object,
+			key: CryptoKey,
+			signature: ArrayBuffer | ArrayBufferView,
+			data: ArrayBuffer | ArrayBufferView,
+		): Promise<boolean>;
+		digest(
+			algorithm: object | string,
+			data: ArrayBuffer | ArrayBufferView,
+		): Promise<ArrayBuffer>;
+		generateKey(
+			algorithm: object,
+			extractable: boolean,
+			keyUsages: string[],
+		): Promise<CryptoKey | CryptoKeyPair>;
+		deriveKey(
+			algorithm: object,
+			baseKey: CryptoKey,
+			derivedKeyType: object,
+			extractable: boolean,
+			keyUsages: string[],
+		): Promise<CryptoKey>;
+		deriveBits(
+			algorithm: object,
+			baseKey: CryptoKey,
+			length: number,
+		): Promise<ArrayBuffer>;
+		importKey(
+			format: string,
+			keyData: JsonWebKey | ArrayBuffer | ArrayBufferView,
+			algorithm: object,
+			extractable: boolean,
+			keyUsages: string[],
+		): Promise<CryptoKey>;
+		exportKey(
+			format: string,
+			key: CryptoKey,
+		): Promise<JsonWebKey | ArrayBuffer>;
+		wrapKey(
+			format: string,
+			key: CryptoKey,
+			wrappingKey: CryptoKey,
+			wrapAlgorithm: object,
+		): Promise<ArrayBuffer>;
+		unwrapKey(
+			format: string,
+			wrappedKey: ArrayBuffer | ArrayBufferView,
+			unwrappingKey: CryptoKey,
+			unwrapAlgorithm: object,
+			unwrappedKeyAlgorithm: object,
+			extractable: boolean,
+			keyUsages: string[],
+		): Promise<CryptoKey>;
+	}
+
+	interface Crypto {
+		readonly subtle: SubtleCrypto;
+		getRandomValues<T extends ArrayBufferView>(array: T): T;
+		randomUUID(): string;
+	}
+	var crypto: Crypto;
+
+	// --- Console ---
+
+	interface Console {
+		log(...data: unknown[]): void;
+		warn(...data: unknown[]): void;
+		error(...data: unknown[]): void;
+		info(...data: unknown[]): void;
+		debug(...data: unknown[]): void;
+		trace(...data: unknown[]): void;
+		dir(item: unknown, options?: object): void;
+		dirxml(...data: unknown[]): void;
+		table(tabularData: unknown, properties?: string[]): void;
+		time(label?: string): void;
+		timeEnd(label?: string): void;
+		timeLog(label?: string, ...data: unknown[]): void;
+		count(label?: string): void;
+		countReset(label?: string): void;
+		group(...data: unknown[]): void;
+		groupCollapsed(...data: unknown[]): void;
+		groupEnd(): void;
+		clear(): void;
+		assert(condition?: boolean, ...data: unknown[]): void;
+	}
+	var console: Console;
+
+	// --- Timers & Utilities ---
+
+	function setTimeout(
+		callback: (...args: unknown[]) => void,
+		ms?: number,
+		...args: unknown[]
+	): number;
+	function clearTimeout(id: number | undefined): void;
+	function setInterval(
+		callback: (...args: unknown[]) => void,
+		ms?: number,
+		...args: unknown[]
+	): number;
+	function clearInterval(id: number | undefined): void;
+	function queueMicrotask(callback: () => void): void;
+	function structuredClone<T>(
+		value: T,
+		options?: { transfer?: Transferable[] },
+	): T;
+	function atob(data: string): string;
+	function btoa(data: string): string;
+	function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
+
+	// --- Events (minimal, for AbortSignal) ---
+
+	class Event {
+		constructor(type: string, eventInitDict?: EventInit);
+		readonly type: string;
+		readonly bubbles: boolean;
+		readonly cancelable: boolean;
+		readonly defaultPrevented: boolean;
+		readonly timeStamp: number;
+		preventDefault(): void;
+		stopPropagation(): void;
+		stopImmediatePropagation(): void;
+	}
+
+	interface EventInit {
+		bubbles?: boolean;
+		cancelable?: boolean;
+		composed?: boolean;
+	}
+
+	interface EventListenerOptions {
+		capture?: boolean;
+	}
+
+	interface AddEventListenerOptions extends EventListenerOptions {
+		once?: boolean;
+		passive?: boolean;
+		signal?: AbortSignal;
+	}
+
+	type EventListenerOrEventListenerObject =
+		| ((event: Event) => void)
+		| { handleEvent(event: Event): void };
+
+	class EventTarget {
+		addEventListener(
+			type: string,
+			listener: EventListenerOrEventListenerObject | null,
+			options?: AddEventListenerOptions | boolean,
+		): void;
+		removeEventListener(
+			type: string,
+			listener: EventListenerOrEventListenerObject | null,
+			options?: EventListenerOptions | boolean,
+		): void;
+		dispatchEvent(event: Event): boolean;
+	}
+}
+
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@meetploy/types",
-	"version": "1.8.0",
+	"version": "1.9.0",
 	"private": false,
 	"repository": {
 		"type": "git",
@@ -13,12 +13,16 @@
 		".": {
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js"
+		},
+		"./globals": {
+			"types": "./globals.d.ts"
 		}
 	},
 	"module": "./dist/index.js",
 	"types": "./dist/index.d.ts",
 	"files": [
-		"dist/"
+		"dist/",
+		"globals.d.ts"
 	],
 	"scripts": {
 		"build": "tsc && resolve-tspaths",