%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /home/opti/workflow/node_modules/email-templates/lib/
Upload File :
Create Path :
Current File : /home/opti/workflow/node_modules/email-templates/lib/index.js

"use strict";

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

const fs = require('fs');

const path = require('path');

const juice = require('juice');

const debug = require('debug')('email-templates');

const htmlToText = require('html-to-text');

const I18N = require('@ladjs/i18n');

const autoBind = require('auto-bind');

const nodemailer = require('nodemailer');

const consolidate = require('consolidate');

const previewEmail = require('preview-email');

const _ = require('lodash');

const _Promise = require('bluebird');

const s = require('underscore.string');

const getPaths = require('get-paths'); // promise version of `juice.juiceResources`


const juiceResources = (html, options) => {
  return new _Promise((resolve, reject) => {
    juice.juiceResources(html, options, (err, html) => {
      if (err) return reject(err);
      resolve(html);
    });
  });
};

const env = (process.env.NODE_ENV || 'development').toLowerCase();

const stat = _Promise.promisify(fs.stat);

const readFile = _Promise.promisify(fs.readFile);

class Email {
  constructor(config = {}) {
    debug('config passed %O', config); // 2.x backwards compatible support

    if (config.juiceOptions) {
      config.juiceResources = config.juiceOptions;
      delete config.juiceOptions;
    }

    if (config.disableJuice) {
      config.juice = false;
      delete config.disableJuice;
    }

    if (config.render) {
      config.customRender = true;
    }

    this.config = _.merge({
      views: {
        // directory where email templates reside
        root: path.resolve('emails'),
        options: {
          // default file extension for template
          extension: 'pug',
          map: {
            hbs: 'handlebars',
            njk: 'nunjucks'
          },
          engineSource: consolidate
        },
        // locals to pass to templates for rendering
        locals: {
          // turn on caching for non-development environments
          cache: !['development', 'test'].includes(env),
          // pretty is automatically set to `false` for subject/text
          pretty: true
        }
      },
      // <https://nodemailer.com/message/>
      message: {},
      send: !['development', 'test'].includes(env),
      preview: env === 'development',
      // <https://github.com/ladjs/i18n>
      // set to an object to configure and enable it
      i18n: false,
      // pass a custom render function if necessary
      render: this.render.bind(this),
      customRender: false,
      // force text-only rendering of template (disregards template folder)
      textOnly: false,
      // <https://github.com/werk85/node-html-to-text>
      htmlToText: {
        ignoreImage: true
      },
      subjectPrefix: false,
      // <https://github.com/Automattic/juice>
      juice: true,
      juiceResources: {
        preserveImportant: true,
        webResources: {
          relativeTo: path.resolve('build'),
          images: false
        }
      },
      // pass a transport configuration object or a transport instance
      // (e.g. an instance is created via `nodemailer.createTransport`)
      // <https://nodemailer.com/transports/>
      transport: {}
    }, config); // override existing method

    this.render = this.config.render;
    if (!_.isFunction(this.config.transport.sendMail)) this.config.transport = nodemailer.createTransport(this.config.transport);
    debug('transformed config %O', this.config);
    autoBind(this);
  } // shorthand use of `juiceResources` with the config
  // (mainly for custom renders like from a database)


  juiceResources(html) {
    return juiceResources(html, this.config.juiceResources);
  } // a simple helper function that gets the actual file path for the template


  getTemplatePath(template) {
    var _this = this;

    return _asyncToGenerator(function* () {
      const _ref = path.isAbsolute(template) ? [path.dirname(template), path.basename(template)] : [_this.config.views.root, template],
            _ref2 = _slicedToArray(_ref, 2),
            root = _ref2[0],
            view = _ref2[1];

      const paths = yield getPaths(root, view, _this.config.views.options.extension);
      const filePath = path.resolve(root, paths.rel);
      return {
        filePath,
        paths
      };
    })();
  } // returns true or false if a template exists
  // (uses same look-up approach as `render` function)


