@fkn/lib 0.2.1 → 0.3.0

package/{build → lib}/api.d.ts

@@ -1,5 +1,10 @@
+export type { Resolvers } from '../api';
 export declare const apiPromise: Promise<{
-    readonly WEBVPN_TCP_SOCKET: ({ remoteAddress: _remoteAddress, remotePort }: {
+    readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
+        all?: T;
+        family: 0 | 4 | 6;
+    }) => Promise<T extends true ? import('../api/dns').AddressLookupResult[] : import('../api/dns').AddressLookupResult | undefined>;
+    readonly webVpnTcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
         remoteAddress: string;
         remotePort: number;
     }) => Promise<{
@@ -9,24 +14,25 @@ export declare const apiPromise: Promise<{
         remoteAddress: string;
         remoteFamily: "IPv4" | "IPv6";
         remotePort: number;
-        dataReadableStream: ReadableStream<Uint8Array<ArrayBuffer>>;
-        dataWritableStream: WritableStream<Uint8Array<ArrayBuffer>>;
+        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
         end: () => Promise<void>;
         destroy: () => Promise<void>;
         destroySoon: () => Promise<void>;
         resetAndDestroy: () => Promise<void>;
+        setOption: (option: import('../api/webvpn/tcp').TcpSocketOption) => Promise<void>;
     }>;
-    readonly WEBVPN_TCP_SOCKET_LISTENER: ({ localAddress: _localAddress, localPort, onConnection }: {
+    readonly webVpnTcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
         localAddress: string;
         localPort: number;
-        onConnection: (connection: import('@mfkn/web/src/api/webvpn/tcp').TcpSocketResult) => void;
+        onConnection: (connection: import('../api/webvpn/tcp').TcpSocketResult) => void;
     }) => Promise<{
         localAddress: string;
         localFamily: "IPv4" | "IPv6";
         localPort: number;
         close: () => Promise<void>;
     }>;
-    readonly WEBVPN_UDP_SOCKET: ({ type, port, address }: {
+    readonly webVpnUdpSocket: ({ type, port, address }: {
         type: "udp4" | "udp6";
         port: number;
         address: string;
@@ -51,22 +57,9 @@ export declare const apiPromise: Promise<{
             port?: number;
         }) => Promise<void>;
         close: () => Promise<void>;
+        setOption: (option: import('../api/webvpn/udp').UdpSocketOption) => Promise<void>;
     }>;
-    readonly DNS_LOOKUP: (hostname: string, options: {
-        all?: boolean;
-        family: 0 | 4 | 6;
-    }, callback: (err: Error | undefined, addresses: import('@mfkn/web/src/api/dns').AddressLookupResult | import('@mfkn/web/src/api/dns').AddressLookupResult[] | undefined) => void) => Promise<void>;
-    readonly SERVER_PROXY_FETCH: ({ input, init }: {
-        input: import('@mfkn/web/src/api/proxy/server-proxy-fetch').ProxyFetchRequestInfo;
-        init?: import('@mfkn/web/src/api/proxy/server-proxy-fetch').ProxyFetchRequestInit;
-    }) => Promise<{
-        headers: any;
-        body: ReadableStream<Uint8Array<ArrayBufferLike>> | null;
-        type: ResponseType;
-        url: string;
-        ok: boolean;
-        redirected: boolean;
-        status: number;
-        statusText: string;
-    }>;
+    readonly proxyFetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
+        render?: boolean;
+    }) => Promise<Response>;
 }>;

package/lib/proxy.d.ts

@@ -0,0 +1,5 @@
+import { Resolvers } from './api';
+type ProxyFetch = Resolvers['proxyFetch'];
+type FetchParameters = Parameters<ProxyFetch>;
+export declare const serverProxyFetch: (input: FetchParameters[0], init?: FetchParameters[1]) => Promise<Response>;
+export {};

package/{build → lib}/webvpn/dgram.d.ts

@@ -1,7 +1,8 @@
 import { BindOptions, Socket as DgramSocket, RemoteInfo, SocketOptions, SocketType } from 'dgram';
 import { AddressInfo } from 'net';
-import { ApiResolvers } from '@mfkn/web/src/api/resolvers';
+import { Resolvers } from '../api';
 import { EventEmitter } from 'events';
