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

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

@@ -0,0 +1,5 @@
+import { Transform } from 'node:stream';
+export default class LastNewline extends Transform {
+    lastByte: number | false;
+    constructor();
+}

package/dist/node_modules/nodemailer/{lib → dist/esm}/mime-node/last-newline.js

@@ -1,22 +1,18 @@
-'use strict';
-
-const { Transform } = require('stream');
-
-class LastNewline extends Transform {
+import { Transform } from 'node:stream';
+export default class LastNewline extends Transform {
     constructor() {
         super();
         this.lastByte = false;
     }
-
+    /** @internal */
     _transform(chunk, encoding, done) {
         if (chunk.length) {
             this.lastByte = chunk[chunk.length - 1];
         }
-
         this.push(chunk);
         done();
     }
-
+    /** @internal */
     _flush(done) {
         if (this.lastByte === 0x0a) {
             return done();
@@ -29,5 +25,3 @@ class LastNewline extends Transform {
         return done();
     }
 }
-
-module.exports = LastNewline;

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

@@ -0,0 +1,9 @@
+import { Transform, type TransformOptions } from 'node:stream';
+/**
+ * Ensures that only <LF> is used for linebreaks
+ *
+ * @param options Stream options
+ */
+export default class LeUnix extends Transform {
+    constructor(options?: TransformOptions);
+}

package/dist/node_modules/nodemailer/{lib → dist/esm}/mime-node/le-unix.js

@@ -1,24 +1,20 @@
-'use strict';
-
-const { Transform } = require('stream');
-
+import { Transform } from 'node:stream';
 /**
  * Ensures that only <LF> is used for linebreaks
  *
- * @param {Object} options Stream options
+ * @param options Stream options
  */
-class LeUnix extends Transform {
+export default class LeUnix extends Transform {
     constructor(options) {
         super(options);
     }
-
     /**
      * Escapes dots
+     * @internal
      */
     _transform(chunk, encoding, done) {
         let buf;
         let lastPos = 0;
-
         for (let i = 0, len = chunk.length; i < len; i++) {
             if (chunk[i] === 0x0d) {
                 // \r
@@ -30,11 +26,10 @@ class LeUnix extends Transform {
         if (lastPos && lastPos < chunk.length) {
             buf = chunk.slice(lastPos);
             this.push(buf);
-        } else if (!lastPos) {
+        }
+        else if (!lastPos) {
             this.push(chunk);
         }
         done();
     }
 }
-
-module.exports = LeUnix;

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

@@ -0,0 +1,10 @@
+import { Transform, type TransformOptions } from 'node:stream';
+/**
+ * Ensures that only <CR><LF> sequences are used for linebreaks
+ *
+ * @param options Stream options
+ */
+export default class LeWindows extends Transform {
+    lastByte: number | false;
+    constructor(options?: TransformOptions);
+}

package/dist/node_modules/nodemailer/{lib → dist/esm}/mime-node/le-windows.js

@@ -1,25 +1,21 @@
-'use strict';
-
-const { Transform } = require('stream');
-
+import { Transform } from 'node:stream';
 /**
  * Ensures that only <CR><LF> sequences are used for linebreaks
  *
- * @param {Object} options Stream options
+ * @param options Stream options
  */
-class LeWindows extends Transform {
+export default class LeWindows extends Transform {
     constructor(options) {
         super(options);
         this.lastByte = false;
     }
-
     /**
      * Escapes dots
+     * @internal
      */
     _transform(chunk, encoding, done) {
         let buf;
         let lastPos = 0;
-
         for (let i = 0, len = chunk.length; i < len; i++) {
             if (chunk[i] === 0x0a) {
                 // \n
@@ -33,17 +29,14 @@ class LeWindows extends Transform {
                 }
             }
         }
-
         if (lastPos && lastPos < chunk.length) {
             buf = chunk.slice(lastPos);
             this.push(buf);
-        } else if (!lastPos) {
+        }
+        else if (!lastPos) {
             this.push(chunk);
         }
-
         this.lastByte = chunk[chunk.length - 1];
         done();
     }
 }
-
-module.exports = LeWindows;

package/dist/node_modules/nodemailer/dist/esm/nodemailer.d.ts

@@ -0,0 +1,124 @@
+import Mail from './mailer/index.js';
+import type { MailDefaults, SentMessageInfo, Transport, TransportOptions } from './mailer/index.js';
+import SMTPPool from './smtp-pool/index.js';
+import type { SMTPPoolOptions, SMTPPoolSentMessageInfo } from './smtp-pool/index.js';
+import SMTPTransport from './smtp-transport/index.js';
+import type { SMTPTransportOptions, SMTPSentMessageInfo } from './smtp-transport/index.js';
+import SendmailTransport from './sendmail-transport/index.js';
+import type { SendmailTransportOptions, SendmailSentMessageInfo } from './sendmail-transport/index.js';
+import StreamTransport from './stream-transport/index.js';
+import type { StreamTransportOptions, StreamSentMessageInfo } from './stream-transport/index.js';
+import JSONTransport from './json-transport/index.js';
+import type { JSONTransportOptions, JSONSentMessageInfo, JSONSentMessageObjectInfo } from './json-transport/index.js';
+import SESTransport from './ses-transport/index.js';
+import type { SESTransportOptions, SESSentMessageInfo } from './ses-transport/index.js';
+/**
+ * Connection details of a service endpoint of an Ethereal test account
+ */
+export interface TestAccountService {
+    host: string;
+    port: number;
+    secure: boolean;
+}
+/**
+ * Ethereal test account returned by createTestAccount()
+ */
+export interface TestAccount {
+    user: string;
+    pass: string;
+    smtp: TestAccountService;
+    imap: TestAccountService;
+    pop3: TestAccountService;
+    web: string;
+    /** true if the account can also receive external mail */
+    mxEnabled?: boolean | undefined;
+    [key: string]: unknown;
+}
+/**
+ * Callback for createTestAccount()
+ */
+export type TestAccountCallback = (err: Error | null, account: TestAccount) => void;
+/**
+ * Configuration object of any of the bundled transports
+ */
+export type TransportConfig = SMTPTransportOptions | SMTPPoolOptions | SendmailTransportOptions | StreamTransportOptions | JSONTransportOptions | SESTransportOptions;
+/**
+ * Creates a transporter object for sending e-mails
+ *
+ * @param transporter Transport configuration object, a connection URL or a transport plugin instance
+ * @param defaults Default message fields that are merged into every message
+ * @returns Mail instance wrapping the transport
+ */
+export declare function createTransport(transporter: SMTPPool | (SMTPPoolOptions & {
+    pool: true;
+}), defaults?: MailDefaults): Mail<SMTPPoolSentMessageInfo, SMTPPoolOptions>;
+export declare function createTransport(transporter: SendmailTransport | (SendmailTransportOptions & {
+    sendmail: true | string;
+}), defaults?: MailDefaults): Mail<SendmailSentMessageInfo, SendmailTransportOptions>;
+export declare function createTransport(transporter: StreamTransport | (StreamTransportOptions & {
+    streamTransport: true;
+}), defaults?: MailDefaults): Mail<StreamSentMessageInfo, StreamTransportOptions>;
+export declare function createTransport(transporter: JSONTransportOptions & {
+    jsonTransport: true;
+    skipEncoding: true;
+}, defaults?: MailDefaults): Mail<JSONSentMessageObjectInfo, JSONTransportOptions>;
+export declare function createTransport(transporter: JSONTransport | (JSONTransportOptions & {
+    jsonTransport: true;
+}), defaults?: MailDefaults): Mail<JSONSentMessageInfo, JSONTransportOptions>;
+export declare function createTransport(transporter: SESTransport | (SESTransportOptions & {
+    SES: object;
+}), defaults?: MailDefaults): Mail<SESSentMessageInfo, SESTransportOptions>;
+export declare function createTransport(transporter: SMTPTransport, defaults?: MailDefaults): Mail<SMTPSentMessageInfo, SMTPTransportOptions>;
+export declare function createTransport<T = SentMessageInfo, D extends TransportOptions = TransportOptions>(transporter: Transport<T, D>, defaults?: MailDefaults): Mail<T, D>;
+export declare function createTransport(transporter?: SMTPTransportOptions | string, defaults?: MailDefaults): Mail<SMTPSentMessageInfo, SMTPTransportOptions>;
+export declare function createTransport(transporter?: TransportConfig | Transport<any, any> | string, defaults?: MailDefaults): Mail<any, any>;
+/**
+ * Creates a test account from the Ethereal service (https://ethereal.email)
+ *
+ * @param callback Callback function to run with the account object
+ */
+export declare function createTestAccount(callback: TestAccountCallback): void;
+/**
+ * Creates a test account from the Ethereal service (https://ethereal.email)
+ *
+ * @param apiUrl API endpoint, defaults to https://api.nodemailer.com
+ * @param callback Callback function to run with the account object
+ */
+export declare function createTestAccount(apiUrl: string | false | null | undefined, callback: TestAccountCallback): void;
+/**
+ * Creates a test account from the Ethereal service (https://ethereal.email)
+ *
+ * @param [apiUrl] API endpoint, defaults to https://api.nodemailer.com
+ * @returns Promise that resolves with the account object
+ */
+export declare function createTestAccount(apiUrl?: string | false | null): Promise<TestAccount>;
+/**
+ * Resolves the Ethereal web URL for a message sent through an Ethereal test account
+ *
+ * @param info Result object of sendMail()
+ * @returns URL of the message in the Ethereal web interface, or false if the response does not carry one
+ */
+export declare function getTestMessageUrl(info?: {
+    response?: string | Buffer | null | undefined;
+} | false | null): string | false;
+declare const nodemailer: {
+    createTransport: typeof createTransport;
+    createTestAccount: typeof createTestAccount;
+    getTestMessageUrl: typeof getTestMessageUrl;
+};
+export default nodemailer;
+export type { Mail, MailDefaults, SentMessageInfo, Transport, TransportOptions };
+export type { SendMailOptions, Transporter } from './mailer/index.js';
+export type { NodemailerError, ErrorCode } from './errors.js';
+export type { MailMessage, MailMessageData, PluginFunction, VerifyCallback } from './mailer/index.js';
+export type { MailComposerOptions, MailComposerAttachment as Attachment, MailComposerAlternative as AttachmentLike, MailComposerIcalEvent as IcalAttachment, MailComposerListHeaders as ListHeaders } from './mail-composer/index.js';
+export type { MimeNodeAddress as Address, MimeNodeHeaders as Headers } from './mime-node/index.js';
+export type { SMTPConnectionOptions, SMTPConnectionAuth, SMTPEnvelope, SMTPEnvelopeDsn } from './smtp-connection/index.js';
+export type { DKIMOptions } from './dkim/index.js';
+export type { XOAuth2Options, XOAuth2Token } from './xoauth2/index.js';
+export type { SMTPTransportOptions, SMTPSentMessageInfo };
+export type { SMTPPoolOptions, SMTPPoolSentMessageInfo };
+export type { SendmailTransportOptions, SendmailSentMessageInfo };
+export type { StreamTransportOptions, StreamSentMessageInfo };
+export type { JSONTransportOptions, JSONSentMessageInfo, JSONSentMessageObjectInfo };
+export type { SESTransportOptions, SESSentMessageInfo };

package/dist/node_modules/nodemailer/dist/esm/nodemailer.js

@@ -0,0 +1,166 @@
+import Mail from './mailer/index.js';
+import * as shared from './shared/index.js';
+import SMTPPool from './smtp-pool/index.js';
+import SMTPTransport from './smtp-transport/index.js';
+import SendmailTransport from './sendmail-transport/index.js';
+import StreamTransport from './stream-transport/index.js';
+import JSONTransport from './json-transport/index.js';
+import SESTransport from './ses-transport/index.js';
+import * as errors from './errors.js';
+import nmfetch from './fetch/index.js';
+import * as packageData from './package-info.js';
+const ETHEREAL_API = (process.env.ETHEREAL_API || 'https://api.nodemailer.com').replace(/\/+$/, '');
+const ETHEREAL_WEB = (process.env.ETHEREAL_WEB || 'https://ethereal.email').replace(/\/+$/, '');
+const ETHEREAL_API_KEY = (process.env.ETHEREAL_API_KEY || '').replace(/\s*/g, '') || null;
+const ETHEREAL_CACHE = ['true', 'yes', 'y', '1'].includes((process.env.ETHEREAL_CACHE || 'yes').toString().trim().toLowerCase());
+let testAccount = false;
+export function createTransport(transporter, defaults) {
+    let options;
+    if (
+    // provided transporter is a configuration object, not transporter plugin
+    (typeof transporter === 'object' && typeof transporter.send !== 'function') ||
+        // provided transporter looks like a connection url
+        (typeof transporter === 'string' && /^(smtps?|direct):/i.test(transporter))) {
+        const urlConfig = typeof transporter === 'string' ? transporter : transporter.url;
+        if (urlConfig) {
+            // parse a configuration URL into configuration options. The other keys of a
+            // configuration object apply where the url does not set them, merged the same
+            // way the SMTP transports merge their own url option
+            const parsed = shared.parseConnectionUrl(urlConfig);
+            options = (typeof transporter === 'object'
+                ? shared.assign(false, shared.copyOwnKeys({}, transporter, key => key === 'url'), parsed)
+                : parsed);
+        }
+        else {
+            options = transporter;
+        }
+        if (options.pool) {
+            transporter = new SMTPPool(options);
+        }
+        else if (options.sendmail) {
+            transporter = new SendmailTransport(options);
+        }
+        else if (options.streamTransport) {
+            transporter = new StreamTransport(options);
+        }
+        else if (options.jsonTransport) {
+            transporter = new JSONTransport(options);
+        }
+        else if (options.SES) {
+            const ses = options.SES;
+            if (ses.ses && ses.aws) {
+                const error = new Error('Using legacy SES configuration, expecting @aws-sdk/client-sesv2, see https://nodemailer.com/transports/ses/');
+                error.code = errors.ECONFIG;
+                throw error;
+            }
+            transporter = new SESTransport(options);
+        }
+        else {
+            transporter = new SMTPTransport(options);
+        }
+    }
+    return new Mail(transporter, options, defaults);
+}
+export function createTestAccount(apiUrl, callback) {
+    let promise;
+    if (!callback && typeof apiUrl === 'function') {
+        callback = apiUrl;
+        apiUrl = false;
+    }
+    if (!callback) {
+        promise = new Promise((resolve, reject) => {
+            callback = shared.callbackPromise(resolve, reject);
+        });
+    }
+    const done = callback;
+    if (ETHEREAL_CACHE && testAccount) {
+        setImmediate(() => done(null, testAccount));
+        return promise;
+    }
+    apiUrl = apiUrl || ETHEREAL_API;
+    const chunks = [];
+    let chunklen = 0;
+    const requestHeaders = {};
+    const requestBody = {
+        requestor: packageData.name,
+        version: packageData.version
+    };
+    if (ETHEREAL_API_KEY) {
+        requestHeaders.Authorization = 'Bearer ' + ETHEREAL_API_KEY;
+    }
+    const fetchOptions = {
+        contentType: 'application/json',
+        method: 'POST',
+        headers: requestHeaders,
+        body: Buffer.from(JSON.stringify(requestBody))
+    };
+    // Credential-bearing request to the Ethereal API. src/fetch already
+    // validates certs by default; pin rejectUnauthorized:true here so this
+    // call stays strict regardless of any future default change and is never
+    // relaxed for a real-cert endpoint.
+    if (/^https:/i.test(apiUrl)) {
+        fetchOptions.tls = { rejectUnauthorized: true };
+    }
+    const req = nmfetch(apiUrl + '/user', fetchOptions);
+    req.on('readable', () => {
+        let chunk;
+        while ((chunk = req.read()) !== null) {
+            chunks.push(chunk);
+            chunklen += chunk.length;
+        }
+    });
+    req.once('error', err => done(err));
+    req.once('end', () => {
+        const res = Buffer.concat(chunks, chunklen);
+        let data;
+        try {
+            data = JSON.parse(res.toString());
+        }
+        catch (E) {
+            return done(E);
+        }
+        if (data.status !== 'success' || data.error) {
+            return done(new Error(data.error || 'Request failed'));
+        }
+        delete data.status;
+        testAccount = data;
+        done(null, testAccount);
+    });
+    return promise;
+}
+/**
+ * Resolves the Ethereal web URL for a message sent through an Ethereal test account
+ *
+ * @param info Result object of sendMail()
+ * @returns URL of the message in the Ethereal web interface, or false if the response does not carry one
+ */
+export function getTestMessageUrl(info) {
+    if (!info || !info.response) {
+        return false;
+    }
+    const infoProps = new Map();
+    // Extract the trailing "[...]" part of the response (no "]" allowed inside)
+    // with linear string scanning; the equivalent regex /\[([^\]]+)\]$/ was
+    // flagged for polynomial backtracking on adversarial server responses
+    const response = info.response.toString();
+    if (response.length > 2 && response.charAt(response.length - 1) === ']') {
+        const open = response.indexOf('[', response.lastIndexOf(']', response.length - 2) + 1);
+        if (open >= 0 && open < response.length - 2) {
+            const props = response.substring(open + 1, response.length - 1);
+            props.replace(/\b([A-Z0-9]+)=([^\s]+)/g, (m, key, value) => {
+                infoProps.set(key, value);
+                return m;
+            });
+        }
+    }
+    if (infoProps.has('STATUS') && infoProps.has('MSGID')) {
+        return ((testAccount && testAccount.web) || ETHEREAL_WEB) + '/message/' + infoProps.get('MSGID');
+    }
+    return false;
+}
+const nodemailer = {
+    createTransport,
+    createTestAccount,
+    getTestMessageUrl
+};
+export default nodemailer;

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

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

package/dist/node_modules/nodemailer/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 = 'nodemailer';
+export const version = '10.0.14';
+export const homepage = 'https://nodemailer.com/';

package/dist/node_modules/nodemailer/dist/esm/package.json

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

package/dist/node_modules/nodemailer/dist/esm/punycode/index.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Creates an array containing the numeric code points of each Unicode
+ * character in the string. While JavaScript uses UCS-2 internally,
+ * this function will convert a pair of surrogate halves (each of which
+ * UCS-2 exposes as separate characters) into a single code point,
+ * matching UTF-16.
+ * @see `punycode.ucs2.encode`
+ * @see <https://mathiasbynens.be/notes/javascript-encoding>
+ * @memberOf punycode.ucs2
+ * @name decode
+ * @param string The Unicode input string (UCS-2).
+ * @returns The new array of code points.
+ */
+declare function ucs2decode(string: string): number[];
+/**
+ * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+ * symbols.
+ * @memberOf punycode
+ * @param input The Punycode string of ASCII-only symbols.
+ * @returns The resulting string of Unicode symbols.
+ */
+declare const decode: (input: string) => string;
+/**
+ * Converts a string of Unicode symbols (e.g. a domain name label) to a
+ * Punycode string of ASCII-only symbols.
+ * @memberOf punycode
+ * @param input The string of Unicode symbols.
+ * @returns The resulting Punycode string of ASCII-only symbols.
+ */
+declare const encode: (input: string) => string;
+/**
+ * Converts a Punycode string representing a domain name or an email address
+ * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+ * it doesn't matter if you call it on a string that has already been
+ * converted to Unicode.
+ * @memberOf punycode
+ * @param input The Punycoded domain name or email address to
+ * convert to Unicode.
+ * @returns The Unicode representation of the given Punycode
+ * string.
+ */
+declare const toUnicode: (input: string) => string;
+/**
+ * Converts a Unicode string representing a domain name or an email address to
+ * Punycode. Only the non-ASCII parts of the domain name will be converted,
+ * i.e. it doesn't matter if you call it with a domain that's already in
+ * ASCII.
+ * @memberOf punycode
+ * @param input The domain name or email address to convert, as a
+ * Unicode string.
+ * @returns The Punycode representation of the given domain name or
+ * email address.
+ */
+declare const toASCII: (input: string) => string;
+/** Define the public API */
+/**
+ * A string representing the current Punycode.js version number.
+ * @memberOf punycode
+ * @type String
+ */
+export declare const version = "2.3.1";
+/**
+ * An object of methods to convert from JavaScript's internal character
+ * representation (UCS-2) to Unicode code points, and back.
+ * @see <https://mathiasbynens.be/notes/javascript-encoding>
+ * @memberOf punycode
+ * @type Object
+ */
+export declare const ucs2: {
+    decode: typeof ucs2decode;
+    encode: (codePoints: number[]) => string;
+};
+export { decode, encode, toASCII, toUnicode };