  templateExists(view) {
    var _this2 = this;

    return _asyncToGenerator(function* () {
      try {
        const _ref3 = yield _this2.getTemplatePath(view),
              filePath = _ref3.filePath;

        const stats = yield stat(filePath);
        if (!stats.isFile()) throw new Error(`${filePath} was not a file`);
        return true;
      } catch (err) {
        debug('templateExists', err);
        return false;
      }
    })();
  } // promise version of consolidate's render
  // inspired by koa-views and re-uses the same config
  // <https://github.com/queckezz/koa-views>


  render(view, locals = {}) {
    var _this3 = this;

    return _asyncToGenerator(function* () {
      const _this3$config$views$o = _this3.config.views.options,
            map = _this3$config$views$o.map,
            engineSource = _this3$config$views$o.engineSource;

      const _ref4 = yield _this3.getTemplatePath(view),
            filePath = _ref4.filePath,
            paths = _ref4.paths;

      if (paths.ext === 'html' && !map) {
        const res = yield readFile(filePath, 'utf8');
        return res;
      }

      const engineName = map && map[paths.ext] ? map[paths.ext] : paths.ext;
      const renderFn = engineSource[engineName];
      if (!engineName || !renderFn) throw new Error(`Engine not found for the ".${paths.ext}" file extension`);

      if (_.isObject(_this3.config.i18n)) {
        const i18n = new I18N(Object.assign({}, _this3.config.i18n, {
          register: locals
        })); // support `locals.user.last_locale`
        // (e.g. for <https://lad.js.org>)

        if (_.isObject(locals.user) && _.isString(locals.user.last_locale)) locals.locale = locals.user.last_locale;
        if (_.isString(locals.locale)) i18n.setLocale(locals.locale);
      }

      const res = yield _Promise.promisify(renderFn)(filePath, locals); // transform the html with juice using remote paths
      // google now supports media queries
      // https://developers.google.com/gmail/design/reference/supported_css

      if (!_this3.config.juice) return res;
      const html = yield _this3.juiceResources(res);
      return html;
    })();
  } // TODO: this needs refactored
  // so that we render templates asynchronously


  renderAll(template, locals = {}, message = {}) {
    var _this4 = this;

    return _asyncToGenerator(function* () {
      let subjectTemplateExists = _this4.config.customRender;
      let htmlTemplateExists = _this4.config.customRender;
      let textTemplateExists = _this4.config.customRender;

      if (template && !_this4.config.customRender) {
        var _ref5 = yield _Promise.all([_this4.templateExists(`${template}/subject`), _this4.templateExists(`${template}/html`), _this4.templateExists(`${template}/text`)]);

        var _ref6 = _slicedToArray(_ref5, 3);

        subjectTemplateExists = _ref6[0];
        htmlTemplateExists = _ref6[1];
        textTemplateExists = _ref6[2];
      }

      if (!message.subject && subjectTemplateExists) {
        message.subject = yield _this4.render(`${template}/subject`, Object.assign({}, locals, {
          pretty: false
        }));
        message.subject = message.subject.trim();
      }

      if (message.subject && _this4.config.subjectPrefix) message.subject = _this4.config.subjectPrefix + message.subject;
      if (!message.html && htmlTemplateExists) message.html = yield _this4.render(`${template}/html`, locals);
      if (!message.text && textTemplateExists) message.text = yield _this4.render(`${template}/text`, Object.assign({}, locals, {
        pretty: false
      }));
      if (_this4.config.htmlToText && message.html && !message.text) // we'd use nodemailer-html-to-text plugin
        // but we really don't need to support cid
        // <https://github.com/andris9/nodemailer-html-to-text>
        message.text = htmlToText.fromString(message.html, _this4.config.htmlToText); // if we only want a text-based version of the email

      if (_this4.config.textOnly) delete message.html; // if no subject, html, or text content exists then we should
      // throw an error that says at least one must be found
      // otherwise the email would be blank (defeats purpose of email-templates)

      if (s.isBlank(message.subject) && s.isBlank(message.text) && s.isBlank(message.html) && _.isArray(message.attachments) && _.isEmpty(message.attachments)) throw new Error(`No content was passed for subject, html, text, nor attachments message props. Check that the files for the template "${template}" exist.`);
      return message;
    })();
  }

