imapflow 1.7.8 → 2.0.0

package/dist/esm/jp-decoder.d.ts

@@ -0,0 +1,12 @@
+import { Transform, type TransformCallback } from 'node:stream';
+export declare class JPDecoder extends Transform {
+    charset: string;
+    chunks: Buffer[];
+    chunklen: number;
+    maxBytes: number;
+    limited: boolean;
+    constructor(charset: string, maxBytes?: number | undefined);
+    _transform(chunk: Buffer | string, encoding: BufferEncoding, done: TransformCallback): void;
+    _flush(done: TransformCallback): void;
+    _destroy(err: Error | null, callback: (error: Error | null) => void): void;
+}

package/{lib → dist/esm}/jp-decoder.js

@@ -1,59 +1,47 @@
-'use strict';
-
-const { Transform } = require('stream');
-const encodingJapanese = require('encoding-japanese');
-const { normalizeByteLimit } = require('./limited-passthrough.js');
-
+import { Transform } from 'node:stream';
+import encodingJapanese from 'encoding-japanese';
+import { normalizeByteLimit } from './limited-passthrough.js';
 // A Transform stream for decoding Japanese character sets (Shift_JIS, EUC-JP, ISO-2022-JP).
 // Unlike iconv-lite which can decode incrementally, encoding-japanese requires the complete
 // input buffer for accurate charset detection and stateful decoding (especially ISO-2022-JP
 // which uses escape sequences to switch between ASCII and multi-byte modes). Therefore,
 // this stream buffers all input during _transform and performs the actual decoding in _flush.
-class JPDecoder extends Transform {
+export class JPDecoder extends Transform {
     constructor(charset, maxBytes) {
         super();
-
         this.charset = charset;
         this.chunks = [];
         this.chunklen = 0;
-
         // Upper bound for the buffered bytes, normalized the same way LimitedPassthrough
         // normalizes its own. The whole-input buffering defeats a downstream maxBytes limiter
         // (nothing is emitted until _flush), so without an internal bound a server could force
         // unbounded memory use through a caller that asked for a limited download. Excess input
         // is truncated, mirroring the truncation a maxBytes download applies anyway.
         this.maxBytes = normalizeByteLimit(maxBytes);
-
         // Also mirroring LimitedPassthrough: true once the bound is reached and every further
         // chunk is being discarded. The download loop reads this to stop pulling from the
         // server, which the limiter at the tail of the pipeline cannot tell it, because nothing
         // is emitted from here until _flush().
         this.limited = false;
     }
-
     // Buffer all incoming chunks (up to maxBytes); no decoding happens here because
     // Japanese charsets require the complete input for accurate conversion.
     _transform(chunk, encoding, done) {
         if (typeof chunk === 'string') {
             chunk = Buffer.from(chunk, encoding);
         }
-
         if (this.chunklen + chunk.length > this.maxBytes) {
             chunk = chunk.slice(0, Math.max(0, this.maxBytes - this.chunklen));
         }
-
         if (chunk.length) {
             this.chunks.push(chunk);
             this.chunklen += chunk.length;
         }
-
         if (this.chunklen >= this.maxBytes) {
             this.limited = true;
         }
-
         done();
     }
-
     // Perform the actual charset conversion once all input has been received.
     // Uses the encoding-japanese library to convert from the source charset to Unicode.
     // On failure (corrupt or unrecognizable data), passes through the raw bytes unchanged.
@@ -69,19 +57,16 @@ class JPDecoder extends Transform {
                 output = Buffer.from(output);
             }
             this.push(output);
-        } catch {
+        }
+        catch {
             // keep as is on errors
             this.push(input);
         }
-
         done();
     }
-
     _destroy(err, callback) {
         this.chunks = [];
         this.chunklen = 0;
         callback(err);
     }
 }
-
-module.exports.JPDecoder = JPDecoder;

package/dist/esm/limited-passthrough.d.ts

@@ -0,0 +1,25 @@
+import { Transform, type TransformCallback } from 'node:stream';
+/**
+ * Normalizes a byte budget for the download pipeline. Any finite positive number is honored and
+ * floored, because byte counts are integers: with a fractional bound a counter can only ever
+ * reach its floor, so a stage would never report itself full and a loop polling that flag would
+ * keep pulling forever. Anything else - 0, NaN, a non-numeric value - means "no limit".
+ *
+ * Lives here rather than in tools.ts because tools.ts imports jp-decoder.ts, which needs this.
+ *
+ * @param value - The configured budget.
+ * @returns The normalized budget, or Infinity when unbounded.
+ */
+export declare const normalizeByteLimit: (value: unknown) => number;
+export interface LimitedPassthroughOptions {
+    /** Maximum number of bytes to pass through. Anything else means "no limit" */
+    maxBytes?: number | undefined;
+}
+export declare class LimitedPassthrough extends Transform {
+    options: LimitedPassthroughOptions;
+    maxBytes: number;
+    processed: number;
+    limited: boolean;
+    constructor(options?: LimitedPassthroughOptions | undefined);
+    _transform(chunk: Buffer, encoding: BufferEncoding, done: TransformCallback): void;
+}

