mirror of
https://github.com/dawidd6/action-send-mail.git
synced 2026-09-17 09:06:48 +07:00
node_modules: update (#322)
Co-authored-by: dawidd6 <9713907+dawidd6@users.noreply.github.com>
This commit is contained in:
Dawid Dziurla
+330
@@ -0,0 +1,330 @@
|
||||
import { type Duplex, type Readable, type TransformOptions, type Writable } from 'node:stream';
|
||||
import type { NodemailerError } from '../errors.js';
|
||||
import type { OutgoingHttpHeaders } from 'node:http';
|
||||
/**
|
||||
* Options for a MimeNode
|
||||
*/
|
||||
export interface MimeNodeOptions {
|
||||
/** root node for this tree */
|
||||
rootNode?: MimeNode | undefined;
|
||||
/** immediate parent for this node */
|
||||
parentNode?: MimeNode | undefined;
|
||||
/** filename for an attachment node */
|
||||
filename?: string | undefined;
|
||||
/** shared part of the unique multipart boundary */
|
||||
baseBoundary?: string | undefined;
|
||||
/** prefix for the generated multipart boundaries, defaults to '--_NmP' */
|
||||
boundaryPrefix?: string | undefined;
|
||||
/** If true, do not exclude Bcc from the generated headers */
|
||||
keepBcc?: boolean | undefined;
|
||||
/** method to normalize header keys for custom caseing */
|
||||
normalizeHeaderKey?: ((key: string, value: string) => string) | undefined;
|
||||
/** either 'Q' (the default) or 'B' */
|
||||
textEncoding?: string | undefined;
|
||||
/** Hostname for default message-id values */
|
||||
hostname?: string | undefined;
|
||||
/** If set to 'win' then uses \r\n, if 'linux' then \n. If not set (or `raw` is used) then newlines are kept as is */
|
||||
newline?: string | undefined;
|
||||
/** Reject content that points to a file path, for this node and every node below it */
|
||||
disableFileAccess?: boolean | undefined;
|
||||
/** Reject content that points to a URL, for this node and every node below it */
|
||||
disableUrlAccess?: boolean | undefined;
|
||||
}
|
||||
/**
|
||||
* An address object as accepted in address headers and produced by getAddresses. Either a
|
||||
* mailbox with an address or a group holding a list of addresses
|
||||
*/
|
||||
export interface MimeNodeAddress {
|
||||
name?: string | undefined;
|
||||
address?: string | undefined;
|
||||
group?: MimeNodeAddress[] | undefined;
|
||||
}
|
||||
/**
|
||||
* Addresses as accepted by address headers and envelope fields: an address string, an
|
||||
* address object, or an array of these, nested arrays included
|
||||
*/
|
||||
export type MimeNodeAddressInput = string | MimeNodeAddress | MimeNodeAddressInput[];
|
||||
/**
|
||||
* A header value object. When `prepared` is set the value is emitted as is, without
|
||||
* encoding, and folded only if `foldLines` is set as well
|
||||
*/
|
||||
export interface MimeNodePreparedHeaderValue {
|
||||
value?: unknown;
|
||||
prepared?: boolean | undefined;
|
||||
foldLines?: boolean | undefined;
|
||||
}
|
||||
/**
|
||||
* The values a header can hold: a string, a number, a Date (for the Date header), address
|
||||
* objects (for the address headers), a prepared value object, or a list of these
|
||||
*/
|
||||
export type MimeNodeHeaderValue = string | number | boolean | Date | MimeNodeAddress | MimeNodePreparedHeaderValue | MimeNodeHeaderValue[] | null | undefined;
|
||||
/**
|
||||
* A single header, the shape the headers are stored in and one of the list forms
|
||||
* setHeader and addHeader accept
|
||||
*/
|
||||
export interface MimeNodeHeader {
|
||||
key: string;
|
||||
value: MimeNodeHeaderValue;
|
||||
}
|
||||
/**
|
||||
* Several headers keyed by header name
|
||||
*/
|
||||
export interface MimeNodeHeaderMap {
|
||||
[key: string]: MimeNodeHeaderValue;
|
||||
}
|
||||
/**
|
||||
* Several headers at once, as accepted by setHeader and addHeader: a single {key, value}
|
||||
* pair, a list of them, or an object keyed by header name
|
||||
*/
|
||||
export type MimeNodeHeaders = MimeNodeHeader | MimeNodeHeader[] | MimeNodeHeaderMap;
|
||||
/**
|
||||
* A content descriptor object, see setContent. Points to the content instead of carrying it
|
||||
*/
|
||||
export interface MimeNodeContentObject {
|
||||
/** File path to read the content from */
|
||||
path?: string | undefined;
|
||||
/** URL to fetch the content from */
|
||||
href?: string | undefined;
|
||||
/** Request headers for a URL fetch */
|
||||
httpHeaders?: OutgoingHttpHeaders | undefined;
|
||||
/** TLS settings for a URL fetch, see nmfetch */
|
||||
tls?: {
|
||||
[key: string]: any;
|
||||
} | undefined;
|
||||
}
|
||||
/**
|
||||
* Body content as accepted by setContent and setRaw: a string, a Buffer, a readable stream
|
||||
* or an object pointing to the content
|
||||
*/
|
||||
export type MimeNodeContent = string | Buffer | Readable | MimeNodeContentObject;
|
||||
/**
|
||||
* SMTP envelope as returned by getEnvelope. Custom fields of an envelope set with
|
||||
* setEnvelope are carried along
|
||||
*/
|
||||
export interface MimeNodeEnvelope {
|
||||
from: string | false;
|
||||
to: string[];
|
||||
[key: string]: unknown;
|
||||
}
|
||||
/**
|
||||
* Envelope as accepted by setEnvelope. Recipients are collected from to, cc and bcc, any
|
||||
* other field is copied to the envelope as is
|
||||
*/
|
||||
export interface MimeNodeEnvelopeInput {
|
||||
from?: MimeNodeAddressInput | undefined;
|
||||
to?: MimeNodeAddressInput | undefined;
|
||||
cc?: MimeNodeAddressInput | undefined;
|
||||
bcc?: MimeNodeAddressInput | undefined;
|
||||
[key: string]: unknown;
|
||||
}
|
||||
/**
|
||||
* Parsed address headers as returned by getAddresses, keyed by lowercase header name
|
||||
*/
|
||||
export interface MimeNodeAddresses {
|
||||
from?: MimeNodeAddress[] | undefined;
|
||||
sender?: MimeNodeAddress[] | undefined;
|
||||
'reply-to'?: MimeNodeAddress[] | undefined;
|
||||
to?: MimeNodeAddress[] | undefined;
|
||||
cc?: MimeNodeAddress[] | undefined;
|
||||
bcc?: MimeNodeAddress[] | undefined;
|
||||
}
|
||||
/**
|
||||
* Options for createReadStream. Handed to the PassThrough the message is written to and to
|
||||
* the base64 / quoted-printable encoders, which read `lineLength` from it
|
||||
*/
|
||||
export interface MimeNodeStreamOptions extends TransformOptions {
|
||||
/** Maximum line length for base64 and quoted-printable bodies, false disables wrapping */
|
||||
lineLength?: number | false | undefined;
|
||||
}
|
||||
/**
|
||||
* A transform stream the message is piped through, or a function returning one
|
||||
*/
|
||||
export type MimeNodeTransform = Duplex | (() => Duplex);
|
||||
/**
|
||||
* A post process function, takes the message stream and returns the stream to expose instead
|
||||
*/
|
||||
export type MimeNodeProcessFunc = (input: Readable) => Readable;
|
||||
/**
|
||||
* Callback for build
|
||||
*/
|
||||
export type MimeNodeBuildCallback = (err: NodemailerError | null, message: Buffer) => void;
|
||||
/**
|
||||
* Creates a new mime tree node. Assumes 'multipart/*' as the content type
|
||||
* if it is a branch, anything else counts as leaf. If rootNode is missing from
|
||||
* the options, assumes this is the root.
|
||||
*
|
||||
* @param contentType Define the content type for the node. Can be left blank for attachments (derived from filename)
|
||||
* @param [options] optional options
|
||||
* @param [options.rootNode] root node for this tree
|
||||
* @param [options.parentNode] immediate parent for this node
|
||||
* @param [options.filename] filename for an attachment node
|
||||
* @param [options.baseBoundary] shared part of the unique multipart boundary
|
||||
* @param [options.keepBcc] If true, do not exclude Bcc from the generated headers
|
||||
* @param [options.normalizeHeaderKey] method to normalize header keys for custom caseing
|
||||
* @param [options.textEncoding] either 'Q' (the default) or 'B'
|
||||
*/
|
||||
declare class MimeNode {
|
||||
nodeCounter: number;
|
||||
baseBoundary: string;
|
||||
boundaryPrefix: string;
|
||||
disableFileAccess: boolean;
|
||||
disableUrlAccess: boolean;
|
||||
normalizeHeaderKey: MimeNodeOptions['normalizeHeaderKey'];
|
||||
date: Date | null;
|
||||
rootNode: MimeNode;
|
||||
keepBcc: boolean;
|
||||
textEncoding: string;
|
||||
parentNode: MimeNode | undefined;
|
||||
hostname: string | undefined;
|
||||
newline: string | undefined;
|
||||
childNodes: MimeNode[];
|
||||
/** Filename for this node. Useful with attachments */
|
||||
filename?: string | undefined;
|
||||
/** Body content, or the error a content stream emitted before it was read */
|
||||
content?: MimeNodeContent | Error | undefined;
|
||||
/** Lowercase content type, set when the headers are built */
|
||||
contentType?: string | undefined;
|
||||
/** Multipart subtype, false for a non-multipart node, set when the headers are built */
|
||||
multipart?: string | false | undefined;
|
||||
/** Multipart boundary, false for a non-multipart node, set when the headers are built */
|
||||
boundary?: string | false | undefined;
|
||||
constructor(contentType?: string | false, options?: MimeNodeOptions);
|
||||
/**
|
||||
* Creates and appends a child node.Arguments provided are passed to MimeNode constructor
|
||||
*
|
||||
* @param [contentType] Optional content type
|
||||
* @param [options] Optional options object
|
||||
* @return Created node object
|
||||
*/
|
||||
createChild(contentType?: string | false | MimeNodeOptions, options?: MimeNodeOptions): MimeNode;
|
||||
/**
|
||||
* Appends an existing node to the mime tree. Removes the node from an existing
|
||||
* tree if needed
|
||||
*
|
||||
* @param childNode node to be appended
|
||||
* @return Appended node object
|
||||
*/
|
||||
appendChild(childNode: MimeNode): MimeNode;
|
||||
/**
|
||||
* Replaces current node with another node
|
||||
*
|
||||
* @param node Replacement node
|
||||
* @return Replacement node
|
||||
*/
|
||||
replace(node: MimeNode): MimeNode;
|
||||
/**
|
||||
* Removes current node from the mime tree
|
||||
*
|
||||
* @return removed node
|
||||
*/
|
||||
remove(): MimeNode | undefined;
|
||||
/**
|
||||
* Sets a header value. If the value for selected key exists, it is overwritten.
|
||||
* You can set multiple values as well by using [{key:'', value:''}] or
|
||||
* {key: 'value'} as the first argument.
|
||||
*
|
||||
* @param key Header key or a list of key value pairs
|
||||
* @param value Header value
|
||||
* @return current node
|
||||
*/
|
||||
setHeader(key: string | MimeNodeHeaders, value?: MimeNodeHeaderValue): this;
|
||||
/**
|
||||
* Adds a header value. If the value for selected key exists, the value is appended
|
||||
* as a new field and old one is not touched.
|
||||
* You can set multiple values as well by using [{key:'', value:''}] or
|
||||
* {key: 'value'} as the first argument.
|
||||
*
|
||||
* @param key Header key or a list of key value pairs
|
||||
* @param value Header value
|
||||
* @return current node
|
||||
*/
|
||||
addHeader(key: string | MimeNodeHeaders, value?: MimeNodeHeaderValue): this;
|
||||
/**
|
||||
* Retrieves the first mathcing value of a selected key
|
||||
*
|
||||
* @param key Key to search for
|
||||
* @retun Value for the key
|
||||
*/
|
||||
getHeader(key: string): MimeNodeHeaderValue;
|
||||
/**
|
||||
* Sets body content for current node. If the value is a string, charset is added automatically
|
||||
* to Content-Type (if it is text/*). If the value is a Buffer, you need to specify
|
||||
* the charset yourself
|
||||
*
|
||||
* @param content Body content
|
||||
* @return current node
|
||||
*/
|
||||
setContent(content: MimeNodeContent): this;
|
||||
build(): Promise<Buffer>;
|
||||
build(callback: MimeNodeBuildCallback): void;
|
||||
getTransferEncoding(): string | false;
|
||||
/**
|
||||
* Builds the header block for the mime node. Append \r\n\r\n before writing the content
|
||||
*
|
||||
* @returns Headers
|
||||
*/
|
||||
buildHeaders(): string;
|
||||
/**
|
||||
* Streams the rfc2822 message from the current node. If this is a root node,
|
||||
* mandatory header fields are set if missing (Date, Message-Id, MIME-Version)
|
||||
*
|
||||
* @return Compiled message
|
||||
*/
|
||||
createReadStream(options?: MimeNodeStreamOptions): Readable;
|
||||
/**
|
||||
* Appends a transform stream object to the transforms list. Final output
|
||||
* is passed through this stream before exposing
|
||||
*
|
||||
* @param transform Read-Write stream
|
||||
*/
|
||||
transform(transform: MimeNodeTransform): void;
|
||||
/**
|
||||
* Appends a post process function. The functon is run after transforms and
|
||||
* uses the following syntax
|
||||
*
|
||||
* processFunc(input) -> outputStream
|
||||
*
|
||||
* @param processFunc Read-Write stream
|
||||
*/
|
||||
processFunc(processFunc: MimeNodeProcessFunc): void;
|
||||
stream(outputStream: Writable, options: MimeNodeStreamOptions, done: (err?: Error | null) => void): void;
|
||||
/**
|
||||
* Sets envelope to be used instead of the generated one
|
||||
*
|
||||
* @return SMTP envelope in the form of {from: 'from@example.com', to: ['to@example.com']}
|
||||
*/
|
||||
setEnvelope(envelope: MimeNodeEnvelopeInput): this;
|
||||
/**
|
||||
* Generates and returns an object with parsed address fields
|
||||
*
|
||||
* @return Address object
|
||||
*/
|
||||
getAddresses(): MimeNodeAddresses;
|
||||
/**
|
||||
* Generates and returns SMTP envelope with the sender address and a list of recipients addresses
|
||||
*
|
||||
* @return SMTP envelope in the form of {from: 'from@example.com', to: ['to@example.com']}
|
||||
*/
|
||||
getEnvelope(): MimeNodeEnvelope;
|
||||
/**
|
||||
* Returns Message-Id value. If it does not exist, then creates one
|
||||
*
|
||||
* @return Message-Id value
|
||||
*/
|
||||
messageId(): string;
|
||||
/**
|
||||
* Sets pregenerated content that will be used as the output of this node
|
||||
*
|
||||
* @param raw Raw MIME contents
|
||||
*/
|
||||
setRaw(raw: MimeNodeContent): this;
|
||||
}
|
||||
/**
|
||||
* Type aliases in the layout of @types/nodemailer, so `MimeNode.Options` style references keep working
|
||||
*/
|
||||
declare namespace MimeNode {
|
||||
type Options = MimeNodeOptions;
|
||||
type Addresses = MimeNodeAddresses;
|
||||
type Envelope = MimeNodeEnvelope;
|
||||
}
|
||||
export default MimeNode;
|
||||
Reference in New Issue
Block a user