@nocobase/plugin-workflow-mailer 2.2.20 → 2.2.21

package/dist/node_modules/nodemailer/.prettierrc

@@ -1,12 +0,0 @@
-{
-    "printWidth": 140,
-    "tabWidth": 4,
-    "useTabs": false,
-    "semi": true,
-    "singleQuote": true,
-    "quoteProps": "as-needed",
-    "trailingComma": "none",
-    "bracketSpacing": true,
-    "arrowParens": "avoid",
-    "endOfLine": "lf"
-}

package/dist/node_modules/nodemailer/.prettierrc.js

@@ -1,10 +0,0 @@
-'use strict';
-
-module.exports = {
-    printWidth: 160,
-    tabWidth: 4,
-    singleQuote: true,
-    endOfLine: 'lf',
-    trailingComma: 'none',
-    arrowParens: 'avoid'
-};

package/dist/node_modules/nodemailer/.release-please-config.json

@@ -1,9 +0,0 @@
-{
-    "packages": {
-        ".": {
-            "release-type": "node",
-            "package-name": "nodemailer",
-            "pull-request-title-pattern": "chore${scope}: release ${version} [skip-ci]"
-        }
-    }
-}

package/dist/node_modules/nodemailer/eslint.config.js

@@ -1,88 +0,0 @@
-'use strict';
-
-const globals = require('globals');
-
-module.exports = [
-    {
-        ignores: ['node_modules/**', 'coverage/**', 'dist/**', 'build/**', '.nyc_output/**']
-    },
-    {
-        files: ['**/*.js'],
-        languageOptions: {
-            ecmaVersion: 2017,
-            sourceType: 'script',
-            globals: Object.assign({}, globals.node, globals.es2017, {
-                it: true,
-                describe: true,
-                beforeEach: true,
-                afterEach: true
-            })
-        },
-        rules: {
-            // Error detection
-            'for-direction': 'error',
-            'no-await-in-loop': 'error',
-            'no-div-regex': 'error',
-            eqeqeq: 'error',
-            'dot-notation': 'error',
-            curly: 'error',
-            'no-fallthrough': 'error',
-            'no-unused-expressions': [
-                'error',
-                {
-                    allowShortCircuit: true
-                }
-            ],
-            'no-unused-vars': [
-                'error',
-                {
-                    varsIgnorePattern: '^_',
-                    argsIgnorePattern: '^_',
-                    caughtErrorsIgnorePattern: '^_'
-                }
-            ],
-            'handle-callback-err': 'error',
-            'no-new': 'error',
-            'new-cap': 'error',
-            'no-eval': 'error',
-            'no-invalid-this': 'error',
-            radix: ['error', 'always'],
-            'no-use-before-define': ['error', 'nofunc'],
-            'callback-return': ['error', ['callback', 'cb', 'done']],
-            'no-regex-spaces': 'error',
-            'no-empty': 'error',
-            'no-duplicate-case': 'error',
-            'no-empty-character-class': 'error',
-            'no-redeclare': 'off', // Disabled per project preference
-            'block-scoped-var': 'error',
-            'no-sequences': 'error',
-            'no-throw-literal': 'error',
-            'no-useless-call': 'error',
-            'no-useless-concat': 'error',
-            'no-void': 'error',
-            yoda: 'error',
-            'no-undef': 'error',
-            'global-require': 'error',
-            'no-var': 'error',
-            'no-bitwise': 'error',
-            'no-lonely-if': 'error',
-            'no-mixed-spaces-and-tabs': 'error',
-            'arrow-body-style': ['error', 'as-needed'],
-            'arrow-parens': ['error', 'as-needed'],
-            'prefer-arrow-callback': 'error',
-            'object-shorthand': 'error',
-            'prefer-spread': 'error',
-            'no-prototype-builtins': 'off', // Disabled per project preference
-            strict: ['error', 'global'],
-
-            // Disable all formatting rules (handled by Prettier)
-            indent: 'off',
-            quotes: 'off',
-            'linebreak-style': 'off',
-            semi: 'off',
-            'quote-props': 'off',
-            'comma-dangle': 'off',
-            'comma-style': 'off'
-        }
-    }
-];

package/dist/node_modules/nodemailer/lib/dkim/relaxed-body.js

