@nocobase/plugin-workflow-mailer 2.3.0-beta.13 → 2.3.0-beta.14

package/dist/node_modules/nodemailer/dist/esm/mime-funcs/mime-types.d.ts

@@ -0,0 +1,2 @@
+export declare function detectMimeType(filename?: string | false): string;
+export declare function detectExtension(mimeType?: string | false): string;

package/dist/node_modules/nodemailer/{lib → dist/esm}/mime-funcs/mime-types.js

@@ -1,12 +1,7 @@
 /* eslint quote-props: 0 */
-
-'use strict';
-
-const path = require('path');
-
+import path from 'node:path';
 const defaultMimeType = 'application/octet-stream';
 const defaultExtension = 'bin';
-
 const mimeTypes = new Map([
     ['application/acad', 'dwg'],
     ['application/applixware', 'aw'],
@@ -2066,44 +2061,36 @@ const extensions = new Map([
     ['zoo', 'application/octet-stream'],
     ['zsh', 'text/x-script.zsh']
 ]);
-
-module.exports = {
-    detectMimeType(filename) {
-        if (!filename) {
-            return defaultMimeType;
-        }
-
-        const parsed = path.parse(filename);
-        const extension = (parsed.ext.substr(1) || parsed.name || '').split('?').shift().trim().toLowerCase();
-        const value = extensions.has(extension) ? extensions.get(extension) : defaultMimeType;
-
+export function detectMimeType(filename) {
+    if (!filename) {
+        return defaultMimeType;
+    }
+    const parsed = path.parse(filename);
+    const extension = (parsed.ext.substr(1) || parsed.name || '').split('?').shift().trim().toLowerCase();
+    const value = extensions.has(extension) ? extensions.get(extension) : defaultMimeType;
+    if (Array.isArray(value)) {
+        return value[0];
+    }
+    return value;
+}
+export function detectExtension(mimeType) {
+    if (!mimeType) {
+        return defaultExtension;
+    }
+    const parts = mimeType.toLowerCase().trim().split('/');
+    const rootType = parts.shift().trim();
+    const subType = parts.join('/').trim();
+    if (mimeTypes.has(rootType + '/' + subType)) {
+        const value = mimeTypes.get(rootType + '/' + subType);
         if (Array.isArray(value)) {
             return value[0];
         }
         return value;
-    },
-
-    detectExtension(mimeType) {
-        if (!mimeType) {
-            return defaultExtension;
-        }
-        const parts = mimeType.toLowerCase().trim().split('/');
-        const rootType = parts.shift().trim();
-        const subType = parts.join('/').trim();
-
-        if (mimeTypes.has(rootType + '/' + subType)) {
-            const value = mimeTypes.get(rootType + '/' + subType);
-            if (Array.isArray(value)) {
-                return value[0];
-            }
-            return value;
-        }
-
-        switch (rootType) {
-            case 'text':
-                return 'txt';
-            default:
-                return 'bin';
-        }
     }
-};
+    switch (rootType) {
+        case 'text':
+            return 'txt';
+        default:
+            return 'bin';
+    }
+}

package/dist/node_modules/nodemailer/dist/esm/mime-node/index.d.ts

@@ -0,0 +1,333 @@
+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. A `from` of false is the null sender of a
+ * bounce message, it is sent as MAIL FROM:<>
+ */
+export interface MimeNodeEnvelopeInput {
+    from?: MimeNodeAddressInput | false | 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;
+}
+/** The same aliases as module level exports, for `import * as MimeNode` and `import MimeNode = require()` */
+export type { MimeNodeOptions as Options, MimeNodeAddresses as Addresses, MimeNodeEnvelope as Envelope };
+export default MimeNode;