first commit

node_modules/@expo/ws-tunnel/build/index.d.ts

@@ -0,0 +1,4 @@
+import { type TunnelOptions } from './tunnel/tunnel';
+export type { TunnelOptions as WsTunnelOptions } from './tunnel/tunnel';
+export declare function startAsync(options: TunnelOptions): Promise<string>;
+export declare function stopAsync(): Promise<void>;

node_modules/@expo/ws-tunnel/build/protocol/decoding.d.ts

@@ -0,0 +1,2 @@
+import { Message } from './types';
+export declare const decodeMessage: (data: Uint8Array) => Message;

node_modules/@expo/ws-tunnel/build/protocol/encoding.d.ts

@@ -0,0 +1,2 @@
+import { Message } from './types';
+export declare const encodeMessage: (message: Message) => Uint8Array;

node_modules/@expo/ws-tunnel/build/protocol/identifiers.d.ts

@@ -0,0 +1,5 @@
+export type RequestID = number & {
+    /** Marker to indicate that a `IdentifierSeed` may not be created directly */
+    readonly _opaque: unique symbol;
+};
+export declare const nextRequestID: (previousRequestId: RequestID | undefined | null) => RequestID;

node_modules/@expo/ws-tunnel/build/protocol/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './encoding';
+export * from './decoding';
+export * from './streams';
+export { nextRequestID } from './identifiers';
+export type { RequestID } from './identifiers';

node_modules/@expo/ws-tunnel/build/protocol/streams.d.ts

@@ -0,0 +1,2 @@
+import type { ReadableStreamReadResult, StreamPipeOptions } from 'node:stream/web';
+export declare function bodyToChunks(stream: ReadableStream<Uint8Array>, options?: StreamPipeOptions): AsyncGenerator<ReadableStreamReadResult<Uint8Array>>;

node_modules/@expo/ws-tunnel/build/protocol/types.d.ts

@@ -0,0 +1,78 @@
+import { RequestID } from './identifiers';
+export declare enum MessageType {
+    Request = 1,
+    RequestAbort = 2,
+    RequestBodyChunk = 3,
+    Response = 4,
+    ResponseAbort = 5,
+    ResponseBodyChunk = 6,
+    WebSocketConnect = 7,
+    WebSocketMessage = 8,
+    WebSocketClose = 9
+}
+export declare const enum RequestMethodCode {
+    GET = 1,
+    HEAD = 2,
+    POST = 3,
+    PUT = 4,
+    PATCH = 5,
+    DELETE = 6,
+    OPTIONS = 7
+}
+export type RequestMethod = 'GET' | 'HEAD' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS';
+export interface MessageShape {
+    type: MessageType;
+    id: RequestID;
+}
+export interface RequestMessage extends MessageShape {
+    type: MessageType.Request;
+    id: RequestID;
+    hasContent: boolean;
+    method: RequestMethod;
+    url: string;
+    headers: Headers;
+}
+export interface RequestAbortMessage extends MessageShape {
+    type: MessageType.RequestAbort;
+    id: RequestID;
+    errored: boolean;
+}
+export interface RequestBodyChunkMessage extends MessageShape {
+    type: MessageType.RequestBodyChunk;
+    id: RequestID;
+    end: boolean;
+    data: Uint8Array | null;
+}
+export interface ResponseMessage extends MessageShape {
+    type: MessageType.Response;
+    id: RequestID;
+    hasContent: boolean;
+    status: number;
+    headers: Headers;
+}
+export interface ResponseAbortMessage extends MessageShape {
+    type: MessageType.ResponseAbort;
+    id: RequestID;
+    errored: boolean;
+}
+export interface ResponseBodyChunkMessage extends MessageShape {
+    type: MessageType.ResponseBodyChunk;
+    id: RequestID;
+    end: boolean;
+    data: Uint8Array | null;
+}
+export interface WebSocketConnectMessage extends MessageShape {
+    type: MessageType.WebSocketConnect;
+    id: RequestID;
+    url: string;
+}
+export interface WebSocketMessageMessage extends MessageShape {
+    type: MessageType.WebSocketMessage;
+    id: RequestID;
+    data: Uint8Array | string | null;
+}
+export interface WebSocketCloseMessage extends MessageShape {
+    type: MessageType.WebSocketClose;
+    id: RequestID;
+}
+export type Message = RequestMessage | RequestAbortMessage | RequestBodyChunkMessage | ResponseMessage | ResponseAbortMessage | ResponseBodyChunkMessage | WebSocketConnectMessage | WebSocketMessageMessage | WebSocketCloseMessage;