+import { UdpSocketOption } from '../../api/webvpn/udp';
 interface EventEmitterOptions {
     /**
      * Enables automatic capturing of promise rejection.
@@ -20,10 +21,16 @@ export declare class Socket extends EventEmitter implements DgramSocket {
         family: string;
         port: number;
     };
-    _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<ApiResolvers['WEBVPN_UDP_SOCKET']>> | undefined>;
+    _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<Resolvers['webVpnUdpSocket']>> | undefined>;
     constructor(options: SocketOptions & EventEmitterOptions & {
-        connection?: ReturnType<ApiResolvers['WEBVPN_UDP_SOCKET']>;
+        connection?: ReturnType<Resolvers['webVpnUdpSocket']>;
     });
+    _lastRecvBufferSize: number;
+    _lastSendBufferSize: number;
+    _lastTtl: number;
+    _lastMulticastTtl: number;
+    _lastMulticastLoopback: boolean;
+    _setUdpOption(option: UdpSocketOption): void;
     addMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
     address(): AddressInfo;
     bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this;

package/{build → lib}/webvpn/net.d.ts

@@ -1,5 +1,5 @@
 import { Socket as NetSocket, SocketConnectOpts, SocketConstructorOpts, Server as TCPServer, ServerOpts, ListenOptions, AddressInfo } from 'net';
-import { ApiResolvers } from '@mfkn/web/src/api/resolvers';
+import { Resolvers } from '../api';
 import { DuplexOptions, Stream } from 'stream';
 import { EventEmitter } from 'events';
 import { isIP, isIPv4, isIPv6 } from './utils';
@@ -14,26 +14,27 @@ export declare class Socket extends Stream.Duplex implements NetSocket {
         family: string;
         port: number;
     };
-    _webVPNTcpSocketPromise?: Promise<(Awaited<ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET']>> & {
+    _webVPNTcpSocketPromise?: Promise<(Awaited<ReturnType<Resolvers['webVpnTcpSocket']>> & {
         reader: ReadableStreamDefaultReader<Uint8Array>;
         writer: WritableStreamDefaultWriter<Uint8Array>;
     }) | undefined>;
     constructor(options?: SocketConstructorOpts & DuplexOptions & {
-        connection?: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET']>;
+        connection?: ReturnType<Resolvers['webVpnTcpSocket']>;
     });
-    __webvpn_tcp_socket_init__(connection: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET']>): Promise<({
+    __webvpn_tcp_socket_init__(connection: ReturnType<Resolvers['webVpnTcpSocket']>): Promise<({
         localAddress: string;
         localFamily: "IPv4" | "IPv6";
         localPort: number;
         remoteAddress: string;
         remoteFamily: "IPv4" | "IPv6";
         remotePort: number;
-        dataReadableStream: ReadableStream<Uint8Array<ArrayBuffer>>;
-        dataWritableStream: WritableStream<Uint8Array<ArrayBuffer>>;
+        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
+        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
         end: () => Promise<void>;
         destroy: () => Promise<void>;
         destroySoon: () => Promise<void>;
         resetAndDestroy: () => Promise<void>;
+        setOption: (option: import('../../api/webvpn/tcp').TcpSocketOption) => Promise<void>;
     } & {
         reader: ReadableStreamDefaultReader<Uint8Array>;
         writer: WritableStreamDefaultWriter<Uint8Array>;
@@ -52,9 +53,15 @@ export declare class Socket extends Stream.Duplex implements NetSocket {
     _destroy(error?: Error | null | undefined): this;
     destroySoon(): void;
     resetAndDestroy(): this;
+    _timeoutMs?: number;
+    _timeoutTimer?: ReturnType<typeof setTimeout>;
+    _restartTimeoutTimer(): void;
     setTimeout(timeout: number, callback?: (() => void) | undefined): this;
     setNoDelay(noDelay?: boolean | undefined): this;
     setKeepAlive(enable?: boolean | undefined, initialDelay?: number | undefined): this;
+    setSendBufferSize(size: number): this;
+    setRecvBufferSize(size: number): this;
+    _setTcpOption(option: import('../../api/webvpn/tcp').TcpSocketOption): void;
     write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
     write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
     address(): AddressInfo | {};
@@ -69,7 +76,7 @@ export declare class Socket extends Stream.Duplex implements NetSocket {
     get localAddress(): string;
     get localPort(): number;
     get localFamily(): string;
-    readyState: SocketReadyState;
+    readyState: 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
     get remoteAddress(): string;
     get remotePort(): number;
     get remoteFamily(): string;
@@ -87,11 +94,11 @@ export declare class Server extends EventEmitter implements TCPServer {
         family: string;
         port: number;
     };
-    _webVPNTcpSocketListenerPromise?: Promise<Awaited<ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET_LISTENER']>> | undefined>;
+    _webVPNTcpSocketListenerPromise?: Promise<Awaited<ReturnType<Resolvers['webVpnTcpSocketListener']>> | undefined>;
     constructor(options?: ServerOpts & EventEmitterOptions & {
-        connection?: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET_LISTENER']>;
+        connection?: ReturnType<Resolvers['webVpnTcpSocketListener']>;
     }, connectionListener?: (socket: Socket) => void);
-    __webvpn_tcp_socket_listener_init__(connection: ReturnType<ApiResolvers['WEBVPN_TCP_SOCKET_LISTENER']>): Promise<{
+    __webvpn_tcp_socket_listener_init__(connection: ReturnType<Resolvers['webVpnTcpSocketListener']>): Promise<{
         localAddress: string;
         localFamily: "IPv4" | "IPv6";
         localPort: number;
@@ -109,7 +116,7 @@ export declare class Server extends EventEmitter implements TCPServer {
     listen(port?: unknown, hostname?: unknown, backlog?: unknown, listeningListener?: unknown): this;
     close(callback?: ((err?: Error | undefined) => void) | undefined): this;
     address(): string | AddressInfo | null;
-    getConnections(cb: (error: Error | null, count: number) => void): void;
+    getConnections(cb: (error: Error | null, count: number) => void): this;
     ref(): this;
     unref(): this;
     maxConnections: number;