  send(options = {}) {
    var _this5 = this;

    return _asyncToGenerator(function* () {
      options = Object.assign({
        template: '',
        message: {},
        locals: {}
      }, options);
      let _options = options,
          template = _options.template,
          message = _options.message,
          locals = _options.locals;
      const attachments = message.attachments || _this5.config.message.attachments || [];
      message = _.defaultsDeep({}, _.omit(message, 'attachments'), _.omit(_this5.config.message, 'attachments'));
      locals = _.defaultsDeep({}, _this5.config.views.locals, locals);
      if (attachments) message.attachments = attachments;
      debug('template %s', template);
      debug('message %O', message);
      debug('locals (keys only): %O', Object.keys(locals)); // get all available templates

      const obj = yield _this5.renderAll(template, locals, message); // assign the object variables over to the message

      Object.assign(message, obj);

      if (_this5.config.preview) {
        debug('using `preview-email` to preview email');
        if (_.isObject(_this5.config.preview)) yield previewEmail(message, null, true, _this5.config.preview);else yield previewEmail(message);
      }

      if (!_this5.config.send) {
        debug('send disabled so we are ensuring JSONTransport'); // <https://github.com/nodemailer/nodemailer/issues/798>
        // if (this.config.transport.name !== 'JSONTransport')

        _this5.config.transport = nodemailer.createTransport({
          jsonTransport: true
        });
      }

      const res = yield _this5.config.transport.sendMail(message);
      debug('message sent');
      res.originalMessage = message;
      return res;
    })();
  }

}