node_modules/@expo/ws-tunnel/build/protocol/utils.d.ts

@@ -0,0 +1 @@
+export declare const alignBytes: (offset: number) => number;

node_modules/@expo/ws-tunnel/build/tunnel/http.d.ts

@@ -0,0 +1,5 @@
+import { WebSocket } from 'ws';
+import { RequestBodyChunkMessage, RequestMessage, RequestAbortMessage } from '../protocol';
+export declare function handleProxiedRequest(tunnel: WebSocket, url: URL, message: RequestMessage): Promise<void>;
+export declare function pushProxiedRequestBodyChunk(message: RequestBodyChunkMessage): Promise<void>;
+export declare function abortProxiedRequest(message: RequestAbortMessage): Promise<void>;

node_modules/@expo/ws-tunnel/build/tunnel/tunnel.d.ts

@@ -0,0 +1,24 @@
+export interface TunnelOptions {
+    /** The main URL of the ws tunnel service */
+    apiUrl?: string;
+    /** The (unique) session identifier */
+    session: string;
+    /** The maximum amount of times the connection can be retried when establishing connection */
+    maxReconnect?: number;
+    /**
+     * Event handler to inform uses based on tunnel status changes.
+     *   - connecting, when the tunnel is trying to connect for the first time
+     *   - connected, when the tunnel is active and ready
+     *   - reconnecting, when the tunnel is trying to re-establish a lost connection
+     *   - disconnected, when the tunnel failed to re-establish a lost connection
+     */
+    onStatusChange?: (status: 'connecting' | 'connected' | 'reconnecting' | 'disconnected') => void;
+}
+/**
+ * Create a new tunnel instance.
+ * Note, this doesn't start the tunnel itself yet.
+ */
+export declare function createTunnel(): {
+    start({ apiUrl, session, maxReconnect, onStatusChange, }: TunnelOptions): Promise<string>;
+    stop(): void;
+};

node_modules/@expo/ws-tunnel/build/tunnel/websocket.d.ts

@@ -0,0 +1,5 @@
+import { WebSocketCloseMessage, WebSocketConnectMessage, WebSocketMessageMessage } from '../protocol';
+import { type WebSocket } from '../utils/ws';
+export declare function sendToProxiedWebsocket(message: WebSocketMessageMessage): Promise<void>;
+export declare function createProxiedWebsocket(tunnel: WebSocket, message: WebSocketConnectMessage): Promise<void>;
+export declare function closeProxiedWebsocket(message: WebSocketCloseMessage): Promise<void>;

node_modules/@expo/ws-tunnel/build/utils/chunk.d.ts

@@ -0,0 +1,3 @@
+import { RawData } from 'ws';
+export declare function toUint8Array(raw: RawData | string): Uint8Array<ArrayBufferLike>;
+export declare function toString(raw: RawData | string): string;

node_modules/@expo/ws-tunnel/build/utils/debug.d.ts

@@ -0,0 +1,2 @@
+import debug from 'debug';
+export declare function createDebug(namespace: string): debug.Debugger;

node_modules/@expo/ws-tunnel/build/utils/promise.d.ts

@@ -0,0 +1,7 @@
+export type PromiseResolve<T> = (value: T | PromiseLike<T>) => void;
+export type PromiseReject = (reason?: any) => void;
+export declare function withResolvers<T>(): {
+    resolve: PromiseResolve<T>;
+    reject: PromiseReject;
+    promise: Promise<T>;
+};

node_modules/@expo/ws-tunnel/build/utils/url.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Create the private URL for the socket itself.
+ * This includes a special flag for the tunnel service to mark this socket as the tunnel source.
+ */
+export declare function createSocketUrl(apiUrl: string, sessionId?: string): import("url").URL;
+/**
+ * Create the exposed tunnel URL from the actual socket URL.
+ * This is visible for the user and may connect clients or other sockets.
+ */
+export declare function createTunnelUrl(socketUrl: string): import("url").URL;

node_modules/@expo/ws-tunnel/build/utils/ws.d.ts

@@ -0,0 +1,3 @@
+import { WebSocket, type RawData } from 'ws';
+export type { WebSocket, RawData };
+export declare function createWebSocket(url: URL | string): WebSocket;