package/{lib → dist/esm}/limited-passthrough.js

@@ -1,62 +1,49 @@
-'use strict';
-
-const { Transform } = require('stream');
-
+import { Transform } from 'node:stream';
 /**
  * Normalizes a byte budget for the download pipeline. Any finite positive number is honored and
  * floored, because byte counts are integers: with a fractional bound a counter can only ever
  * reach its floor, so a stage would never report itself full and a loop polling that flag would
  * keep pulling forever. Anything else - 0, NaN, a non-numeric value - means "no limit".
  *
- * Lives here rather than in tools.js because tools.js requires jp-decoder.js, which needs this.
+ * Lives here rather than in tools.ts because tools.ts imports jp-decoder.ts, which needs this.
  *
- * @param {*} value - The configured budget.
- * @returns {Number} The normalized budget, or Infinity when unbounded.
+ * @param value - The configured budget.
+ * @returns The normalized budget, or Infinity when unbounded.
  */
-const normalizeByteLimit = value => {
+export const normalizeByteLimit = (value) => {
     let bytes = Number(value);
     // Math.max keeps a sub-1 budget from flooring to 0, which would read back as "no limit"
     return Number.isFinite(bytes) && bytes > 0 ? Math.max(Math.floor(bytes), 1) : Infinity;
 };
-
 // A Transform stream that passes through data up to a maximum byte limit,
 // then silently discards all subsequent chunks. Used to enforce download
 // size limits when fetching message content from the IMAP server.
-class LimitedPassthrough extends Transform {
+export class LimitedPassthrough extends Transform {
     constructor(options) {
         super();
         this.options = options || {};
         this.maxBytes = normalizeByteLimit(this.options.maxBytes);
         this.processed = 0;
-        // Once set to true, all subsequent chunks are dropped without error
         this.limited = false;
     }
-
     _transform(chunk, encoding, done) {
         // If the limit was already reached, discard the chunk immediately
         if (this.limited) {
             return done();
         }
-
         const remainingBytes = this.maxBytes - this.processed;
         if (remainingBytes < 1) {
             return done();
         }
-
         // Slice the chunk to fit within the remaining byte budget
         if (chunk.length > remainingBytes) {
-            chunk = chunk.slice(0, remainingBytes);
+            chunk = chunk.subarray(0, remainingBytes);
         }
-
         this.processed += chunk.length;
         if (this.processed >= this.maxBytes) {
             this.limited = true;
         }
-
         this.push(chunk);
         done();
     }
 }
-
-module.exports.LimitedPassthrough = LimitedPassthrough;
-module.exports.normalizeByteLimit = normalizeByteLimit;

package/dist/esm/logger.d.ts

@@ -0,0 +1,3 @@
+import pino from 'pino';
+declare const logger: pino.Logger<never, boolean>;
+export default logger;

package/dist/esm/logger.js

@@ -0,0 +1,4 @@
+import pino from 'pino';
+const logger = pino();
+logger.level = 'trace';
+export default logger;

package/dist/esm/package-info.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "imapflow";
+export declare const version = "2.0.0";
+export declare const homepage = "https://imapflow.com/";

package/dist/esm/package-info.js

@@ -0,0 +1,4 @@
+// Generated by scripts/build.js from package.json. Do not edit by hand.
+export const name = 'imapflow';
+export const version = '2.0.0';
+export const homepage = 'https://imapflow.com/';

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/esm/proxy-connection.d.ts

@@ -0,0 +1,33 @@
+import net from 'node:net';
+import { ConnectionDeadline } from './connection-deadline.js';
+import type { InternalLogger } from './types.js';
+/**
+ * A socket handed out by the proxy helpers, carrying the early error handler installed by
+ * attachEarlyErrorHandler() until the caller takes ownership
+ */
+export type ProxySocket = net.Socket & {
+    _earlyErrorHandler?: ((err: Error) => void) | null | undefined;
+};
+export interface ProxyConnectionOptions {
+    /**
+     * Shared connection deadline. Proxy DNS and negotiation run inside it, so a stalled proxy
+     * cannot exceed the configured connectionTimeout.
+     */
+    deadline?: ConnectionDeadline | undefined;
+    /** Used to build a deadline when none was passed */
+    connectionTimeout?: number | undefined;
+}
+declare const detachEarlyErrorHandler: (socket: ProxySocket | false | null | undefined) => void;
+/**
+ * Opens a socket to `host`:`port` through the configured proxy.
+ *
+ * @param logger Logger instance.
+ * @param connectionUrl Proxy URL (http, https, socks, socks4, socks4a, socks5).
+ * @param host Destination host, passed through unresolved wherever the proxy protocol
+ *   can resolve it itself.
+ * @param port Destination port.
+ * @param options Deadline options, see ProxyConnectionOptions.
+ * @returns The tunnelled socket, or undefined for an unknown protocol.
+ */
+declare const proxyConnection: (logger: InternalLogger, connectionUrl: string, host: string, port: number, options?: ProxyConnectionOptions | undefined) => Promise<ProxySocket | undefined>;
+export { proxyConnection, detachEarlyErrorHandler };