@lupinum/nuxt-email 0.1.1 → 1.0.0-beta.2

package/dist/module.mjs

@@ -1,8 +1,9 @@
-import { relative, isAbsolute, sep, resolve } from 'node:path';
-import { resolveFiles, defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, addServerImports, addComponent, addServerHandler, useNitro, updateTemplates } from '@nuxt/kit';
+import { resolve, isAbsolute, relative } from 'node:path';
+import { defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, addServerImports, addComponent, addServerHandler, useNitro, updateTemplates } from '@nuxt/kit';
 import vueRollup from 'unplugin-vue/rollup';
 import { stat } from 'node:fs/promises';
 import { EMAIL_COMPONENT_NAMES } from '../dist/runtime/components/email-component-names.js';
+import { g as generateEmailRegistry, a as generateEmailTypes, d as discoverEmailTemplates } from './shared/nuxt-email.B5ux0eBv.mjs';
 
 function previewFixturePath(sourcePath) {
   return `${sourcePath.slice(0, -".vue".length)}.fixtures.ts`;
@@ -26,140 +27,34 @@ async function attachPreviewFixtures(templates) {
   }));
 }
 
-class DuplicateEmailTemplateError extends Error {
-  templateName;
-  sourcePaths;
-  constructor(templateName, sourcePaths) {
-    const sortedSourcePaths = [...sourcePaths].sort();
-    super(`Duplicate email template name "${templateName}" from: ${sortedSourcePaths.join(", ")}`);
-    this.name = "DuplicateEmailTemplateError";
-    this.templateName = templateName;
-    this.sourcePaths = sortedSourcePaths;
+function configureEmailTypeProject(tsConfig, emailDirectory, registryId, registryPath) {
+  const normalizedDirectory = emailDirectory.replaceAll("\\", "/");
+  const include = tsConfig.include ??= [];
+  const emailTypeGlob = `${normalizedDirectory}/**/*.vue`;
+  if (!include.includes(emailTypeGlob)) {
+    include.push(emailTypeGlob);
   }
-}
-class EmailTemplateDiscoveryError extends Error {
-  sourcePath;
-  constructor(sourcePath, cause) {
-    super(`Failed to discover email templates under ${sourcePath}`, { cause });
-    this.name = "EmailTemplateDiscoveryError";
-    this.sourcePath = sourcePath;
+  const exclude = tsConfig.exclude ??= [];
+  const emailComponentTypeGlob = `${normalizedDirectory}/components/**/*.vue`;
+  if (!exclude.includes(emailComponentTypeGlob)) {
+    exclude.push(emailComponentTypeGlob);
   }
+  const paths = (tsConfig.compilerOptions ??= {}).paths ??= {};
+  paths[registryId] = [registryPath];
+  return paths;
 }
-
-function compareCodePoints(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function normalizeSeparators(value) {
-  return value.split(sep).join("/").replaceAll("\\", "/");
+function previewURL(baseURL) {
+  return `${baseURL.endsWith("/") ? baseURL : `${baseURL}/`}__email`;
 }
-function templatesFromSourcePaths(emailDirectory, sourcePaths) {
-  const templates = sourcePaths.map((sourcePath) => {
-    const relativePath = normalizeSeparators(relative(emailDirectory, sourcePath));
-    if (relativePath.startsWith("../") || relativePath === ".." || isAbsolute(relativePath)) {
-      throw new EmailTemplateDiscoveryError(sourcePath, new TypeError("Template path is outside app/emails"));
+function relativeEmailPath(emailDirectory, path, roots) {
+  const candidates = isAbsolute(path) ? [path] : roots.map((root) => resolve(root, path));
+  for (const candidate of candidates) {
+    const relativePath = relative(emailDirectory, candidate).replaceAll("\\", "/");
+    if (relativePath !== ".." && !relativePath.startsWith("../") && !isAbsolute(relativePath)) {
+      return relativePath;
     }
-    return {
-      name: relativePath.slice(0, -".vue".length),
-      sourcePath: normalizeSeparators(sourcePath)
-    };
-  }).sort((left, right) => {
-    return compareCodePoints(left.name, right.name) || compareCodePoints(left.sourcePath, right.sourcePath);
-  });
-  const pathsByName = /* @__PURE__ */ new Map();
-  for (const template of templates) {
-    const paths = pathsByName.get(template.name) ?? [];
-    paths.push(template.sourcePath);
-    pathsByName.set(template.name, paths);
   }
-  const duplicate = [...pathsByName.entries()].filter(([, paths]) => paths.length > 1).sort(([left], [right]) => compareCodePoints(left, right))[0];
-  if (duplicate) {
-    throw new DuplicateEmailTemplateError(duplicate[0], duplicate[1]);
-  }
-  return templates;
 }
-async function discoverEmailTemplates(emailDirectory) {
-  let sourcePaths;
-  try {
-    sourcePaths = await resolveFiles(emailDirectory, "**/*.vue", {
-      followSymbolicLinks: false,
-      ignore: ["components/**"]
-    });
-  } catch (error) {
-    throw new EmailTemplateDiscoveryError(emailDirectory, error);
-  }
-  return templatesFromSourcePaths(emailDirectory, sourcePaths);
-}
-
-function importPath(path) {
-  return JSON.stringify(path.replaceAll("\\", "/"));
-}
-function generateEmailRegistry(templates, runtimePaths) {
-  const entries = templates.map((template) => {
-    const fixture = template.fixturePath ? `
-    fixture: () => import(${importPath(template.fixturePath)}),` : "";
-    return `  [${JSON.stringify(template.name)}]: {
-    component: () => import(${importPath(template.sourcePath)}),${fixture}
-  },`;
-  });
-  return `import { EmailRenderError } from ${importPath(runtimePaths.emailRenderError)}
-import { renderEmailComponent } from ${importPath(runtimePaths.renderEmailComponent)}
-import { UnknownEmailTemplateError } from ${importPath(runtimePaths.templateRegistryErrors)}
-
-export const emailTemplates = Object.freeze({
-${entries.join("\n")}
-})
-
-export async function renderEmail(name, props) {
-  const loader = typeof name === 'string' && Object.hasOwn(emailTemplates, name)
-    ? emailTemplates[name]
-    : undefined
-  if (!loader) {
-    throw new UnknownEmailTemplateError(String(name), Object.keys(emailTemplates))
-  }
-
-  try {
-    const templateModule = await loader.component()
-    return await renderEmailComponent(templateModule.default, props)
-  }
-  catch (error) {
-    throw new EmailRenderError(name, error instanceof EmailRenderError ? error.cause : error)
-  }
-}
-`;
-}
-function generateEmailTypes(templates, typePaths) {
-  const entries = templates.map((template) => {
-    const fixture = template.fixturePath ? `
-    fixture: () => Promise<typeof import(${importPath(template.fixturePath)})>` : "";
-    return `  ${JSON.stringify(template.name)}: {
-    component: () => Promise<typeof import(${importPath(template.sourcePath)})>${fixture}
-  }`;
-  });
-  return `export const emailTemplates: Readonly<{
-${entries.join("\n")}
-}>
-
-export type EmailTemplateName = keyof typeof emailTemplates
-type _EmailComponent = abstract new (...args: never[]) => { $props: object }
-type _DeclaredEmailProps<Component extends _EmailComponent> = Omit<
-  InstanceType<Component>['$props'],
-  keyof import('vue').PublicProps
->
-type _EmailProps<Component extends _EmailComponent> = keyof _DeclaredEmailProps<Component> extends never
-  ? Record<string, never>
-  : _DeclaredEmailProps<Component>
-
-export type EmailTemplateProps = {
-  [Name in EmailTemplateName]: _EmailProps<Awaited<ReturnType<(typeof emailTemplates)[Name]['component']>>['default']>
-}
-
-export function renderEmail<Name extends EmailTemplateName>(
-  name: Name,
-  props: NoInfer<EmailTemplateProps[Name]>,
-): Promise<import(${importPath(typePaths.renderedEmail)}).RenderedEmail>
-`;
-}
-
 const module$1 = defineNuxtModule({
   meta: {
     name: "@lupinum/nuxt-email",
@@ -176,10 +71,12 @@ const module$1 = defineNuxtModule({
     const resolver = createResolver(import.meta.url);
     const defineEmailPublicPath = await resolver.resolvePath("./runtime/define-email");
     const errorsPublicPath = await resolver.resolvePath("./runtime/errors");
-    let renderEmailComponentPath = await resolver.resolvePath("./runtime/testing");
+    let renderEmailComponentPath = await resolver.resolvePath("./runtime/render/index");
+    let testingRendererPath = await resolver.resolvePath("./runtime/testing");
     if (options.codeBlock !== void 0) {
       const { setupCodeBlock } = await import('./chunks/setup.mjs');
       renderEmailComponentPath = setupCodeBlock(options.codeBlock, resolver);
+      testingRendererPath = renderEmailComponentPath;
     }
     const emailDirectory = resolve(nuxt.options.srcDir, "emails");
     const loadTemplates = async () => {
@@ -205,6 +102,9 @@ const module$1 = defineNuxtModule({
       write: true,
       getContents: () => generateEmailTypes(templates, registryTypePaths)
     }, { nitro: true });
+    nuxt.hook("prepare:types", ({ tsConfig: tsConfig2 }) => {
+      configureEmailTypeProject(tsConfig2, emailDirectory, registryId, typeTemplate.dst);
+    });
     addServerImports([
       {
         name: "renderEmail",
@@ -220,6 +120,17 @@ const module$1 = defineNuxtModule({
       });
     }
     if (nuxt.options.dev) {
+      nuxt.hook("devtools:customTabs", (tabs) => {
+        tabs.push({
+          name: "nuxt-email",
+          title: "Nuxt Email",
+          icon: "i-lucide-mail",
+          view: {
+            type: "iframe",
+            src: previewURL(nuxt.options.app.baseURL)
+          }
+        });
+      });
       addServerHandler({
         route: "/__email",
         method: "get",
@@ -250,21 +161,21 @@ const module$1 = defineNuxtModule({
     let registryUpdates = Promise.resolve();
     nuxt.hook("builder:watch", (event, path) => {
       const structureChanged = ["add", "unlink", "addDir", "unlinkDir"].includes(event);
-      if (event !== "change" && !structureChanged) {
+      if (!structureChanged) {
         return;
       }
-      const absolutePath = isAbsolute(path) ? path : resolve(nuxt.options.srcDir, path);
-      const relativePath = relative(emailDirectory, absolutePath).replaceAll("\\", "/");
-      if (relativePath === ".." || relativePath.startsWith("../") || isAbsolute(relativePath)) {
+      const relativePath = relativeEmailPath(emailDirectory, path, [
+        nuxt.options.rootDir,
+        nuxt.options.srcDir
+      ]);
+      if (relativePath === void 0) {
         return;
       }
       const update = async () => {
-        if (structureChanged) {
-          templates = await loadTemplates();
-          await updateTemplates({
-            filter: (template) => template.filename === typeTemplate.filename
-          });
-        }
+        templates = await loadTemplates();
+        await updateTemplates({
+          filter: (template) => template.filename === typeTemplate.filename
+        });
         await reloadRegistry();
       };
       const queuedUpdate = registryUpdates.then(update, update);
@@ -275,7 +186,7 @@ const module$1 = defineNuxtModule({
     const nuxtOptions = nuxt.options;
     const nitro = nuxtOptions.nitro ??= {};
     const alias = nitro.alias ??= {};
-    alias["#nuxt-email/testing"] = renderEmailComponentPath;
+    alias["#nuxt-email/testing"] = testingRendererPath;
     alias["@lupinum/nuxt-email/define-email"] = defineEmailPublicPath;
     alias["@lupinum/nuxt-email/errors"] = errorsPublicPath;
     const externals = nitro.externals ??= {};
@@ -287,10 +198,8 @@ const module$1 = defineNuxtModule({
     }
     const typescript = nitro.typescript ??= {};
     const tsConfig = typescript.tsConfig ??= {};
-    const compilerOptions = tsConfig.compilerOptions ??= {};
-    const paths = compilerOptions.paths ??= {};
-    paths[registryId] = [typeTemplate.dst];
-    paths["#nuxt-email/testing"] = [renderEmailComponentPath];
+    const paths = configureEmailTypeProject(tsConfig, emailDirectory, registryId, typeTemplate.dst);
+    paths["#nuxt-email/testing"] = [testingRendererPath];
     nitro.rollupConfig ??= {};
     const existingPlugins = nitro.rollupConfig.plugins;
     nitro.rollupConfig.plugins = existingPlugins ? [existingPlugins, vueRollup()] : [vueRollup()];

package/dist/runtime/components/EHtml.d.ts

@@ -1,4 +1,6 @@
 import type { DefineComponent, HTMLAttributes } from 'vue';
 import type { SafeEmailAttributes } from './attributes.js';
-export type EHtmlProps = SafeEmailAttributes<HTMLAttributes>;
+export type EHtmlProps = Omit<SafeEmailAttributes<HTMLAttributes>, 'lang'> & {
+    lang: string;
+};
 export declare const EHtml: DefineComponent<EHtmlProps>;

package/dist/runtime/components/EHtml.js

@@ -3,10 +3,20 @@ import { assertSafeEmailAttributes } from "./attributes.js";
 export const EHtml = defineComponent({
   name: "EHtml",
   inheritAttrs: false,
-  setup(_props, { attrs, slots }) {
+  props: {
+    lang: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props, { attrs, slots }) {
     return () => {
       assertSafeEmailAttributes("EHtml", attrs);
-      const { dir = "ltr", lang = "en", ...attributes } = attrs;
+      const { dir = "ltr", ...attributes } = attrs;
+      const { lang } = props;
+      if (typeof lang !== "string" || lang.trim().length === 0) {
+        throw new TypeError("EHtml lang must be a non-empty string");
+      }
       return h("html", {
         ...attributes,
         dir,

package/dist/runtime/components/ELink.js

@@ -1,11 +1,6 @@
 import { defineComponent, h, inject } from "vue";
 import { resolveNestedTailwindStyle, TAILWIND_NESTED_KEY } from "../tailwind/nested.js";
 import { assertSafeEmailAttributes } from "./attributes.js";
-import { mergeEmailStyles } from "./style.js";
-const DEFAULT_LINK_STYLE = {
-  color: "#067df7",
-  textDecorationLine: "none"
-};
 export const ELink = defineComponent({
   name: "ELink",
   inheritAttrs: false,
@@ -27,7 +22,7 @@ export const ELink = defineComponent({
       return h("a", {
         ...attributes,
         href: props.href,
-        style: mergeEmailStyles(DEFAULT_LINK_STYLE, effectiveStyle),
+        ...effectiveStyle === void 0 || effectiveStyle === null ? {} : { style: effectiveStyle },
         target: attrs.target ?? "_blank"
       }, slots.default?.());
     };

package/dist/runtime/dev-preview/render.get.d.ts

@@ -1,3 +1,28 @@
 export declare const PREVIEW_RENDER_CSP: string;
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+interface SerializedPreviewError {
+    name: string;
+    message: string;
+    stack?: string;
+    templateName?: string;
+    requestedName?: string;
+    knownNames?: readonly string[];
+    cause?: SerializedPreviewError;
+}
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | {
+    bytes: any;
+    html: string;
+    text: string;
+    subject?: string;
+    name: string;
+    statusCode?: undefined;
+    statusMessage?: undefined;
+    data?: undefined;
+} | {
+    statusCode: number;
+    statusMessage: string;
+    data: {
+        templateName: string | undefined;
+        error: SerializedPreviewError;
+    };
+}>>;
 export default _default;

package/dist/runtime/dev-preview/render.get.js

@@ -45,8 +45,8 @@ function serializeError(error, seen = /* @__PURE__ */ new Set()) {
   if (error.stack) {
     serialized.stack = error.stack;
   }
-  if ("componentName" in error && typeof error.componentName === "string") {
-    serialized.componentName = error.componentName;
+  if ("templateName" in error && typeof error.templateName === "string") {
+    serialized.templateName = error.templateName;
   }
   if ("requestedName" in error && typeof error.requestedName === "string") {
     serialized.requestedName = error.requestedName;

package/dist/runtime/render/define-email.d.ts

@@ -2,12 +2,18 @@ import type { TailwindRegion } from '../tailwind/nested.js';
 /**
  * Options declared by an email template via {@link defineEmail}.
  *
- * `subject` is a zero-argument closure over the template's real `defineProps()`
- * value and returns the computed subject line.
+ * String values are constant metadata. Functions are zero-argument closures
+ * over the template's real `defineProps()` value and run synchronously after
+ * the HTML render completes.
  */
-export interface DefineEmailOptions {
-    subject: () => string;
-}
+export type EmailMetadataValue = string | (() => string);
+export type DefineEmailOptions = {
+    subject: EmailMetadataValue;
+    text?: EmailMetadataValue;
+} | {
+    subject?: EmailMetadataValue;
+    text: EmailMetadataValue;
+};
 declare const EMAIL_RENDER_BRAND: unique symbol;
 /**
  * Per-render registry created by the renderer. A fresh instance is created for
@@ -16,7 +22,10 @@ declare const EMAIL_RENDER_BRAND: unique symbol;
  */
 export interface EmailRenderContext {
     readonly [EMAIL_RENDER_BRAND]: true;
-    subject?: () => string;
+    metadata?: {
+        subject?: () => string;
+        text?: () => string;
+    };
     /**
      * Tailwind regions registered by `<ETailwind>` boundaries during render, in
      * registration order. Consumed by the post-render pass to complete each head
@@ -44,10 +53,10 @@ export declare function getEmailRenderContext(): EmailRenderContext | undefined;
  */
 export declare function runWithEmailRenderContext<T>(context: EmailRenderContext, fn: () => T): T;
 /**
- * Declare email metadata (currently the subject) from an email template's
- * `<script setup>`. The zero-argument subject closure captures the template's
- * real `defineProps()` value, so there is no separate generic that can lie about
- * the template contract. The computed value surfaces as `subject`.
+ * Declare subject and/or authored plain text from an email template's
+ * `<script setup>`. A zero-argument closure captures the template's real
+ * `defineProps()` value, so there is no separate generic that can lie about the
+ * template contract.
  *
  * Must run during an email render; calling it elsewhere throws
  * {@link DefineEmailOutsideRenderError}.

package/dist/runtime/render/define-email.js

@@ -30,11 +30,28 @@ export function defineEmail(options) {
   if (!isEmailRenderContext(context)) {
     throw new DefineEmailOutsideRenderError();
   }
-  if (context.subject !== void 0) {
+  if (context.metadata) {
     throw new DuplicateEmailDefinitionError();
   }
-  if (!options || typeof options.subject !== "function") {
-    throw new TypeError("defineEmail() subject must be a function returning a string.");
+  if (!options || typeof options !== "object") {
+    throw new TypeError("defineEmail() requires subject or text metadata.");
   }
-  context.subject = options.subject;
+  const keys = Object.keys(options);
+  const unsupportedKeys = keys.filter((key) => key !== "subject" && key !== "text");
+  if (unsupportedKeys.length > 0) {
+    throw new TypeError(`defineEmail() received unsupported metadata: ${unsupportedKeys.sort().join(", ")}.`);
+  }
+  if (options.subject === void 0 && options.text === void 0) {
+    throw new TypeError("defineEmail() requires subject or text metadata.");
+  }
+  const toFactory = (name, value) => {
+    if (value === void 0) return void 0;
+    if (typeof value === "string") return () => value;
+    if (typeof value === "function") return value;
+    throw new TypeError(`defineEmail() ${name} must be a string or a function returning a string.`);
+  };
+  context.metadata = {
+    subject: toFactory("subject", options.subject),
+    text: toFactory("text", options.text)
+  };
 }

package/dist/runtime/render/errors.d.ts

@@ -1,4 +1,4 @@
 export declare class EmailRenderError extends Error {
-    readonly componentName: string;
-    constructor(componentName: string, cause: unknown);
+    readonly templateName: string;
+    constructor(templateName: string, cause: unknown);
 }

package/dist/runtime/render/errors.js

@@ -1,8 +1,8 @@
 export class EmailRenderError extends Error {
-  componentName;
-  constructor(componentName, cause) {
-    super(`Failed to render email component ${componentName}`, { cause });
+  templateName;
+  constructor(templateName, cause) {
+    super(`Failed to render email template ${templateName}`, { cause });
     this.name = "EmailRenderError";
-    this.componentName = componentName;
+    this.templateName = templateName;
   }
 }

package/dist/runtime/render/index.d.ts

@@ -0,0 +1,6 @@
+/** Server-only production rendering of already compiled Vue components. */
+export { renderEmailComponent } from './render-email-component.js';
+export { EmailRenderError } from './errors.js';
+export { UnknownEmailTemplateError } from '../template-registry/errors.js';
+export type { EmailComponentProps, RenderedEmail } from './types.js';
+export type EmailComponents = typeof import('../components/email-component-registry').emailComponentRegistry;

package/dist/runtime/render/index.js

@@ -0,0 +1,3 @@
+export { renderEmailComponent } from "./render-email-component.js";
+export { EmailRenderError } from "./errors.js";
+export { UnknownEmailTemplateError } from "../template-registry/errors.js";

package/dist/runtime/render/render-email-component.d.ts

@@ -1,13 +1,10 @@
-import type { Component, FunctionalComponent, PublicProps } from 'vue';
+import type { Component } from 'vue';
 import type { EmailComponentRegistry } from './render-component.js';
-import type { RenderedEmail } from './types.js';
-type DeclaredComponentProps<ComponentType extends Component> = ComponentType extends abstract new (...args: infer _Arguments) => infer Instance ? Instance extends {
-    $props: infer Props;
-} ? Omit<Props, keyof PublicProps> : Record<string, unknown> : ComponentType extends FunctionalComponent<infer Props> ? Props : Record<string, unknown>;
+import type { EmailComponentProps, RenderedEmail } from './types.js';
 type RequiredPropKeys<Props> = {
     [Key in keyof Props]-?: Record<never, never> extends Pick<Props, Key> ? never : Key;
 }[keyof Props];
-type RenderEmailComponentArguments<ComponentType extends Component> = keyof DeclaredComponentProps<ComponentType> extends never ? [props?: Record<string, never>] : RequiredPropKeys<DeclaredComponentProps<ComponentType>> extends never ? [props?: DeclaredComponentProps<ComponentType>] : [props: DeclaredComponentProps<ComponentType>];
+type RenderEmailComponentArguments<ComponentType extends Component> = keyof EmailComponentProps<ComponentType> extends never ? [props?: Record<string, never>] : RequiredPropKeys<EmailComponentProps<ComponentType>> extends never ? [props?: EmailComponentProps<ComponentType>] : [props: EmailComponentProps<ComponentType>];
 export interface RenderEmailComponent {
     <ComponentType extends Component>(component: ComponentType, ...args: RenderEmailComponentArguments<ComponentType>): Promise<RenderedEmail>;
 }

package/dist/runtime/render/render-email-component.js

@@ -4,7 +4,7 @@ import { assertCompleteEmailDocument } from "./document.js";
 import { EmailRenderError } from "./errors.js";
 import { renderPlainText } from "./plain-text.js";
 import { renderComponentToHtml } from "./render-component.js";
-function componentName(component) {
+function templateName(component) {
   if (typeof component === "object" && component !== null || typeof component === "function") {
     if ("name" in component && typeof component.name === "string" && component.name.length > 0) {
       return component.name;
@@ -22,24 +22,24 @@ export function createRenderEmailComponent(componentRegistry) {
       const context = createEmailRenderContext();
       const html = await renderComponentToHtml(component, props, context, componentRegistry);
       assertCompleteEmailDocument(html);
-      const subjectFactory = context.subject;
-      if (subjectFactory === void 0) {
-        return {
-          html,
-          text: renderPlainText(html)
-        };
-      }
-      const subject = subjectFactory();
-      if (typeof subject !== "string") {
-        throw new TypeError(`defineEmail() subject must return a string; received ${typeof subject}`);
-      }
-      return {
+      const resolveMetadata = (name, factory) => {
+        if (!factory) return void 0;
+        const value = factory();
+        if (typeof value !== "string") {
+          throw new TypeError(`defineEmail() ${name} must return a string; received ${typeof value}`);
+        }
+        return value;
+      };
+      const subject = resolveMetadata("subject", context.metadata?.subject);
+      const text = resolveMetadata("text", context.metadata?.text) ?? renderPlainText(html);
+      const result = {
         html,
-        text: renderPlainText(html),
-        subject
+        text
       };
+      if (subject !== void 0) result.subject = subject;
+      return result;
     } catch (error) {
-      throw new EmailRenderError(componentName(component), error);
+      throw new EmailRenderError(templateName(component), error);
     }
   };
 }

package/dist/runtime/render/types.d.ts

@@ -1,3 +1,9 @@
+import type { FunctionalComponent, PublicProps } from 'vue';
+type VueListenerProp = `on${Capitalize<string>}`;
+type EmailAuthoringProps<Props> = string extends keyof Props ? Props : Omit<Props, keyof PublicProps | VueListenerProp>;
+export type EmailComponentProps<ComponentType> = ComponentType extends abstract new (...args: never[]) => {
+    $props: infer Props;
+} ? EmailAuthoringProps<Props> : ComponentType extends FunctionalComponent<infer Props> ? EmailAuthoringProps<Props> : never;
 export interface RenderedEmail {
     html: string;
     text: string;
@@ -7,3 +13,4 @@ export interface RenderedEmail {
      */
     subject?: string;
 }
+export {};

package/dist/runtime/tailwind/css-tree.d.ts

@@ -0,0 +1,10 @@
+import type * as CssTree from 'css-tree';
+export declare const parse: typeof CssTree.parse;
+export declare const generate: typeof CssTree.generate;
+export declare const walk: typeof CssTree.walk;
+export declare const find: typeof CssTree.find;
+export declare const clone: typeof CssTree.clone;
+export declare const List: typeof CssTree.List;
+export type List<T> = CssTree.List<T>;
+export declare const string: typeof CssTree.string;
+export type * from 'css-tree';

package/dist/runtime/tailwind/css-tree.js

@@ -0,0 +1,11 @@
+import parser from "css-tree/parser";
+import generator from "css-tree/generator";
+import walker from "css-tree/walker";
+import { clone as cloneNode, List as NodeList, string as cssString } from "css-tree/utils";
+export const parse = parser;
+export const generate = generator;
+export const walk = walker;
+export const find = walker.find;
+export const clone = cloneNode;
+export const List = NodeList;
+export const string = cssString;