react-native-nitro-net 0.2.0 → 0.3.0

package/lib/https.d.ts

@@ -0,0 +1,24 @@
+import * as http from './http';
+import * as tls from './tls';
+import { IncomingMessage } from './http';
+export declare class Server extends tls.Server {
+    private _httpConnections;
+    maxHeaderSize: number;
+    maxRequestsPerSocket: number;
+    headersTimeout: number;
+    requestTimeout: number;
+    keepAliveTimeout: number;
+    constructor(options?: any, requestListener?: (req: http.IncomingMessage, res: http.ServerResponse) => void);
+    setTimeout(ms: number, callback?: () => void): this;
+}
+export declare function createServer(options?: any, requestListener?: (req: http.IncomingMessage, res: http.ServerResponse) => void): Server;
+export declare class ClientRequest extends http.ClientRequest {
+    constructor(options: any, callback?: (res: http.IncomingMessage) => void);
+}
+export declare function request(urlOrOptions: string | URL | http.RequestOptions, optionsOrCallback?: http.RequestOptions | ((res: http.IncomingMessage) => void), callback?: (res: http.IncomingMessage) => void): ClientRequest;
+export declare function get(urlOrOptions: string | URL | http.RequestOptions, optionsOrCallback?: http.RequestOptions | ((res: http.IncomingMessage) => void), callback?: (res: http.IncomingMessage) => void): ClientRequest;
+export declare class Agent extends http.Agent {
+    constructor(options?: any);
+}
+export declare const globalAgent: Agent;
+export { IncomingMessage };

package/lib/https.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncomingMessage = exports.globalAgent = exports.Agent = exports.ClientRequest = exports.Server = void 0;
+exports.createServer = createServer;
+exports.request = request;
+exports.get = get;
+const http = __importStar(require("./http"));
+const tls = __importStar(require("./tls"));
+const http_1 = require("./http");
+Object.defineProperty(exports, "IncomingMessage", { enumerable: true, get: function () { return http_1.IncomingMessage; } });
+// ========== Server ==========
+class Server extends tls.Server {
+    constructor(options, requestListener) {
+        if (typeof options === 'function') {
+            requestListener = options;
+            options = {};
+        }
+        super(options);
+        this._httpConnections = new Set();
+        this.maxHeaderSize = 16384;
+        this.maxRequestsPerSocket = 0;
+        this.headersTimeout = 60000;
+        this.requestTimeout = 300000;
+        this.keepAliveTimeout = 5000;
+        if (requestListener) {
+            this.on('request', requestListener);
+        }
+        // Initialize HTTP connection setup for secure connections
+        this.on('secureConnection', (socket) => {
+            // @ts-ignore - access internal http logic
+            http.Server.prototype._setupHttpConnection.call(this, socket);
+        });
+    }
+    setTimeout(ms, callback) {
+        // @ts-ignore - access netServer via super's internal or cast
+        this._netServer.setTimeout(ms, callback);
+        return this;
+    }
+}
+exports.Server = Server;
+function createServer(options, requestListener) {
+    return new Server(options, requestListener);
+}
+// ========== ClientRequest ==========
+class ClientRequest extends http.ClientRequest {
+    constructor(options, callback) {
+        if (typeof options === 'string') {
+            options = new URL(options);
+        }
+        if (options instanceof URL) {
+            options = {
+                protocol: options.protocol,
+                hostname: options.hostname,
+                path: options.pathname + options.search,
+                port: options.port ? parseInt(options.port) : 443
+            };
+        }
+        options.protocol = 'https:';
+        super(options, callback);
+    }
+}
+exports.ClientRequest = ClientRequest;
+function request(urlOrOptions, optionsOrCallback, callback) {
+    let opts = {};
+    let cb = callback;
+    if (typeof urlOrOptions === 'string') {
+        const url = new URL(urlOrOptions);
+        opts = {
+            protocol: url.protocol,
+            hostname: url.hostname,
+            path: url.pathname + url.search,
+            port: url.port ? parseInt(url.port) : 443
+        };
+    }
+    else if (urlOrOptions instanceof URL) {
+        opts = {
+            protocol: urlOrOptions.protocol,
+            hostname: urlOrOptions.hostname,
+            path: urlOrOptions.pathname + urlOrOptions.search,
+            port: urlOrOptions.port ? parseInt(urlOrOptions.port) : 443
+        };
+    }
+    else {
+        opts = { ...urlOrOptions };
+    }
+    if (typeof optionsOrCallback === 'function') {
+        cb = optionsOrCallback;
+    }
+    else if (optionsOrCallback) {
+        opts = { ...opts, ...optionsOrCallback };
+    }
+    opts.protocol = 'https:';
+    return new ClientRequest(opts, cb);
+}
+function get(urlOrOptions, optionsOrCallback, callback) {
+    const req = request(urlOrOptions, optionsOrCallback, callback);
+    req.end();
+    return req;
+}
+// ========== Agent ==========
+class Agent extends http.Agent {
+    constructor(options) {
+        super(options);
+    }
+}
+exports.Agent = Agent;
+exports.globalAgent = new Agent({
+    keepAlive: true,
+    scheduling: 'lifo',
+    timeout: 5000,
+});