module.exports = Email;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/index.js"],"names":["fs","require","path","juice","debug","htmlToText","I18N","autoBind","nodemailer","consolidate","previewEmail","_","Promise","s","getPaths","juiceResources","html","options","resolve","reject","err","env","process","NODE_ENV","toLowerCase","stat","promisify","readFile","Email","constructor","config","juiceOptions","disableJuice","render","customRender","merge","views","root","extension","map","hbs","njk","engineSource","locals","cache","includes","pretty","message","send","preview","i18n","bind","textOnly","ignoreImage","subjectPrefix","preserveImportant","webResources","relativeTo","images","transport","isFunction","sendMail","createTransport","getTemplatePath","template","isAbsolute","dirname","basename","view","paths","filePath","rel","templateExists","stats","isFile","Error","ext","res","engineName","renderFn","isObject","Object","assign","register","user","isString","last_locale","locale","setLocale","renderAll","subjectTemplateExists","htmlTemplateExists","textTemplateExists","all","subject","trim","text","fromString","isBlank","isArray","attachments","isEmpty","defaultsDeep","omit","keys","obj","jsonTransport","originalMessage","module","exports"],"mappings":"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","sourcesContent":["const fs = require('fs');\nconst path = require('path');\nconst juice = require('juice');\nconst debug = require('debug')('email-templates');\nconst htmlToText = require('html-to-text');\nconst I18N = require('@ladjs/i18n');\nconst autoBind = require('auto-bind');\nconst nodemailer = require('nodemailer');\nconst consolidate = require('consolidate');\nconst previewEmail = require('preview-email');\nconst _ = require('lodash');\nconst Promise = require('bluebird');\nconst s = require('underscore.string');\n\nconst getPaths = require('get-paths');\n\n// promise version of `juice.juiceResources`\nconst juiceResources = (html, options) => {\n  return new Promise((resolve, reject) => {\n    juice.juiceResources(html, options, (err, html) => {\n      if (err) return reject(err);\n      resolve(html);\n    });\n  });\n};\n\nconst env = (process.env.NODE_ENV || 'development').toLowerCase();\nconst stat = Promise.promisify(fs.stat);\nconst readFile = Promise.promisify(fs.readFile);\n\nclass Email {\n  constructor(config = {}) {\n    debug('config passed %O', config);\n\n    // 2.x backwards compatible support\n    if (config.juiceOptions) {\n      config.juiceResources = config.juiceOptions;\n      delete config.juiceOptions;\n    }\n\n    if (config.disableJuice) {\n      config.juice = false;\n      delete config.disableJuice;\n    }\n\n    if (config.render) {\n      config.customRender = true;\n    }\n\n    this.config = _.merge(\n      {\n        views: {\n          // directory where email templates reside\n          root: path.resolve('emails'),\n          options: {\n            // default file extension for template\n            extension: 'pug',\n            map: {\n              hbs: 'handlebars',\n              njk: 'nunjucks'\n            },\n            engineSource: consolidate\n          },\n          // locals to pass to templates for rendering\n          locals: {\n            // turn on caching for non-development environments\n            cache: !['development', 'test'].includes(env),\n            // pretty is automatically set to `false` for subject/text\n            pretty: true\n          }\n        },\n        // <https://nodemailer.com/message/>\n        message: {},\n        send: !['development', 'test'].includes(env),\n        preview: env === 'development',\n        // <https://github.com/ladjs/i18n>\n        // set to an object to configure and enable it\n        i18n: false,\n        // pass a custom render function if necessary\n        render: this.render.bind(this),\n        customRender: false,\n        // force text-only rendering of template (disregards template folder)\n        textOnly: false,\n        // <https://github.com/werk85/node-html-to-text>\n        htmlToText: {\n          ignoreImage: true\n        },\n        subjectPrefix: false,\n        // <https://github.com/Automattic/juice>\n        juice: true,\n        juiceResources: {\n          preserveImportant: true,\n          webResources: {\n            relativeTo: path.resolve('build'),\n            images: false\n          }\n        },\n        // pass a transport configuration object or a transport instance\n        // (e.g. an instance is created via `nodemailer.createTransport`)\n        // <https://nodemailer.com/transports/>\n        transport: {}\n      },\n      config\n    );\n\n    // override existing method\n    this.render = this.config.render;\n\n    if (!_.isFunction(this.config.transport.sendMail))\n      this.config.transport = nodemailer.createTransport(this.config.transport);\n\n    debug('transformed config %O', this.config);\n\n    autoBind(this);\n  }\n\n  // shorthand use of `juiceResources` with the config\n  // (mainly for custom renders like from a database)\n  juiceResources(html) {\n    return juiceResources(html, this.config.juiceResources);\n  }\n\n  // a simple helper function that gets the actual file path for the template\n  async getTemplatePath(template) {\n    const [root, view] = path.isAbsolute(template)\n      ? [path.dirname(template), path.basename(template)]\n      : [this.config.views.root, template];\n    const paths = await getPaths(\n      root,\n      view,\n      this.config.views.options.extension\n    );\n    const filePath = path.resolve(root, paths.rel);\n    return { filePath, paths };\n  }\n\n  // returns true or false if a template exists\n  // (uses same look-up approach as `render` function)\n  async templateExists(view) {\n    try {\n      const { filePath } = await this.getTemplatePath(view);\n      const stats = await stat(filePath);\n      if (!stats.isFile()) throw new Error(`${filePath} was not a file`);\n      return true;\n    } catch (err) {\n      debug('templateExists', err);\n      return false;\n    }\n  }\n\n  // promise version of consolidate's render\n  // inspired by koa-views and re-uses the same config\n  // <https://github.com/queckezz/koa-views>\n  async render(view, locals = {}) {\n    const { map, engineSource } = this.config.views.options;\n    const { filePath, paths } = await this.getTemplatePath(view);\n    if (paths.ext === 'html' && !map) {\n      const res = await readFile(filePath, 'utf8');\n      return res;\n    }\n\n    const engineName = map && map[paths.ext] ? map[paths.ext] : paths.ext;\n    const renderFn = engineSource[engineName];\n    if (!engineName || !renderFn)\n      throw new Error(\n        `Engine not found for the \".${paths.ext}\" file extension`\n      );\n\n    if (_.isObject(this.config.i18n)) {\n      const i18n = new I18N(\n        Object.assign({}, this.config.i18n, {\n          register: locals\n        })\n      );\n\n      // support `locals.user.last_locale`\n      // (e.g. for <https://lad.js.org>)\n      if (_.isObject(locals.user) && _.isString(locals.user.last_locale))\n        locals.locale = locals.user.last_locale;\n\n      if (_.isString(locals.locale)) i18n.setLocale(locals.locale);\n    }\n\n    const res = await Promise.promisify(renderFn)(filePath, locals);\n    // transform the html with juice using remote paths\n    // google now supports media queries\n    // https://developers.google.com/gmail/design/reference/supported_css\n    if (!this.config.juice) return res;\n    const html = await this.juiceResources(res);\n    return html;\n  }\n\n  // TODO: this needs refactored\n  // so that we render templates asynchronously\n  async renderAll(template, locals = {}, message = {}) {\n    let subjectTemplateExists = this.config.customRender;\n    let htmlTemplateExists = this.config.customRender;\n    let textTemplateExists = this.config.customRender;\n\n    if (template && !this.config.customRender)\n      [\n        subjectTemplateExists,\n        htmlTemplateExists,\n        textTemplateExists\n      ] = await Promise.all([\n        this.templateExists(`${template}/subject`),\n        this.templateExists(`${template}/html`),\n        this.templateExists(`${template}/text`)\n      ]);\n\n    if (!message.subject && subjectTemplateExists) {\n      message.subject = await this.render(\n        `${template}/subject`,\n        Object.assign({}, locals, { pretty: false })\n      );\n      message.subject = message.subject.trim();\n    }\n\n    if (message.subject && this.config.subjectPrefix)\n      message.subject = this.config.subjectPrefix + message.subject;\n\n    if (!message.html && htmlTemplateExists)\n      message.html = await this.render(`${template}/html`, locals);\n\n    if (!message.text && textTemplateExists)\n      message.text = await this.render(\n        `${template}/text`,\n        Object.assign({}, locals, { pretty: false })\n      );\n\n    if (this.config.htmlToText && message.html && !message.text)\n      // we'd use nodemailer-html-to-text plugin\n      // but we really don't need to support cid\n      // <https://github.com/andris9/nodemailer-html-to-text>\n      message.text = htmlToText.fromString(\n        message.html,\n        this.config.htmlToText\n      );\n\n    // if we only want a text-based version of the email\n    if (this.config.textOnly) delete message.html;\n\n    // if no subject, html, or text content exists then we should\n    // throw an error that says at least one must be found\n    // otherwise the email would be blank (defeats purpose of email-templates)\n    if (\n      s.isBlank(message.subject) &&\n      s.isBlank(message.text) &&\n      s.isBlank(message.html) &&\n      _.isArray(message.attachments) &&\n      _.isEmpty(message.attachments)\n    )\n      throw new Error(\n        `No content was passed for subject, html, text, nor attachments message props. Check that the files for the template \"${template}\" exist.`\n      );\n\n    return message;\n  }\n\n  async send(options = {}) {\n    options = Object.assign(\n      {\n        template: '',\n        message: {},\n        locals: {}\n      },\n      options\n    );\n\n    let { template, message, locals } = options;\n\n    const attachments =\n      message.attachments || this.config.message.attachments || [];\n\n    message = _.defaultsDeep(\n      {},\n      _.omit(message, 'attachments'),\n      _.omit(this.config.message, 'attachments')\n    );\n    locals = _.defaultsDeep({}, this.config.views.locals, locals);\n\n    if (attachments) message.attachments = attachments;\n\n    debug('template %s', template);\n    debug('message %O', message);\n    debug('locals (keys only): %O', Object.keys(locals));\n\n    // get all available templates\n    const obj = await this.renderAll(template, locals, message);\n\n    // assign the object variables over to the message\n    Object.assign(message, obj);\n\n    if (this.config.preview) {\n      debug('using `preview-email` to preview email');\n      if (_.isObject(this.config.preview))\n        await previewEmail(message, null, true, this.config.preview);\n      else await previewEmail(message);\n    }\n\n    if (!this.config.send) {\n      debug('send disabled so we are ensuring JSONTransport');\n      // <https://github.com/nodemailer/nodemailer/issues/798>\n      // if (this.config.transport.name !== 'JSONTransport')\n      this.config.transport = nodemailer.createTransport({\n        jsonTransport: true\n      });\n    }\n\n    const res = await this.config.transport.sendMail(message);\n    debug('message sent');\n    res.originalMessage = message;\n    return res;\n  }\n}\n\nmodule.exports = Email;\n"]}

Zerion Mini Shell 1.0