@@ -1,154 +0,0 @@
-'use strict';
-
-// streams through a message body and calculates relaxed body hash
-
-const { Transform } = require('stream');
-const crypto = require('crypto');
-
-class RelaxedBody extends Transform {
-    constructor(options) {
-        super();
-        options = options || {};
-        this.chunkBuffer = [];
-        this.chunkBufferLen = 0;
-        this.bodyHash = crypto.createHash(options.hashAlgo || 'sha256');
-        this.remainder = '';
-        this.byteLength = 0;
-
-        this.debug = options.debug;
-        this._debugBody = options.debug ? [] : false;
-    }
-
-    updateHash(chunk) {
-        let bodyStr;
-
-        // find next remainder
-        let nextRemainder = '';
-
-        // This crux finds and removes the spaces from the last line and the newline characters after the last non-empty line
-        // If we get another chunk that does not match this description then we can restore the previously processed data
-        let state = 'file';
-        for (let i = chunk.length - 1; i >= 0; i--) {
-            const c = chunk[i];
-
-            if (state === 'file' && (c === 0x0a || c === 0x0d)) {
-                // do nothing, found \n or \r at the end of chunk, stil end of file
-            } else if (state === 'file' && (c === 0x09 || c === 0x20)) {
-                // switch to line ending mode, this is the last non-empty line
-                state = 'line';
-            } else if (state === 'line' && (c === 0x09 || c === 0x20)) {
-                // do nothing, found ' ' or \t at the end of line, keep processing the last non-empty line
-            } else if (state === 'file' || state === 'line') {
-                // non line/file ending character found, switch to body mode
-                state = 'body';
-                if (i === chunk.length - 1) {
-                    // final char is not part of line end or file end, so do nothing
-                    break;
-                }
-            }
-
-            if (i === 0) {
-                // reached to the beginning of the chunk, check if it is still about the ending
-                // and if the remainder also matches
-                if (
-                    (state === 'file' && (!this.remainder || /[\r\n]$/.test(this.remainder))) ||
-                    (state === 'line' && (!this.remainder || /[ \t]$/.test(this.remainder)))
-                ) {
-                    // keep everything
-                    this.remainder += chunk.toString('binary');
-                    return;
-                } else if (state === 'line' || state === 'file') {
-                    // process existing remainder as normal line but store the current chunk
-                    nextRemainder = chunk.toString('binary');
-                    chunk = false;
-                    break;
-                }
-            }
-
-            if (state !== 'body') {
-                continue;
-            }
-
-            // reached first non ending byte
-            nextRemainder = chunk.slice(i + 1).toString('binary');
-            chunk = chunk.slice(0, i + 1);
-            break;
-        }
-
-        let needsFixing = !!this.remainder;
-        if (chunk && !needsFixing) {
-            // check if we even need to change anything
-            for (let i = 0, len = chunk.length; i < len; i++) {
-                if (i && chunk[i] === 0x0a && chunk[i - 1] !== 0x0d) {
-                    // missing \r before \n
-                    needsFixing = true;
-                    break;
-                } else if (i && chunk[i] === 0x0d && chunk[i - 1] === 0x20) {
-                    // trailing WSP found
-                    needsFixing = true;
-                    break;
-                } else if (i && chunk[i] === 0x20 && chunk[i - 1] === 0x20) {
-                    // multiple spaces found, needs to be replaced with just one
-                    needsFixing = true;
-                    break;
-                } else if (chunk[i] === 0x09) {
-                    // TAB found, needs to be replaced with a space
-                    needsFixing = true;
-                    break;
-                }
-            }
-        }
-
-        if (needsFixing) {
-            bodyStr = this.remainder + (chunk ? chunk.toString('binary') : '');
-            this.remainder = nextRemainder;
-            bodyStr = bodyStr
-                .replace(/\r?\n/g, '\n') // use js line endings
-                .replace(/[ \t]*$/gm, '') // remove line endings, rtrim
-                .replace(/[ \t]+/gm, ' ') // single spaces
-                .replace(/\n/g, '\r\n'); // restore rfc822 line endings
-            chunk = Buffer.from(bodyStr, 'binary');
-        } else if (nextRemainder) {
-            this.remainder = nextRemainder;
-        }
-
-        if (this.debug) {
-            this._debugBody.push(chunk);
-        }
-        this.bodyHash.update(chunk);
-    }
-
-    _transform(chunk, encoding, callback) {
-        if (!chunk || !chunk.length) {
-            return callback();
-        }
-
-        if (typeof chunk === 'string') {
-            chunk = Buffer.from(chunk, encoding);
-        }
-
-        this.updateHash(chunk);
-
-        this.byteLength += chunk.length;
-        this.push(chunk);
-        callback();
-    }
-
-    _flush(callback) {
-        // generate final hash and emit it
-        if (/[\r\n]$/.test(this.remainder) && this.byteLength > 2) {
-            // add terminating line end
-            this.bodyHash.update(Buffer.from('\r\n'));
-        }
-        if (!this.byteLength) {
-            // emit empty line buffer to keep the stream flowing
-            this.push(Buffer.from('\r\n'));
-            // this.bodyHash.update(Buffer.from('\r\n'));
-        }
-
-        this.emit('hash', this.bodyHash.digest('base64'), this.debug ? Buffer.concat(this._debugBody) : false);
-        callback();
-    }
-}
-
-module.exports = RelaxedBody;