package/lib/index.d.ts

@@ -4,6 +4,7 @@ import type { NetSocketDriver, NetConfig } from './Net.nitro';
 declare function isIP(input: string): number;
 declare function isIPv4(input: string): boolean;
 declare function isIPv6(input: string): boolean;
+declare function isVerbose(): boolean;
 declare function setVerbose(enabled: boolean): void;
 declare function getDefaultAutoSelectFamily(): number;
 declare function setDefaultAutoSelectFamily(family: number): void;
@@ -23,24 +24,56 @@ declare function setDefaultAutoSelectFamily(family: number): void;
  * ```
  */
 declare function initWithConfig(config: NetConfig): void;
+export interface SocketAddressOptions {
+    address?: string;
+    family?: 'ipv4' | 'ipv6';
+    port?: number;
+    flowlabel?: number;
+}
 export declare class SocketAddress {
     readonly address: string;
     readonly family: 'ipv4' | 'ipv6';
     readonly port: number;
     readonly flowlabel: number;
-    constructor(options: {
-        address: string;
-        family?: 'ipv4' | 'ipv6';
-        port: number;
-        flowlabel?: number;
-    });
+    constructor(options?: SocketAddressOptions);
+    /**
+     * Attempts to parse a string containing a socket address.
+     * Returns a SocketAddress if successful, or undefined if not.
+     *
+     * Supported formats:
+     * - `ip:port` (e.g., `127.0.0.1:8080`, `[::1]:8080`)
+     * - `ip` only (port defaults to 0)
+     */
+    static parse(input: string): SocketAddress | undefined;
+}
+export interface BlockListRule {
+    type: 'address' | 'range' | 'subnet';
+    address?: string;
+    start?: string;
+    end?: string;
+    prefix?: number;
+    family: 'ipv4' | 'ipv6';
 }
 export declare class BlockList {
     private _rules;
+    /** Returns an array of rules added to the blocklist. */
+    get rules(): BlockListRule[];
     addAddress(address: string, family?: 'ipv4' | 'ipv6'): void;
     addRange(start: string, end: string, family?: 'ipv4' | 'ipv6'): void;
     addSubnet(net: string, prefix: number, family?: 'ipv4' | 'ipv6'): void;
     check(address: string, family?: 'ipv4' | 'ipv6'): boolean;
+    /**
+     * Serializes the BlockList to a JSON-compatible format.
+     */
+    toJSON(): BlockListRule[];
+    /**
+     * Creates a BlockList from a JSON array of rules.
+     */
+    static fromJSON(json: BlockListRule[]): BlockList;
+    /**
+     * Checks if a given value is a BlockList instance.
+     */
+    static isBlockList(value: unknown): value is BlockList;
 }
 export interface SocketOptions extends DuplexOptions {
     fd?: any;
@@ -65,6 +98,7 @@ export declare class Socket extends Duplex {
     bytesWritten: number;
     autoSelectFamilyAttemptedAddresses: string[];
     private _autoSelectFamily;
+    private _timeout;
     get localFamily(): string;
     get readyState(): string;
     get pending(): boolean;
@@ -110,7 +144,7 @@ export declare class Socket extends Duplex {
      * Use 'utf8', 'hex', etc.
      */
     setEncoding(encoding: BufferEncoding): this;
-    get timeout(): number | undefined;
+    get timeout(): number;
     get bufferSize(): number;
     resetAndDestroy(): this;
 }
@@ -142,7 +176,9 @@ export declare function createConnection(options: any, connectionListener?: () =
 export declare const connect: typeof createConnection;
 export declare function createServer(options?: any, connectionListener?: (socket: Socket) => void): Server;
 export * as tls from './tls';
-export { isIP, isIPv4, isIPv6, getDefaultAutoSelectFamily, setDefaultAutoSelectFamily, setVerbose, initWithConfig, };
+export * as http from './http';
+export * as https from './https';
+export { isIP, isIPv4, isIPv6, getDefaultAutoSelectFamily, setDefaultAutoSelectFamily, isVerbose, setVerbose, initWithConfig, };
 export type { NetConfig };
 declare const _default: {
     Socket: typeof Socket;
@@ -159,5 +195,7 @@ declare const _default: {
     setDefaultAutoSelectFamily: typeof setDefaultAutoSelectFamily;
     setVerbose: typeof setVerbose;
     initWithConfig: typeof initWithConfig;
+    http: any;
+    https: any;
 };
 export default _default;

package/lib/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tls = exports.connect = exports.Server = exports.Socket = exports.BlockList = exports.SocketAddress = void 0;
+exports.https = exports.http = exports.tls = exports.connect = exports.Server = exports.Socket = exports.BlockList = exports.SocketAddress = void 0;
 exports.createConnection = createConnection;
 exports.createServer = createServer;
 exports.isIP = isIP;
@@ -41,6 +41,7 @@ exports.isIPv4 = isIPv4;
 exports.isIPv6 = isIPv6;
 exports.getDefaultAutoSelectFamily = getDefaultAutoSelectFamily;
 exports.setDefaultAutoSelectFamily = setDefaultAutoSelectFamily;
+exports.isVerbose = isVerbose;
 exports.setVerbose = setVerbose;
 exports.initWithConfig = initWithConfig;
 const readable_stream_1 = require("readable-stream");
@@ -74,14 +75,18 @@ function isIPv6(input) {
 let _autoSelectFamilyDefault = 4; // Node default is usually 4/6 independent, but we mock it.
 let _isVerbose = false;
 let _isInitialized = false;
-function debugLog(message) {
-    if (_isVerbose) {
-        console.log(`[NET DEBUG] ${message}`);
-    }
+function isVerbose() {
+    return _isVerbose;
 }
 function setVerbose(enabled) {
     _isVerbose = enabled;
 }
+function debugLog(message) {
+    if (_isVerbose) {
+        const timestamp = new Date().toISOString().split('T')[1].split('Z')[0];
+        console.log(`[NET DEBUG ${timestamp}] ${message}`);
+    }
+}
 function getDefaultAutoSelectFamily() {
     return _autoSelectFamilyDefault;
 }
@@ -116,29 +121,84 @@ function ensureInitialized() {
  */
 function initWithConfig(config) {
     _isInitialized = true;
+    if (config.debug !== undefined) {
+        setVerbose(config.debug);
+    }
     Driver_1.Driver.initWithConfig(config);
 }
-// -----------------------------------------------------------------------------
-// SocketAddress
-// -----------------------------------------------------------------------------
-// SocketAddress
-// -----------------------------------------------------------------------------
 class SocketAddress {
-    constructor(options) {
-        this.address = options.address;
-        this.family = options.family || (isIPv6(options.address) ? 'ipv6' : 'ipv4');
-        this.port = options.port;
-        this.flowlabel = options.flowlabel || 0;
+    constructor(options = {}) {
+        this.address = options.address ?? (options.family === 'ipv6' ? '::' : '127.0.0.1');
+        this.family = options.family || (isIPv6(this.address) ? 'ipv6' : 'ipv4');
+        this.port = options.port ?? 0;
+        this.flowlabel = options.flowlabel ?? 0;
+    }
+    /**
+     * Attempts to parse a string containing a socket address.
+     * Returns a SocketAddress if successful, or undefined if not.
+     *
+     * Supported formats:
+     * - `ip:port` (e.g., `127.0.0.1:8080`, `[::1]:8080`)
+     * - `ip` only (port defaults to 0)
+     */
+    static parse(input) {
+        if (!input || typeof input !== 'string')
+            return undefined;
+        let address;
+        let port = 0;
+        // Handle IPv6 bracket notation: [::1]:port
+        const ipv6Match = input.match(/^\[([^\]]+)\]:?(\d*)$/);
+        if (ipv6Match) {
+            address = ipv6Match[1];
+            port = ipv6Match[2] ? parseInt(ipv6Match[2], 10) : 0;
+            if (!isIPv6(address))
+                return undefined;
+            return new SocketAddress({ address, port, family: 'ipv6' });
+        }
+        // Handle IPv4 or IPv6 without brackets
+        const lastColon = input.lastIndexOf(':');
+        if (lastColon === -1) {
+            // No port, just IP
+            address = input;
+        }
+        else {
+            // Determine if the colon is a port separator or part of IPv6
+            const potentialPort = input.slice(lastColon + 1);
+            const potentialAddr = input.slice(0, lastColon);
+            if (/^\d+$/.test(potentialPort) && (isIPv4(potentialAddr) || isIPv6(potentialAddr))) {
+                address = potentialAddr;
+                port = parseInt(potentialPort, 10);
+            }
+            else {
+                // It's an IPv6 address without port
+                address = input;
+            }
+        }
+        const family = isIPv6(address) ? 'ipv6' : (isIPv4(address) ? 'ipv4' : undefined);
+        if (!family)
+            return undefined;
+        return new SocketAddress({ address, port, family });
     }
 }
 exports.SocketAddress = SocketAddress;
-// -----------------------------------------------------------------------------
-// BlockList
-// -----------------------------------------------------------------------------
 class BlockList {
     constructor() {
         this._rules = [];
     }
+    /** Returns an array of rules added to the blocklist. */
+    get rules() {
+        return this._rules.map(r => {
+            if (r.type === 'address') {
+                return { type: 'address', address: r.data.address, family: r.data.family };
+            }
+            else if (r.type === 'range') {
+                return { type: 'range', start: r.data.start, end: r.data.end, family: r.data.family };
+            }
+            else {
+                return { type: 'subnet', address: r.data.net, prefix: r.data.prefix, family: r.data.family };
+            }
+        });
+    }
     addAddress(address, family) {
         this._rules.push({ type: 'address', data: { address, family: family || (isIPv6(address) ? 'ipv6' : 'ipv4') } });
     }
@@ -173,6 +233,36 @@ class BlockList {
         }
         return false;
     }
+    /**
+     * Serializes the BlockList to a JSON-compatible format.
+     */
+    toJSON() {
+        return this.rules;
+    }
+    /**
+     * Creates a BlockList from a JSON array of rules.
+     */
+    static fromJSON(json) {
+        const list = new BlockList();
+        for (const rule of json) {
+            if (rule.type === 'address' && rule.address) {
+                list.addAddress(rule.address, rule.family);
+            }
+            else if (rule.type === 'range' && rule.start && rule.end) {
+                list.addRange(rule.start, rule.end, rule.family);
+            }
+            else if (rule.type === 'subnet' && rule.address && rule.prefix !== undefined) {
+                list.addSubnet(rule.address, rule.prefix, rule.family);
+            }
+        }
+        return list;
+    }
+    /**
+     * Checks if a given value is a BlockList instance.
+     */
+    static isBlockList(value) {
+        return value instanceof BlockList;
+    }
 }
 exports.BlockList = BlockList;
 function ipv4ToLong(ip) {
@@ -205,7 +295,9 @@ class Socket extends readable_stream_1.Duplex {
         super({
             allowHalfOpen: options?.allowHalfOpen ?? false,
             readable: options?.readable ?? true,
-            writable: options?.writable ?? true
+            writable: options?.writable ?? true,
+            // @ts-ignore
+            autoDestroy: false
         });
         this.connecting = false; // Changed from private _connecting
         this._connected = false;
@@ -214,11 +306,14 @@ class Socket extends readable_stream_1.Duplex {
         this.bytesWritten = 0;
         this.autoSelectFamilyAttemptedAddresses = [];
         this._autoSelectFamily = false;
+        this._timeout = 0;
         if (options?.socketDriver) {
             // Wrapping existing socket (from Server)
             this._driver = options.socketDriver;
             this._connected = true;
             this._setupEvents();
+            // Enable noDelay by default
+            this._driver.setNoDelay(true);
             // Resume the socket since it starts paused on server-accept
             this.resume();
             // Emit connect for server-side socket? No, it's already connected.
@@ -228,8 +323,10 @@ class Socket extends readable_stream_1.Duplex {
             ensureInitialized();
             this._driver = Driver_1.Driver.createSocket();
             this._setupEvents();
-            // Also resume client socket initially so it's ready to receive
-            this.resume();
+            // Enable noDelay by default to match Node.js and reduce latency for small writes
+            this._driver.setNoDelay(true);
+            // Do NOT resume here - socket is not connected yet!
+            // resume() will be called after 'connect' event in _connect()
         }
         this.on('finish', () => {
             // Writable side finished
@@ -268,6 +365,8 @@ class Socket extends readable_stream_1.Duplex {
                     this.connecting = false;
                     this._connected = true;
                     this._updateAddresses();
+                    // Now that we're connected, start receiving data
+                    this.resume();
                     this.emit('connect');
                     this.emit('ready');
                     break;
@@ -407,6 +506,7 @@ class Socket extends readable_stream_1.Duplex {
         else {
             this._autoSelectFamily = true;
         }
+        debugLog(`Socket.connect: target=${host}:${port}, autoSelectFamily=${this._autoSelectFamily}`);
         return this._connect(port, host, connectionListener, options.signal);
     }
     _connect(port, host, listener, signal) {
@@ -428,6 +528,7 @@ class Socket extends readable_stream_1.Duplex {
             this.once('connect', () => signal.removeEventListener('abort', abortHandler));
             this.once('close', () => signal.removeEventListener('abort', abortHandler));
         }
+        debugLog(`Socket._connect: Calling driver.connect(${host}, ${port})`);
         this._driver?.connect(host, port);
         return this;
     }
@@ -499,6 +600,7 @@ class Socket extends readable_stream_1.Duplex {
     }
     // Standard net.Socket methods
     setTimeout(msecs, callback) {
+        this._timeout = msecs;
         if (this._driver) {
             this._driver.setTimeout(msecs);
         }
@@ -521,12 +623,13 @@ class Socket extends readable_stream_1.Duplex {
      * Resume reading after a call to pause().
      */
     resume() {
-        const id = this._driver?.id;
-        debugLog(`Socket.resume() called, id: ${id}`);
+        const driver = this._driver;
+        const id = driver?.id;
+        debugLog(`Socket.resume() called, id: ${id === undefined ? 'none' : id}, destroyed: ${this.destroyed}`);
         super.resume();
-        if (this._driver) {
+        if (driver) {
             debugLog(`Socket.resume() calling driver.resume(), id: ${id}`);
-            this._driver.resume();
+            driver.resume();
         }
         return this;
     }
@@ -552,7 +655,7 @@ class Socket extends readable_stream_1.Duplex {
         return this;
     }
     get timeout() {
-        return undefined; // Not tracked strictly as a property yet
+        return this._timeout;
     }
     get bufferSize() {
         return 0; // Deprecated but often accessed
@@ -804,6 +907,8 @@ function createServer(options, connectionListener) {
     return new Server(options, connectionListener);
 }
 exports.tls = __importStar(require("./tls"));
+exports.http = __importStar(require("./http"));
+exports.https = __importStar(require("./https"));
 exports.default = {
     Socket,
     Server,
@@ -819,4 +924,6 @@ exports.default = {
     setDefaultAutoSelectFamily,
     setVerbose,
     initWithConfig,
+    http: require('./http'),
+    https: require('./https'),
 };

package/lib/tls.d.ts

@@ -26,6 +26,13 @@ export interface ConnectionOptions extends SocketOptions {
     pfx?: string | ArrayBuffer;
     passphrase?: string;
     keylog?: boolean;
+    /**
+     * Custom hostname verification function.
+     * If provided, it will be called after the TLS handshake to verify the peer certificate.
+     * Return `undefined` if valid, or an `Error` if invalid.
+     * If not provided, the default `checkServerIdentity` is used.
+     */
+    checkServerIdentity?: (hostname: string, cert: PeerCertificate) => Error | undefined;
 }
 export interface SecureContextOptions {
     pfx?: string | ArrayBuffer;
@@ -70,6 +77,20 @@ export declare class TLSSocket extends Socket {
     getSharedSigalgs(): string | undefined;
     renegotiate(options: any, callback: (err: Error | null) => void): boolean;
     disableRenegotiation(): void;
+    /**
+     * Enables trace output for this socket.
+     */
+    enableTrace(): void;
+    /**
+     * Exports keying material for use by external protocols.
+     *
+     * @param length The number of bytes to return.
+     * @param label A label identifying the keying material.
+     * @param context An optional context.
+     * @returns Buffer containing keying material.
+     * @throws Error if export fails (e.g., TLS not connected).
+     */
+    exportKeyingMaterial(length: number, label: string, context?: Buffer): Buffer;
     constructor(socket: Socket, options?: ConnectionOptions);
     constructor(options: ConnectionOptions);
     connect(options: any, connectionListener?: () => void): this;