@travetto/email-compiler 7.0.0-rc.0 → 7.0.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/email-compiler",
-  "version": "7.0.0-rc.0",
+  "version": "7.0.0-rc.2",
   "description": "Email compiling module",
   "keywords": [
     "email",
@@ -26,12 +26,12 @@
     "directory": "module/email-compiler"
   },
   "dependencies": {
-    "@travetto/config": "^7.0.0-rc.0",
-    "@travetto/di": "^7.0.0-rc.0",
-    "@travetto/email": "^7.0.0-rc.0",
-    "@travetto/image": "^7.0.0-rc.0",
-    "@travetto/runtime": "^7.0.0-rc.0",
-    "@travetto/worker": "^7.0.0-rc.0",
+    "@travetto/config": "^7.0.0-rc.2",
+    "@travetto/di": "^7.0.0-rc.2",
+    "@travetto/email": "^7.0.0-rc.2",
+    "@travetto/image": "^7.0.0-rc.2",
+    "@travetto/runtime": "^7.0.0-rc.2",
+    "@travetto/worker": "^7.0.0-rc.2",
     "@types/inline-css": "^3.0.4",
     "html-entities": "^2.6.0",
     "inline-css": "^4.0.3",
@@ -39,7 +39,7 @@
     "sass": "^1.94.2"
   },
   "peerDependencies": {
-    "@travetto/cli": "^7.0.0-rc.0"
+    "@travetto/cli": "^7.0.0-rc.2"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -23,14 +23,14 @@ export class EmailCompiler {
   /**
    * Grab list of all available templates
    */
-  static findAllTemplates(mod?: string): string[] {
+  static findAllTemplates(moduleName?: string): string[] {
     return RuntimeIndex
       .find({
-        module: m => !mod ? m.roles.includes('std') : mod === m.name,
-        folder: f => f === 'support',
-        file: f => EmailCompileUtil.isTemplateFile(f.sourceFile)
+        module: mod => !moduleName ? mod.roles.includes('std') : moduleName === mod.name,
+        folder: folder => folder === 'support',
+        file: file => EmailCompileUtil.isTemplateFile(file.sourceFile)
       })
-      .map(x => x.sourceFile);
+      .map(file => file.sourceFile);
   }
 
   /**
@@ -52,14 +52,14 @@ export class EmailCompiler {
   /**
    * Write template to file
    */
-  static async writeTemplate(file: string, msg: EmailCompiled): Promise<void> {
+  static async writeTemplate(file: string, message: EmailCompiled): Promise<void> {
     const outs = this.getOutputFiles(file);
-    await Promise.all(TypedObject.keys(outs).map(async k => {
-      if (msg[k]) {
-        const content = MailUtil.buildBrand(file, msg[k], 'trv email:compile');
-        await BinaryUtil.bufferedFileWrite(outs[k], content);
+    await Promise.all(TypedObject.keys(outs).map(async key => {
+      if (message[key]) {
+        const content = MailUtil.buildBrand(file, message[key], 'trv email:compile');
+        await BinaryUtil.bufferedFileWrite(outs[key], content);
       } else {
-        await fs.rm(outs[k], { force: true }); // Remove file if data not provided
+        await fs.rm(outs[key], { force: true }); // Remove file if data not provided
       }
     }));
   }
@@ -68,8 +68,8 @@ export class EmailCompiler {
    * Compile a file given a resource provider
    */
   static async compile(file: string): Promise<EmailCompiled> {
-    const tpl = await this.loadTemplate(file);
-    const compiled = await EmailCompileUtil.compile(tpl);
+    const template = await this.loadTemplate(file);
+    const compiled = await EmailCompileUtil.compile(template);
     await this.writeTemplate(file, compiled);
     return compiled;
   }
@@ -79,7 +79,7 @@ export class EmailCompiler {
    */
   static async compileAll(mod?: string): Promise<string[]> {
     const keys = this.findAllTemplates(mod);
-    await Promise.all(keys.map(src => this.compile(src)));
+    await Promise.all(keys.map(key => this.compile(key)));
     return keys;
   }
 
@@ -89,16 +89,16 @@ export class EmailCompiler {
   static async * watchCompile(signal?: AbortSignal): AsyncIterable<string> {
     // Watch template files
     for await (const { file, action } of watchCompiler({ signal })) {
-      const src = RuntimeIndex.getEntry(file);
-      if (!src || !EmailCompileUtil.isTemplateFile(src.sourceFile) || action === 'delete') {
+      const entry = RuntimeIndex.getEntry(file);
+      if (!entry || !EmailCompileUtil.isTemplateFile(entry.sourceFile) || action === 'delete') {
         continue;
       }
       try {
         await this.compile(file);
         console.log('Successfully compiled template', { changed: [file] });
         yield file;
-      } catch (err) {
-        console.error(`Error in compiling ${file}`, err && err instanceof Error ? err.message : `${err}`);
+      } catch (error) {
+        console.error(`Error in compiling ${file}`, error && error instanceof Error ? error.message : `${error}`);
       }
     }
   }

package/src/util.ts

@@ -11,11 +11,11 @@ type Tokenized = {
   finalize: (onToken: (token: string) => string) => string;
 };
 
-const SUPPORT_SRC = /(?:support|src)\//;
+const SUPPORT_SOURCE = /(?:support|src)\//;
 
 const HTML_CSS_IMAGE_URLS = [
-  /(?<pre><img[^>]src=\s{0,10}["'])(?<src>[^"{}]{1,1000})/g,
-  /(?<pre>background(?:-image)?:\s{0,10}url[(]['"]?)(?<src>[^"'){}]{1,1000})/g
+  /(?<prefix><img[^>]src=\s{0,10}["'])(?<source>[^"{}]{1,1000})/g,
+  /(?<prefix>background(?:-image)?:\s{0,10}url[(]['"]?)(?<source>[^"'){}]{1,1000})/g
 ];
 
 const EXT = /[.]email[.]tsx$/;
@@ -36,8 +36,8 @@ export class EmailCompileUtil {
    * Generate singular output path given a file
    */
   static buildOutputPath(file: string, suffix: string, prefix?: string): string {
-    const res = (SUPPORT_SRC.test(file) ? file.split(SUPPORT_SRC)[1] : file).replace(EXT, suffix);
-    return prefix ? path.join(prefix, res) : res;
+    const location = (SUPPORT_SOURCE.test(file) ? file.split(SUPPORT_SOURCE)[1] : file).replace(EXT, suffix);
+    return prefix ? path.join(prefix, location) : location;
   }
 
   /**
@@ -62,16 +62,16 @@ export class EmailCompileUtil {
     let id = 0;
     const tokens = new Map();
     for (const pattern of patterns) {
-      for (const { [0]: all, groups: { pre, src } = { pre: '', src: '' } } of text.matchAll(pattern)) {
-        if (src.includes('://')) { // No urls
+      for (const { [0]: all, groups: { prefix, source } = { prefix: '', source: '' } } of text.matchAll(pattern)) {
+        if (source.includes('://')) { // No urls
           continue;
         }
         const token = `@@${id += 1}@@`;
-        tokens.set(token, src);
-        text = text.replace(all, `${pre}${token}`);
+        tokens.set(token, source);
+        text = text.replace(all, `${prefix}${token}`);
       }
     }
-    const finalize = (onToken: (token: string) => string): string => text.replace(/@@[^@]{1,100}@@/g, t => onToken(t));
+    const finalize = (onToken: (token: string) => string): string => text.replace(/@@[^@]{1,100}@@/g, token => onToken(token));
 
     return { text, tokens, finalize };
   }
@@ -79,12 +79,12 @@ export class EmailCompileUtil {
   /**
    * Compile SCSS content with roots as search paths for additional assets
    */
-  static async compileSass(src: { data: string } | { file: string }, opts: EmailTemplateResource): Promise<string> {
+  static async compileSass(input: { data: string } | { file: string }, options: EmailTemplateResource): Promise<string> {
     const sass = await import('sass');
     const result = await util.promisify(sass.render)({
-      ...src,
+      ...input,
       sourceMap: false,
-      includePaths: opts.loader.searchPaths.slice(0)
+      includePaths: options.loader.searchPaths.slice(0)
     });
     return result!.css.toString();
   }
@@ -133,21 +133,21 @@ export class EmailCompileUtil {
   /**
    * Inline image sources
    */
-  static async inlineImages(html: string, opts: EmailTemplateResource): Promise<string> {
+  static async inlineImages(html: string, options: EmailTemplateResource): Promise<string> {
     const { tokens, finalize } = await this.tokenizeResources(html, HTML_CSS_IMAGE_URLS);
     const pendingImages: [token: string, ext: string, stream: Buffer | Promise<Buffer>][] = [];
 
-    for (const [token, src] of tokens) {
-      const ext = path.extname(src);
+    for (const [token, source] of tokens) {
+      const ext = path.extname(source);
       if (/^[.](jpe?g|png)$/.test(ext)) {
         const output = await ImageUtil.convert(
-          await opts.loader.readStream(src),
+          await options.loader.readStream(source),
           { format: ext === '.png' ? 'png' : 'jpeg' }
         );
         const buffer = await toBuffer(output);
         pendingImages.push([token, ext, buffer]);
       } else {
-        pendingImages.push([token, ext, opts.loader.read(src, true)]);
+        pendingImages.push([token, ext, options.loader.read(source, true)]);
       }
     }
 
@@ -167,7 +167,7 @@ export class EmailCompileUtil {
       .replace(/<(meta|img|link|hr|br)[^>]{0,200}>/g, a => a.replace(/>/g, '/>')) // Fix self closing
       .replace(/&apos;/g, '&#39;') // Fix apostrophes, as outlook hates them
       .replace(/(background(?:-color)?:\s*)([#0-9a-f]{6,8})([^>.#,]+)>/ig,
-        (all, p, col, rest) => `${p}${col}${rest} bgcolor="${col}">`) // Inline bg-color
+        (all, property, color, rest) => `${property}${color}${rest} bgcolor="${color}">`) // Inline bg-color
       .replace(/<([^>]+vertical-align:\s*(top|bottom|middle)[^>]+)>/g,
         (a, tag, valign) => tag.indexOf('valign') ? `<${tag}>` : `<${tag} valign="${valign}">`) // Vertically align if it has the style
       .replace(/<(table[^>]+expand[^>]+width:\s*)(100%\s+!important)([^>]+)>/g,
@@ -179,14 +179,16 @@ export class EmailCompileUtil {
   /**
    * Apply styles into a given html document
    */
-  static async applyStyles(html: string, opts: EmailTemplateResource): Promise<string> {
+  static async applyStyles(html: string, options: EmailTemplateResource): Promise<string> {
     const styles = [
-      opts.globalStyles ?? '',
-      await opts.loader.read('/email/main.scss').catch(() => '')
-    ].filter(x => !!x).join('\n');
+      options.globalStyles ?? '',
+      await options.loader.read('/email/main.scss').catch(() => '')
+    ]
+      .filter(line => !!line)
+      .join('\n');
 
     if (styles.length) {
-      const compiled = await this.compileSass({ data: styles }, opts);
+      const compiled = await this.compileSass({ data: styles }, options);
 
       // Remove all unused styles
       const finalStyles = await this.pruneCss(html, compiled);
@@ -198,21 +200,21 @@ export class EmailCompileUtil {
     return html;
   }
 
-  static async compile(src: EmailTemplateModule): Promise<EmailCompiled> {
-    const subject = await this.simplifiedText(await src.subject());
-    const text = await this.simplifiedText(await src.text());
+  static async compile(input: EmailTemplateModule): Promise<EmailCompiled> {
+    const subject = await this.simplifiedText(await input.subject());
+    const text = await this.simplifiedText(await input.text());
 
-    let html = await src.html();
+    let html = await input.html();
 
-    if (src.inlineStyle !== false) {
-      html = await this.applyStyles(html, src);
+    if (input.inlineStyle !== false) {
+      html = await this.applyStyles(html, input);
     }
 
     // Fix up html edge cases
     html = this.handleHtmlEdgeCases(html);
 
-    if (src.inlineImages !== false) {
-      html = await this.inlineImages(html, src);
+    if (input.inlineImages !== false) {
+      html = await this.inlineImages(html, input);
     }
 
     return { html, subject, text };

package/support/bin/editor.ts

@@ -24,10 +24,11 @@ export class EditorService {
     return Promise.resolve(this.engine.render(text, context)).then(MailUtil.purgeBrand);
   }
 
-  async #renderTemplate(rel: string, context: Record<string, unknown>): Promise<EmailCompiled> {
-    const p = await EmailCompiler.compile(rel);
+  async #renderTemplate(templateFile: string, context: Record<string, unknown>): Promise<EmailCompiled> {
+    const email = await EmailCompiler.compile(templateFile);
     return TypedObject.fromEntries(
-      await Promise.all(TypedObject.entries(p).map(([k, v]) => this.#interpolate(v, context).then((t) => [k, t])))
+      await Promise.all(TypedObject.entries(email).map(([key, value]) =>
+        this.#interpolate(value, context).then((result) => [key, result])))
     );
   }
 
@@ -36,24 +37,24 @@ export class EditorService {
     return { content, file };
   }
 
-  async #response<T>(op: Promise<T>, success: (v: T) => EditorResponse, fail?: (err: Error) => EditorResponse): Promise<void> {
+  async #response<T>(operation: Promise<T>, success: (value: T) => EditorResponse, fail?: (error: Error) => EditorResponse): Promise<void> {
     try {
-      const res = await op;
-      if (process.connected) { process.send?.(success(res)); }
-    } catch (err) {
-      if (fail && process.connected && err && err instanceof Error) {
-        process.send?.(fail(err));
+      const response = await operation;
+      if (process.connected) { process.send?.(success(response)); }
+    } catch (error) {
+      if (fail && process.connected && error && error instanceof Error) {
+        process.send?.(fail(error));
       } else {
-        console.error(err);
+        console.error(error);
       }
     }
   }
 
   async sendFile(file: string, to?: string): Promise<{ to: string, file: string, url?: string | false | undefined }> {
-    const cfg = await EditorConfig.get();
-    to ||= cfg.to;
-    const content = await this.#renderTemplate(file, cfg.context ?? {});
-    return { to, file, ...await this.sender.send({ from: cfg.from, to, ...content, }) };
+    const config = await EditorConfig.get();
+    to ||= config.to;
+    const content = await this.#renderTemplate(file, config.context ?? {});
+    return { to, file, ...await this.sender.send({ from: config.from, to, ...content, }) };
   }
 
   /**
@@ -63,22 +64,22 @@ export class EditorService {
     if (!process.connected || !process.send) {
       throw new AppError('Unable to run email editor, missing ipc channel');
     }
-    process.on('message', async (msg: EditorRequest) => {
-      switch (msg.type) {
+    process.on('message', async (request: EditorRequest) => {
+      switch (request.type) {
         case 'configure': {
           return await this.#response(EditorConfig.ensureConfig(), file => ({ type: 'configured', file }));
         }
         case 'compile': {
-          return await this.#response(this.#renderFile(msg.file),
-            res => ({ type: 'compiled', ...res }),
-            err => ({ type: 'compiled-failed', message: err.message, stack: err.stack, file: msg.file })
+          return await this.#response(this.#renderFile(request.file),
+            result => ({ type: 'compiled', ...result }),
+            error => ({ type: 'compiled-failed', message: error.message, stack: error.stack, file: request.file })
           );
         }
         case 'send': {
           return await this.#response(
-            this.sendFile(msg.file, msg.to),
-            res => ({ type: 'sent', ...res }),
-            err => ({ type: 'sent-failed', message: err.message, stack: err.stack, to: msg.to!, file: msg.file })
+            this.sendFile(request.file, request.to),
+            result => ({ type: 'sent', ...result }),
+            error => ({ type: 'sent-failed', message: error.message, stack: error.stack, to: request.to!, file: request.file })
           );
         }
       }
@@ -88,8 +89,8 @@ export class EditorService {
 
     for await (const file of EmailCompiler.watchCompile()) {
       await this.#response(this.#renderFile(file),
-        res => ({ type: 'compiled', ...res }),
-        err => ({ type: 'compiled-failed', message: err.message, stack: err.stack, file })
+        result => ({ type: 'compiled', ...result }),
+        error => ({ type: 'compiled-failed', message: error.message, stack: error.stack, file })
       );
     }
   }

package/support/bin/send.ts

@@ -33,7 +33,7 @@ export class EditorSendService {
             }
           }
         });
-        Registry.process([{ type: 'added', curr: cls }]);
+        Registry.process([{ type: 'added', current: cls }]);
 
         this.ethereal = !!senderConfig.host?.includes('ethereal.email');
       } catch {
@@ -51,23 +51,23 @@ export class EditorSendService {
     const to = message.to!;
     try {
       console.log('Sending email', { to });
-      const svc = await this.service();
+      const service = await this.service();
       if (this.ethereal) {
         const { getTestMessageUrl } = await import('nodemailer');
         const { default: _smtp } = await import('nodemailer/lib/smtp-transport/index');
         type SendMessage = Parameters<Parameters<(typeof _smtp)['prototype']['send']>[1]>[1];
-        const info = await svc.send<SendMessage>(message);
+        const info = await service.send<SendMessage>(message);
         const url = getTestMessageUrl(info);
         console.log('Sent email', { to, url });
         return { url };
       } else {
-        await svc.send(message);
+        await service.send(message);
         console.log('Sent email', { to });
         return {};
       }
-    } catch (err) {
-      console.warn('Failed to send email', { to, error: err });
-      throw err;
+    } catch (error) {
+      console.warn('Failed to send email', { to, error });
+      throw error;
     }
   }
 }

package/support/cli.email_compile.ts

@@ -23,10 +23,10 @@ export class EmailCompileCommand implements CliCommandShape {
     await Registry.init();
 
     // Let the engine template
-    const all = await EmailCompiler.compileAll();
-    console!.log(cliTpl`Successfully compiled ${{ param: `${all.length}` }} templates`);
-    for (const el of all) {
-      console!.log(cliTpl`  * ${{ param: Runtime.stripWorkspacePath(el) }}`);
+    const locations = await EmailCompiler.compileAll();
+    console!.log(cliTpl`Successfully compiled ${{ param: `${locations.length}` }} templates`);
+    for (const location of locations) {
+      console!.log(cliTpl`  * ${{ param: Runtime.stripWorkspacePath(location) }}`);
     }
 
     if (this.watch) {