package/dist/node_modules/nodemailer/lib/fetch/cookies.js

@@ -1,276 +0,0 @@
-'use strict';
-
-// module to handle cookies
-
-const urllib = require('../shared/url');
-
-const SESSION_TIMEOUT = 1800; // 30 min
-
-/**
- * Creates a biskviit cookie jar for managing cookie values in memory
- *
- * @constructor
- * @param {Object} [options] Optional options object
- */
-class Cookies {
-    constructor(options) {
-        this.options = options || {};
-        this.cookies = [];
-    }
-
-    /**
-     * Stores a cookie string to the cookie storage
-     *
-     * @param {String} cookieStr Value from the 'Set-Cookie:' header
-     * @param {String} url Current URL
-     */
-    set(cookieStr, url) {
-        const urlparts = urllib.parse(url || '');
-        const cookie = this.parse(cookieStr);
-        let domain;
-
-        if (cookie.domain) {
-            domain = cookie.domain.replace(/^\./, '');
-
-            // do not allow cross origin cookies
-            if (
-                // can't be valid if the requested domain is shorter than current hostname
-                urlparts.hostname.length < domain.length ||
-                // prefix domains with dot to be sure that partial matches are not used
-                ('.' + urlparts.hostname).substr(-domain.length + 1) !== '.' + domain
-            ) {
-                cookie.domain = urlparts.hostname;
-            }
-        } else {
-            cookie.domain = urlparts.hostname;
-        }
-
-        if (!cookie.path) {
-            cookie.path = this.getPath(urlparts.pathname);
-        }
-
-        // if no expire date, then use sessionTimeout value
-        if (!cookie.expires) {
-            cookie.expires = new Date(Date.now() + (Number(this.options.sessionTimeout || SESSION_TIMEOUT) || SESSION_TIMEOUT) * 1000);
-        }
-
-        return this.add(cookie);
-    }
-
-    /**
-     * Returns cookie string for the 'Cookie:' header.
-     *
-     * @param {String} url URL to check for
-     * @returns {String} Cookie header or empty string if no matches were found
-     */
-    get(url) {
-        return this.list(url)
-            .map(cookie => cookie.name + '=' + cookie.value)
-            .join('; ');
-    }
-
-    /**
-     * Lists all valied cookie objects for the specified URL
-     *
-     * @param {String} url URL to check for
-     * @returns {Array} An array of cookie objects
-     */
-    list(url) {
-        const result = [];
-
-        for (let i = this.cookies.length - 1; i >= 0; i--) {
-            const cookie = this.cookies[i];
-
-            if (this.isExpired(cookie)) {
-                this.cookies.splice(i, 1);
-                continue;
-            }
-
-            if (this.match(cookie, url)) {
-                result.unshift(cookie);
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Parses cookie string from the 'Set-Cookie:' header
-     *
-     * @param {String} cookieStr String from the 'Set-Cookie:' header
-     * @returns {Object} Cookie object
-     */
-    parse(cookieStr) {
-        const cookie = {};
-
-        (cookieStr || '')
-            .toString()
-            .split(';')
-            .forEach(cookiePart => {
-                const valueParts = cookiePart.split('=');
-                const key = valueParts.shift().trim().toLowerCase();
-                let value = valueParts.join('=').trim();
-                let domain;
-
-                if (!key) {
-                    // skip empty parts
-                    return;
-                }
-
-                switch (key) {
-                    case 'expires':
-                        value = new Date(value);
-                        // ignore date if can not parse it
-                        if (value.toString() !== 'Invalid Date') {
-                            cookie.expires = value;
-                        }
-                        break;
-
-                    case 'path':
-                        cookie.path = value;
-                        break;
-
-                    case 'domain':
-                        domain = value.toLowerCase();
-                        if (domain.length && domain.charAt(0) !== '.') {
-                            domain = '.' + domain; // ensure preceeding dot for user set domains
-                        }
-                        cookie.domain = domain;
-                        break;
-
-                    case 'max-age':
-                        cookie.expires = new Date(Date.now() + (Number(value) || 0) * 1000);
-                        break;
-
-                    case 'secure':
-                        cookie.secure = true;
-                        break;
-
-                    case 'httponly':
-                        cookie.httponly = true;
-                        break;
-
-                    default:
-                        if (!cookie.name) {
-                            cookie.name = key;
-                            cookie.value = value;
-                        }
-                }
-            });
-
-        return cookie;
-    }
-
-    /**
-     * Checks if a cookie object is valid for a specified URL
-     *
-     * @param {Object} cookie Cookie object
-     * @param {String} url URL to check for
-     * @returns {Boolean} true if cookie is valid for specifiec URL
-     */
-    match(cookie, url) {
-        const urlparts = urllib.parse(url || '');
-
-        // check if hostname matches
-        // .foo.com also matches subdomains, foo.com does not
-        if (
-            urlparts.hostname !== cookie.domain &&
-            (cookie.domain.charAt(0) !== '.' || ('.' + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)
-        ) {
-            return false;
-        }
-
-        // check if path matches
-        const path = this.getPath(urlparts.pathname);
-        if (path.substr(0, cookie.path.length) !== cookie.path) {
-            return false;
-        }
-
-        // check secure argument
-        if (cookie.secure && urlparts.protocol !== 'https:') {
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * Adds (or updates/removes if needed) a cookie object to the cookie storage
-     *
-     * @param {Object} cookie Cookie value to be stored
-     */
-    add(cookie) {
-        // nothing to do here
-        if (!cookie || !cookie.name) {
-            return false;
-        }
-
-        // overwrite if has same params
-        for (let i = 0, len = this.cookies.length; i < len; i++) {
-            if (this.compare(this.cookies[i], cookie)) {
-                // check if the cookie needs to be removed instead
-                if (this.isExpired(cookie)) {
-                    this.cookies.splice(i, 1); // remove expired/unset cookie
-                    return false;
-                }
-
-                this.cookies[i] = cookie;
-                return true;
-            }
-        }
-
-        // add as new if not already expired
-        if (!this.isExpired(cookie)) {
-            this.cookies.push(cookie);
-        }
-
-        return true;
-    }
-
-    /**
-     * Checks if two cookie objects are the same
-     *
-     * @param {Object} a Cookie to check against
-     * @param {Object} b Cookie to check against
-     * @returns {Boolean} True, if the cookies are the same
-     */
-    compare(a, b) {
-        return a.name === b.name && a.path === b.path && a.domain === b.domain && a.secure === b.secure && a.httponly === b.httponly;
-    }
-
-    /**
-     * Checks if a cookie is expired
-     *
-     * @param {Object} cookie Cookie object to check against
-     * @returns {Boolean} True, if the cookie is expired
-     */
-    isExpired(cookie) {
-        return (cookie.expires && cookie.expires < new Date()) || !cookie.value;
-    }
-
-    /**
-     * Returns normalized cookie path for an URL path argument
-     *
-     * @param {String} pathname
-     * @returns {String} Normalized path
-     */
-    getPath(pathname) {
-        let path = (pathname || '/').split('/');
-        path.pop(); // remove filename part
-        path = path.join('/').trim();
-
-        // ensure path prefix /
-        if (path.charAt(0) !== '/') {
-            path = '/' + path;
-        }
-
-        // ensure path suffix /
-        if (path.substr(-1) !== '/') {
-            path += '/';
-        }
-
-        return path;
-    }
-}
-
-module.exports = Cookies;