@travetto/email-compiler 3.1.20 → 3.1.22

package/__index__.ts

@@ -1,2 +1,2 @@
-export * from './src/resource';
-export * from './src/compiler';
+export * from './src/compiler';
+export * from './src/util';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/email-compiler",
-  "version": "3.1.20",
+  "version": "3.1.22",
   "description": "Email compiling module",
   "keywords": [
     "email",
@@ -26,11 +26,11 @@
     "directory": "module/email-compiler"
   },
   "dependencies": {
-    "@travetto/base": "^3.1.2",
-    "@travetto/config": "^3.1.6",
-    "@travetto/di": "^3.1.3",
-    "@travetto/email": "^3.1.12",
-    "@travetto/image": "^3.1.3",
+    "@travetto/base": "^3.1.3",
+    "@travetto/config": "^3.1.7",
+    "@travetto/di": "^3.1.4",
+    "@travetto/email": "^3.1.13",
+    "@travetto/image": "^3.1.4",
     "@types/inline-css": "^3.0.1",
     "html-entities": "^2.3.3",
     "inline-css": "^4.0.2",
@@ -38,7 +38,7 @@
     "purgecss": "^5.0.0"
   },
   "peerDependencies": {
-    "@travetto/cli": "^3.1.7"
+    "@travetto/cli": "^3.1.8"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/compiler.ts

@@ -1,187 +1,145 @@
 import fs from 'fs/promises';
-import util from 'util';
-import { decode as decodeEntities } from 'html-entities';
 
-import { ImageConverter } from '@travetto/image';
-import { RootIndex, path } from '@travetto/manifest';
-import { StreamUtil } from '@travetto/base';
+import { FileQueryProvider, TypedObject } from '@travetto/base';
 import { MessageCompilationSource, MessageCompiled } from '@travetto/email';
+import { RootIndex, path } from '@travetto/manifest';
+import { DynamicFileLoader } from '@travetto/base/src/internal/file-loader';
+
+import { EmailCompileUtil } from './util';
 
-import { EmailCompilerResource } from './resource';
+const VALID_FILE = (file: string): boolean => /[.](scss|css|png|jpe?g|gif|ya?ml)$/.test(file) && !/[.]compiled[.]/.test(file);
 
 /**
- * Utilities for templating
+ * Email compilation support
  */
 export class EmailCompiler {
 
-  static HTML_CSS_IMAGE_URLS = [
-    /(?<pre><img[^>]src=\s*["'])(?<src>[^"]+)/g,
-    /(?<pre>background(?:-image)?:\s*url[(]['"]?)(?<src>[^"')]+)/g
-  ];
+  /** Load Template */
+  static async loadTemplate(file: string): Promise<MessageCompilationSource> {
+    const entry = RootIndex.getEntry(file);
+    if (!entry) {
+      throw new Error(`Unable to find template for ${file}`);
+    }
+    const root = (await import(entry.outputFile)).default;
+    const res: MessageCompilationSource = { ...await root.wrap(), file: entry.sourceFile };
+    const mod = RootIndex.getModule(entry.module)!;
 
-  static async readText(text: Promise<string> | string): Promise<string> {
-    return decodeEntities((await text).replace(/&#xA0;/g, ' '));
-  }
+    const resourcePaths = [
+      path.resolve(mod.sourcePath, 'resources'),
+      path.resolve(RootIndex.manifest.workspacePath, 'resources')
+    ];
 
-  /**
-   * Compile SCSS content with roots as search paths for additional assets
-   */
-  static async compileSass(src: { data: string } | { file: string }, roots: string[]): Promise<string> {
-    const sass = await import('sass');
-    const result = await util.promisify(sass.render)({
-      ...src,
-      sourceMap: false,
-      includePaths: roots
-    });
-    return result!.css.toString();
-  }
+    const styles = res.styles ??= {};
+    (styles.search ??= []).push(...resourcePaths);
 
-  resources: EmailCompilerResource;
+    const images = res.images ??= {};
+    (images.search ??= []).push(...resourcePaths);
 
-  constructor(resources: EmailCompilerResource) {
-    this.resources = resources;
+    return res;
   }
 
   /**
-   * Inline image sources
+   * Grab list of all available templates
    */
-  async inlineImageSource(html: string): Promise<string> {
-    const { tokens, finalize } = await this.resources.tokenizeResources(html, EmailCompiler.HTML_CSS_IMAGE_URLS);
-    const pendingImages: Promise<[token: string, content: string]>[] = [];
-
-    for (const [token, src] of tokens) {
-      const ext = path.extname(src).replace(/^[.]/, '');
-      const stream = await this.resources.readStream(src);
-
-      switch (ext) {
-        case 'jpg':
-        case 'jpeg':
-        case 'png': {
-          pendingImages.push(
-            ImageConverter.optimize(ext === 'png' ? 'png' : 'jpeg', stream)
-              .then(img => StreamUtil.streamToBuffer(img))
-              .then(data => [token, `data:image/${ext};base64,${data.toString('base64')}`])
-          );
-          break;
-        }
-        default: {
-          pendingImages.push(
-            StreamUtil.streamToBuffer(stream)
-              .then(data => [token, `data:image/${ext};base64,${data.toString('base64')}`])
-          );
-        }
-      }
-    }
-
-    const imageMap = new Map(await Promise.all(pendingImages));
-
-    return finalize(token => imageMap.get(token)!);
+  static findAllTemplates(mod?: string): string[] {
+    return RootIndex
+      .findSupport({ filter: f => EmailCompileUtil.isTemplateFile(f) })
+      .filter(x => !mod || x.module === mod)
+      .map(x => x.sourceFile);
   }
 
-  async pruneCss(html: string, css: string): Promise<string> {
-    const { PurgeCSS } = await import('purgecss');
-    const purge = new PurgeCSS();
-    const result = await purge.purge({
-      content: [{ raw: html, extension: 'html' }],
-      css: [{ raw: css }],
-    });
-    return result[0].css;
+  /**
+   * Get output files
+   */
+  static getOutputFiles(file: string): MessageCompiled {
+    const entry = RootIndex.getEntry(file)!;
+    const mod = RootIndex.getModule(entry.module)!;
+    return EmailCompileUtil.getOutputs(file, path.join(mod.sourcePath, 'resources'));
   }
 
-  async inlineCss(html: string, css: string): Promise<string> {
-    // Inline css
-    const { default: inlineCss } = await import('inline-css');
-    html = html.replace('</head>', `<style>${css}</style></head>`);
-    // Style needs to be in head to preserve media queries
-    html = (await inlineCss(html, {
-      url: 'https://app.dev',
-      preserveMediaQueries: true,
-      removeStyleTags: true,
-      removeLinkTags: true,
-      applyStyleTags: true,
-    }));
-    return html;
+  /**
+   * Get the sending email key from a template file
+   */
+  static async templateFileToKey(file: string): Promise<string> {
+    return EmailCompileUtil.buildOutputPath(file, '');
   }
 
   /**
-   * Compile all
+   * Write template to file
    */
-  async compileAll(persist = false): Promise<MessageCompiled[]> {
-    const keys = await this.resources.findAllTemplates();
-    return Promise.all(keys.map(src => this.compile(src, persist)));
+  static async writeTemplate(file: string, msg: MessageCompiled): Promise<void> {
+    const outs = this.getOutputFiles(file);
+    await Promise.all(TypedObject.keys(outs).map(async k => {
+      if (msg[k]) {
+        await fs.mkdir(path.dirname(outs[k]), { recursive: true });
+        await fs.writeFile(outs[k], msg[k], { encoding: 'utf8' });
+      } else {
+        await fs.unlink(outs[k]).catch(() => { }); // Remove file if data not provided
+      }
+    }));
   }
 
   /**
-   * Compile template
+   * Compile a file given a resource provider
    */
-  async compile(src: string | MessageCompilationSource, persist = false): Promise<MessageCompiled> {
-    if (typeof src === 'string') {
-      src = await this.resources.loadTemplate(src);
+  static async compile(file: string, persist: boolean = false): Promise<MessageCompiled> {
+    const src = await this.loadTemplate(file);
+    const compiled = await EmailCompileUtil.compile(src);
+    if (persist) {
+      await this.writeTemplate(file, compiled);
     }
+    return compiled;
+  }
 
-    const subject = await EmailCompiler.readText(src.subject());
-    const text = await EmailCompiler.readText(src.text());
-
-    let html = (await src.html())
-      .replace(/<(meta|img|link|hr|br)[^>]*>/g, a => a.replace('>', '/>')) // Fix self closing
-      .replace(/&apos;/g, '&#39;'); // Fix apostrophes, as outlook hates them
-
-    if (src.inlineStyles !== false) {
-      const styles: string[] = [];
+  /**
+   * Compile all
+   */
+  static async compileAll(mod?: string): Promise<string[]> {
+    const keys = this.findAllTemplates(mod);
+    await Promise.all(keys.map(src => this.compile(src, true)));
+    return keys;
+  }
 
-      if (src.styles?.global) {
-        styles.push(src.styles.global);
-      }
 
-      const main = await this.resources.read('/email/main.scss').then(d => d, () => '');
-      if (main) {
-        styles.push(main);
+  /**
+   * Watch compilation
+   */
+  static async * watchCompile(): AsyncIterable<string> {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const all = new FileQueryProvider(
+      [...new Set(this.findAllTemplates()
+        .map(x => RootIndex.getEntry(x)!.module)
+      )].map(x => path.resolve(RootIndex.getModule(x)!.sourcePath, 'resources'))
+    );
+
+    const stream = all.watchFiles();
+
+    DynamicFileLoader.onLoadEvent((ev) => {
+      const src = RootIndex.getEntry(ev.file);
+      if (src && EmailCompileUtil.isTemplateFile(src.sourceFile)) {
+        stream.add({ ...ev, file: src.sourceFile });
       }
-
-      if (styles.length) {
-        const compiled = await EmailCompiler.compileSass(
-          { data: styles.join('\n') },
-          [...src.styles?.search ?? [], ...this.resources.getAllPaths()]);
-
-        // Remove all unused styles
-        const finalStyles = await this.pruneCss(html, compiled);
-
-        // Apply styles
-        html = await this.inlineCss(html, finalStyles);
+    });
+    for await (const { file, action } of stream) {
+      if (action === 'delete') {
+        continue;
       }
-    }
 
-    // Fix up style behaviors
-    html = html
-      .replace(/(background(?:-color)?:\s*)([#0-9a-f]{6,8})([^>.#,]+)>/ig,
-        (all, p, col, rest) => `${p}${col}${rest} bgcolor="${col}">`) // 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,
-        (a, left, size, right) => `<${left}100%${right}>`); // Drop important as a fix for outlook
-
-    if (src.inlineImages !== false) {
-      // Inline Images
-      html = await this.inlineImageSource(html);
-    }
-
-    // Write to disk, if desired
-    if (persist) {
-      const outs = this.resources.getOutputs(src.file!, path.join(RootIndex.mainModule.sourcePath, 'resources'));
-      await Promise.all([
-        [outs.text, text],
-        [outs.html, html],
-        [outs.subject, subject]
-      ].map(async ([file, content]) => {
-        if (content) {
-          await fs.mkdir(path.dirname(file), { recursive: true });
-          await fs.writeFile(file, content, { encoding: 'utf8' });
-        } else {
-          await fs.unlink(file).catch(() => { }); // Remove file if data not provided
+      try {
+        if (EmailCompileUtil.isTemplateFile(file)) {
+          await this.compile(file, true);
+          console.log(`Successfully compiled ${1} templates`, { changed: [file] });
+          yield file;
+        } else if (VALID_FILE(file)) {
+          const rootFile = file.replace(/\/resources.*/, '/package.json');
+          const mod = RootIndex.getFromSource(rootFile)!.module;
+          const changed = await this.compileAll(mod);
+          console.log(`Successfully compiled ${changed.length} templates`, { changed, file });
+          yield* changed;
         }
-      }));
+      } catch (err) {
+        console.error(`Error in compiling ${file}`, err && err instanceof Error ? err.message : `${err}`);
+      }
     }
-
-    return { html, text, subject };
   }
 }

package/src/util.ts

@@ -0,0 +1,221 @@
+import util from 'util';
+import { Readable } from 'stream';
+
+import { FileResourceProvider, StreamUtil } from '@travetto/base';
+import { MessageCompilationImages, MessageCompilationSource, MessageCompilationStyles, MessageCompiled } from '@travetto/email';
+import { ImageConverter } from '@travetto/image';
+import { path } from '@travetto/manifest';
+
+
+type Tokenized = {
+  text: string;
+  tokens: Map<string, string>;
+  finalize: (onToken: (token: string) => string) => string;
+};
+
+/**
+ * Email compile tools
+ */
+export class EmailCompileUtil {
+  static #HTML_CSS_IMAGE_URLS = [
+    /(?<pre><img[^>]src=\s*["'])(?<src>[^"]+)/g,
+    /(?<pre>background(?:-image)?:\s*url[(]['"]?)(?<src>[^"')]+)/g
+  ];
+
+  static #EXT = /[.]email[.]tsx$/;
+
+  /**
+   * Is file a template?
+   */
+  static isTemplateFile(file: string): boolean {
+    return this.#EXT.test(file);
+  }
+
+  /**
+   * Generate singular output path given a file
+   */
+  static buildOutputPath(file: string, suffix: string, prefix?: string): string {
+    const res = file.replace(/.*(support|src)\//, '').replace(this.#EXT, suffix);
+    return prefix ? path.join(prefix, res) : res;
+  }
+
+  /**
+   * Get the different parts from the file name
+   */
+  static getOutputs(file: string, prefix?: string): MessageCompiled {
+    return {
+      html: this.buildOutputPath(file, '.compiled.html', prefix),
+      subject: this.buildOutputPath(file, '.compiled.subject', prefix),
+      text: this.buildOutputPath(file, '.compiled.text', prefix),
+    };
+  }
+
+  /**
+   * Run through text and match/resolve resource urls, producing tokens
+   *
+   * @param text
+   * @param patterns
+   * @returns
+   */
+  static async tokenizeResources(text: string, patterns: RegExp[]): Promise<Tokenized> {
+    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
+          continue;
+        }
+        const token = `@@${id += 1}@@`;
+        tokens.set(token, src);
+        text = text.replace(all, `${pre}${token}`);
+      }
+    }
+    const finalize = (onToken: (token: string) => string): string => text.replace(/@@[^@]+@@/g, t => onToken(t));
+
+    return { text, tokens, finalize };
+  }
+
+  /**
+   * Compile SCSS content with roots as search paths for additional assets
+   */
+  static async compileSass(src: { data: string } | { file: string }, roots: string[]): Promise<string> {
+    const sass = await import('sass');
+    const result = await util.promisify(sass.render)({
+      ...src,
+      sourceMap: false,
+      includePaths: roots
+    });
+    return result!.css.toString();
+  }
+
+  /**
+   * Prunes unused css given html document
+   */
+  static async pruneCss(html: string, css: string): Promise<string> {
+    const { PurgeCSS } = await import('purgecss');
+    const purge = new PurgeCSS();
+    const [result] = await purge.purge({
+      content: [{ raw: html, extension: 'html' }],
+      css: [{ raw: css }],
+    });
+    return result.css;
+  }
+
+  /**
+   * Moves CSS inline into html output, minus media queries
+   */
+  static async inlineCss(html: string, css: string): Promise<string> {
+    // Inline css
+    const { default: inlineCss } = await import('inline-css');
+    return inlineCss(
+      // Style needs to be in head to preserve media queries
+      html.replace('</head>', `<style>${css}</style></head>`),
+      {
+        url: 'https://app.dev',
+        preserveMediaQueries: true,
+        removeStyleTags: true,
+        removeLinkTags: true,
+        applyStyleTags: true,
+      });
+  }
+
+  /**
+   * Simplifies text by decoding all entities
+   *
+   * @param text
+   */
+  static async simplifiedText(text: string): Promise<string> {
+    const { decode } = await import('html-entities');
+    return decode(text.replace(/&#xA0;/g, ' '));
+  }
+
+  /**
+   * Inline image sources
+   */
+  static async inlineImages(html: string, opts: MessageCompilationImages): Promise<string> {
+    const { tokens, finalize } = await this.tokenizeResources(html, this.#HTML_CSS_IMAGE_URLS);
+    const pendingImages: [token: string, ext: string, stream: Readable | Promise<Readable>][] = [];
+    const resources = new FileResourceProvider(opts.search ?? []);
+
+    for (const [token, src] of tokens) {
+      const ext = path.extname(src);
+      const stream = await resources.readStream(src);
+      pendingImages.push([token, ext, /^[.](jpe?g|png)$/.test(ext) ?
+        ImageConverter.optimize(ext === '.png' ? 'png' : 'jpeg', stream) : stream]);
+    }
+
+    const imageMap = new Map(await Promise.all(pendingImages.map(async ([token, ext, stream]) => {
+      const data = await StreamUtil.streamToBuffer(await stream);
+      return [token, `data:image/${ext};base64,${data.toString('base64')}`] as const;
+    })));
+
+    return finalize(token => imageMap.get(token)!);
+  }
+
+  /**
+   * Handle various edge cases
+   */
+  static handleHtmlEdgeCases(html: string): string {
+    return html
+      .replace(/<(meta|img|link|hr|br)[^>]*>/g, a => a.replace('>', '/>')) // 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
+      .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,
+        (a, left, size, right) => `<${left}100%${right}>`); // Drop important as a fix for outlook
+  }
+
+
+  /**
+   * Apply styles into a given html document
+   */
+  static async applyStyles(html: string, opts: MessageCompilationStyles): Promise<string> {
+    const styles: string[] = [];
+
+    if (opts.global) {
+      styles.push(opts.global);
+    }
+
+    const resource = new FileResourceProvider(opts.search ?? []);
+    const main = await resource.read('/email/main.scss').then(d => d, () => '');
+
+    if (main) {
+      styles.push(main);
+    }
+
+    if (styles.length) {
+      const compiled = await this.compileSass(
+        { data: styles.join('\n') },
+        [...opts.search ?? []]);
+
+      // Remove all unused styles
+      const finalStyles = await this.pruneCss(html, compiled);
+
+      // Apply styles
+      html = await this.inlineCss(html, finalStyles);
+    }
+
+    return html;
+  }
+
+  static async compile(src: MessageCompilationSource): Promise<MessageCompiled> {
+    const subject = await this.simplifiedText(await src.subject());
+    const text = await this.simplifiedText(await src.text());
+
+    let html = await src.html();
+
+    if (src.styles?.inline !== false) {
+      html = await this.applyStyles(html, src.styles!);
+    }
+
+    // Fix up html edge cases
+    html = this.handleHtmlEdgeCases(html);
+
+    if (src.images?.inline !== false) {
+      html = await this.inlineImages(html, src.images!);
+    }
+    return { html, subject, text };
+  }
+}

package/support/bin/config.ts

@@ -1,6 +1,6 @@
 import fs from 'fs/promises';
 
-import { path } from '@travetto/manifest';
+import { RootIndex, path } from '@travetto/manifest';
 import { YamlUtil } from '@travetto/yaml';
 
 interface ConfigType {
@@ -22,7 +22,7 @@ interface ConfigType {
  */
 export class $EditorConfig {
 
-  #configFile = path.resolve('resources/email/dev.yml');
+  #configFile: Record<string, string> = {};
   #defaultConfig = {
     to: 'my-email@gmail.com',
     from: 'from-email@gmail.com',
@@ -42,9 +42,10 @@ export class $EditorConfig {
   /**
    *
    */
-  async get(): Promise<ConfigType> {
+  async get(file: string): Promise<ConfigType> {
     try {
-      const content = await fs.readFile(this.#configFile, 'utf8');
+      const mod = RootIndex.getModuleFromSource(file)!.name;
+      const content = await fs.readFile(this.#configFile[mod], 'utf8');
       return YamlUtil.parse<ConfigType>(content);
     } catch {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -52,13 +53,13 @@ export class $EditorConfig {
     }
   }
 
-  async getContext(): Promise<Exclude<ConfigType['context'], undefined>> {
-    const conf = await this.get();
+  async getContext(file: string): Promise<Exclude<ConfigType['context'], undefined>> {
+    const conf = await this.get(file);
     return conf.context ?? {};
   }
 
-  async getSenderConfig(): Promise<Exclude<ConfigType['sender'], undefined>> {
-    const conf = await this.get();
+  async getSenderConfig(file: string): Promise<Exclude<ConfigType['sender'], undefined>> {
+    const conf = await this.get(file);
     return conf.sender ?? {};
   }
 
@@ -66,13 +67,15 @@ export class $EditorConfig {
     return YamlUtil.serialize(this.#defaultConfig);
   }
 
-  async ensureConfig(): Promise<string> {
-    const file = this.#configFile;
-    if (!(await fs.stat(file).catch(() => { }))) {
-      await fs.mkdir(path.dirname(file), { recursive: true });
-      await fs.writeFile(file, this.getDefaultConfig(), { encoding: 'utf8' });
+  async ensureConfig(file: string): Promise<string> {
+    console.log('Ensuring config', file);
+    const mod = RootIndex.getModuleFromSource(file)!;
+    const resolved = this.#configFile[mod.name] ??= path.resolve(mod.sourcePath, 'resources/email/dev.yml');
+    if (!(await fs.stat(resolved).catch(() => { }))) {
+      await fs.mkdir(path.dirname(resolved), { recursive: true });
+      await fs.writeFile(resolved, this.getDefaultConfig(), { encoding: 'utf8' });
     }
-    return file;
+    return resolved;
   }
 }
 

package/support/bin/editor.ts

@@ -1,9 +1,14 @@
+import { ShutdownManager } from '@travetto/base';
+
 import { EmailCompilationManager } from './manager';
 import { EditorSendService } from './send';
 import { EditorConfig } from './config';
 
+import { EmailCompiler } from '../../src/compiler';
+import { EmailCompileUtil } from '../../src/util';
+
 type InboundMessage =
-  { type: 'configure' } |
+  { type: 'configure', file: string } |
   { type: 'redraw', file: string } |
   { type: 'send', file: string, from?: string, to?: string };
 
@@ -20,20 +25,18 @@ type OutboundMessage =
 export class EditorState {
 
   #lastFile = '';
-  #sender: EditorSendService;
   #template: EmailCompilationManager;
 
   constructor(template: EmailCompilationManager) {
     this.#template = template;
-    this.#sender = new EditorSendService();
   }
 
   async renderFile(file: string): Promise<void> {
-    file = this.#template.resources.isTemplateFile(file) ? file : this.#lastFile;
+    file = EmailCompileUtil.isTemplateFile(file) ? file : this.#lastFile;
     if (file) {
       try {
         const content = await this.#template.resolveCompiledTemplate(
-          file, await EditorConfig.getContext()
+          file, await EditorConfig.getContext(file)
         );
         this.response({
           type: 'changed',
@@ -57,12 +60,12 @@ export class EditorState {
   }
 
   async onConfigure(msg: InboundMessage & { type: 'configure' }): Promise<void> {
-    this.response({ type: 'configured', file: await EditorConfig.ensureConfig() });
+    this.response({ type: 'configured', file: await EditorConfig.ensureConfig(msg.file) });
   }
 
   async #onRedraw(msg: InboundMessage & { type: 'redraw' }): Promise<void> {
     try {
-      await this.#template.compiler.compile(msg.file, true);
+      await EmailCompiler.compile(msg.file, true);
       await this.renderFile(msg.file);
     } catch (err) {
       if (err && err instanceof Error) {
@@ -74,12 +77,15 @@ export class EditorState {
   }
 
   async onSend(msg: InboundMessage & { type: 'send' }): Promise<void> {
-    const cfg = await EditorConfig.get();
+    const cfg = await EditorConfig.get(msg.file);
     const to = msg.to || cfg.to;
     const from = msg.from || cfg.from;
-    const key = this.#template.resources.buildOutputPath(msg.file, '');
+    const content = await this.#template.resolveCompiledTemplate(
+      msg.file, await EditorConfig.getContext(msg.file)
+    );
+
     try {
-      const url = await this.#sender.sendEmail(key, from, to, await EditorConfig.getContext());
+      const url = await EditorSendService.sendEmail(msg.file, { from, to, ...content, });
       this.response({ type: 'sent', to, file: msg.file, ...url });
     } catch (err) {
       if (err && err instanceof Error) {
@@ -101,7 +107,11 @@ export class EditorState {
         case 'send': this.onSend(msg); break;
       }
     });
-    for await (const f of this.#template.watchCompile()) {
+
+    process.on('disconnect', () => ShutdownManager.execute());
+    process.send?.('ready');
+
+    for await (const f of EmailCompiler.watchCompile()) {
       await this.renderFile(f);
     }
   }

package/support/bin/manager.ts

@@ -1,15 +1,11 @@
+import fs from 'fs/promises';
+
 import type { MailTemplateEngine, MessageCompiled } from '@travetto/email';
-import { TypedObject } from '@travetto/base';
 import { DependencyRegistry } from '@travetto/di';
-import { RootIndex, WatchEvent, WatchStream } from '@travetto/manifest';
-
+import { TypedObject } from '@travetto/base';
 import { MailTemplateEngineTarget } from '@travetto/email/src/internal/types';
-import { DynamicFileLoader } from '@travetto/base/src/internal/file-loader';
 
-import type { EmailCompiler } from '../../src/compiler';
-import type { EmailCompilerResource } from '../../src/resource';
-
-const VALID_FILE = (file: string): boolean => /[.](scss|css|png|jpe?g|gif|ya?ml)$/.test(file) && !/[.]compiled[.]/.test(file);
+import { EmailCompiler } from '../../src/compiler';
 
 /**
  *
@@ -17,41 +13,31 @@ const VALID_FILE = (file: string): boolean => /[.](scss|css|png|jpe?g|gif|ya?ml)
 export class EmailCompilationManager {
 
   static async createInstance(): Promise<EmailCompilationManager> {
-    const { EmailCompiler: Compiler } = await import('../../src/compiler.js');
-    const { EmailCompilerResource: Res } = await import('../../src/resource.js');
-
     return new EmailCompilationManager(
       await DependencyRegistry.getInstance<MailTemplateEngine>(MailTemplateEngineTarget),
-      new Compiler(new Res())
     );
   }
 
-  compiler: EmailCompiler;
   engine: MailTemplateEngine;
 
-  constructor(engine: MailTemplateEngine, compiler: EmailCompiler) {
+  constructor(engine: MailTemplateEngine) {
     this.engine = engine;
-    this.compiler = compiler;
-  }
-
-  get resources(): EmailCompilerResource {
-    return this.compiler.resources;
   }
 
   /**
    * Resolve template
    */
   async resolveTemplateParts(file: string): Promise<MessageCompiled> {
-    const files = this.resources.getOutputs(file);
-    const missing = await Promise.all(Object.values(files).map(x => this.resources.describe(x).catch(() => { })));
+    const files = EmailCompiler.getOutputFiles(file);
+    const missing = await Promise.all(Object.values(files).map(x => fs.stat(file).catch(() => { })));
 
     if (missing.some(x => x === undefined)) {
-      await this.compiler.compile(file, true);
+      await EmailCompiler.compile(file, true);
     }
 
     const parts = await Promise.all(
       TypedObject.entries(files).map(
-        ([key, subRel]) => this.resources.read(subRel)
+        ([key, partFile]) => fs.readFile(partFile, 'utf8')
           .then(content => [key, content] as const)
       )
     );
@@ -72,40 +58,4 @@ export class EmailCompilationManager {
     };
   }
 
-  /**
-   * Watch compilation
-   */
-  async * watchCompile(): AsyncIterable<string> {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const stream = this.resources.watchFiles() as (
-      WatchStream & {
-        add(item: WatchEvent | WatchEvent[]): void;
-      }
-    );
-    DynamicFileLoader.onLoadEvent((ev) => {
-      const src = RootIndex.getEntry(ev.file);
-      if (src && this.resources.isTemplateFile(src.sourceFile)) {
-        stream.add({ ...ev, file: src.sourceFile });
-      }
-    });
-    for await (const { file, action } of stream) {
-      if (action === 'delete') {
-        continue;
-      }
-
-      try {
-        if (this.resources.isTemplateFile(file)) {
-          await this.compiler.compile(file, true);
-          yield file;
-        } else if (VALID_FILE(file)) {
-          await this.compiler.compileAll(true);
-          for (const el of await this.resources.findAllTemplates()) {
-            yield el.file!;
-          }
-        }
-      } catch (err) {
-        console.error(`Error in compiling ${file}`, err && err instanceof Error ? err.message : `${err}`);
-      }
-    }
-  }
 }

package/support/bin/send.ts

@@ -1,22 +1,25 @@
-import { MailService, SentMessage } from '@travetto/email';
+import { MailService, MessageOptions, SentMessage } from '@travetto/email';
 import { MailTransportTarget } from '@travetto/email/src/internal/types';
 import { DependencyRegistry } from '@travetto/di';
 
 import { EditorConfig } from './config';
+import { RootIndex } from '@travetto/manifest';
 
 /**
  * Util for sending emails
  */
 export class EditorSendService {
 
-  #svc: MailService;
+  static #svc: Record<string, MailService> = {};
 
   /**
    * Get mail service
    */
-  async getMailService(): Promise<MailService> {
-    if (!this.#svc) {
-      const senderConfig = await EditorConfig.getSenderConfig();
+  static async getMailService(file: string): Promise<MailService> {
+    const mod = RootIndex.getModuleFromSource(file)!.name;
+
+    if (!this.#svc[mod]) {
+      const senderConfig = await EditorConfig.getSenderConfig(file);
 
       if (senderConfig?.host?.includes('ethereal.email')) {
         const cls = class { };
@@ -39,30 +42,32 @@ ${EditorConfig.getDefaultConfig()}`.trim();
         throw new Error(errorMessage);
       }
 
-      this.#svc = await DependencyRegistry.getInstance(MailService);
+      this.#svc[mod] = await DependencyRegistry.getInstance(MailService);
     }
-    return this.#svc;
+    return this.#svc[mod];
   }
 
   /**
    * Resolve template
    */
-  async sendEmail(key: string, from: string, to: string, context: Record<string, unknown>): Promise<{
+  static async sendEmail(file: string, message: MessageOptions): Promise<{
     url?: string | false;
   }> {
+    const to = message.to!;
     try {
       console.log('Sending email', { to });
       // Let the engine template
-      const svc = await this.getMailService();
+      const svc = await this.getMailService(file);
       if (!svc) {
         throw new Error('Node mailer support is missing');
       }
 
-      const info = await svc.send<{ host?: string } & SentMessage>({ to, from }, key, context);
+      const info = await svc.send<{ host?: string } & SentMessage>(message);
       console.log('Sent email', { to });
 
-      const senderConfig = await EditorConfig.getSenderConfig();
+      const senderConfig = await EditorConfig.getSenderConfig(file);
       return senderConfig.host?.includes('ethereal.email') ? {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
         url: (await import('nodemailer')).getTestMessageUrl(info as any)
       } : {};
     } catch (err) {

package/support/cli.email_compile.ts

@@ -1,13 +1,13 @@
 import { RootRegistry } from '@travetto/registry';
 import { CliCommandShape, CliCommand, cliTpl } from '@travetto/cli';
-
-import { EmailCompilationManager } from './bin/manager';
 import { GlobalEnvConfig } from '@travetto/base';
 
+import { EmailCompiler } from '../src/compiler';
+
 /**
  * CLI Entry point for running the email server
  */
-@CliCommand({ fields: ['module'] })
+@CliCommand()
 export class EmailCompileCommand implements CliCommandShape {
 
   /** Compile in watch mode */
@@ -23,14 +23,16 @@ export class EmailCompileCommand implements CliCommandShape {
   async main(): Promise<void> {
     await RootRegistry.init();
 
-    const template = await EmailCompilationManager.createInstance();
-
     // Let the engine template
-    const all = await template.compiler.compileAll(true);
+    const all = await EmailCompiler.compileAll();
     console!.log(cliTpl`Successfully compiled ${{ param: `${all.length}` }} templates`);
+    for (const el of all) {
+      console!.log(cliTpl`  * ${{ param: el }}`);
+    }
 
     if (this.watch) {
-      for await (const _ of template.watchCompile()) {
+
+      for await (const _ of EmailCompiler.watchCompile()) {
         // Iterate until done
       }
     }

package/support/cli.email_editor.ts

@@ -1,6 +1,5 @@
-import { GlobalEnvConfig, ShutdownManager } from '@travetto/base';
+import { GlobalEnvConfig } from '@travetto/base';
 import { CliCommand } from '@travetto/cli';
-import { RootIndex } from '@travetto/manifest';
 import { RootRegistry } from '@travetto/registry';
 
 import { EditorState } from './bin/editor';
@@ -11,19 +10,11 @@ import { EmailCompilationManager } from './bin/manager';
 export class EmailEditorCommand {
 
   envInit(): GlobalEnvConfig {
-    return {
-      envName: 'dev',
-      resourcePaths: [`${RootIndex.getModule('@travetto/email-compiler')!.sourcePath}/resources`]
-    };
+    return { envName: 'dev', dynamic: true };
   }
 
   async main(): Promise<void> {
     await RootRegistry.init();
-    const editor = new EditorState(await EmailCompilationManager.createInstance());
-    await editor.init();
-    if (process.send) {
-      process.on('disconnect', () => ShutdownManager.execute());
-      process.send('ready');
-    }
+    await new EditorState(await EmailCompilationManager.createInstance()).init();
   }
 }

package/support/cli.email_test.ts

@@ -4,7 +4,10 @@ import { CliCommandShape, CliCommand } from '@travetto/cli';
 import { GlobalEnvConfig } from '@travetto/base';
 
 import { EmailCompilationManager } from './bin/manager';
-import { EditorState } from './bin/editor';
+import { EditorConfig } from './bin/config';
+import { EditorSendService } from './bin/send';
+
+import { EmailCompiler } from '../src/compiler';
 
 /**
  * CLI Entry point for running the email server
@@ -19,10 +22,12 @@ export class EmailTestCommand implements CliCommandShape {
   async main(file: string, to: string): Promise<void> {
     file = path.resolve(file);
     await RootRegistry.init();
-    const template = await EmailCompilationManager.createInstance();
-    await template.compiler.compile(file, true);
-    const editor = new EditorState(await EmailCompilationManager.createInstance());
-    await editor.onConfigure({ type: 'configure' });
-    await editor.onSend({ type: 'send', file, to });
+    await EmailCompiler.compile(file, true);
+
+    const mgr = await EmailCompilationManager.createInstance();
+    const cfg = await EditorConfig.get(file);
+    const content = await mgr.resolveCompiledTemplate(file, await EditorConfig.getContext(file));
+
+    await EditorSendService.sendEmail(file, { from: cfg.from, to, ...content, });
   }
 }

package/src/resource.ts

@@ -1,111 +0,0 @@
-import { FileQueryProvider } from '@travetto/base';
-import { MessageCompilationSource, MessageCompiled } from '@travetto/email';
-import { RootIndex, path } from '@travetto/manifest';
-
-/**
- * Resource management for email templating
- */
-export class EmailCompilerResource extends FileQueryProvider {
-  static PATH_PREFIX = /.*\/resources\//;
-  static EXT = /[.]email[.][jt]sx$/;
-
-  get ext(): RegExp {
-    return EmailCompilerResource.EXT;
-  }
-
-  constructor(paths: string[] = ['@travetto/email-compiler#support/resources']) {
-    super({ paths, includeCommon: true });
-  }
-
-  buildOutputPath(file: string, suffix: string, prefix?: string): string {
-    let res = file.replace(/.*(support|src)\//, '').replace(this.ext, suffix);
-    if (prefix) {
-      res = path.join(prefix, res);
-    }
-    return res;
-  }
-
-  /**
-   * Get the different parts from the file name
-   * @returns
-   */
-  getOutputs(file: string, prefix?: string): MessageCompiled {
-    return {
-      html: this.buildOutputPath(file, '.compiled.html', prefix),
-      subject: this.buildOutputPath(file, '.compiled.subject', prefix),
-      text: this.buildOutputPath(file, '.compiled.text', prefix),
-    };
-  }
-
-  /**
-   * Is this a valid template file?
-   */
-  isTemplateFile(file: string): boolean {
-    return this.ext.test(file);
-  }
-
-  /**
-   * Get the sending email key from a template file
-   * @param file
-   */
-  async templateFileToKey(file: string): Promise<string> {
-    return this.buildOutputPath(file, '');
-  }
-
-  async loadTemplate(imp: string): Promise<MessageCompilationSource> {
-    const entry = RootIndex.getEntry(imp) ?? RootIndex.getFromImport(imp);
-    if (!entry) {
-      throw new Error();
-    }
-    const root = (await import(entry.outputFile)).default;
-    return { ...await root.wrap(), file: entry.sourceFile };
-  }
-
-  /**
-   * Grab list of all available templates
-   */
-  async findAllTemplates(): Promise<MessageCompilationSource[]> {
-    const items = RootIndex.findSupport({
-      filter: (f) => this.ext.test(f)
-    });
-    const out: Promise<MessageCompilationSource>[] = [];
-    for (const item of items) {
-      out.push(this.loadTemplate(item.import));
-    }
-    return Promise.all(out);
-  }
-
-
-  /**
-   * Run through text and match/resolve resource urls, producing tokens
-   *
-   * @param text
-   * @param patterns
-   * @returns
-   */
-  async tokenizeResources(
-    text: string,
-    patterns: RegExp[]
-  ): Promise<{
-    text: string;
-    tokens: Map<string, string>;
-    finalize: (onToken: (token: string) => string) => string;
-  }> {
-    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
-          continue;
-        }
-        await this.describe(src);
-        const token = `@@${id += 1}@@`;
-        tokens.set(token, src);
-        text = text.replace(all, `${pre}${token}`);
-      }
-    }
-    const finalize = (onToken: (token: string) => string): string => text.replace(/@@[^@]+@@/g, t => onToken(t));
-
-    return { text, tokens, finalize };
-  }
-}