@maizzle/framework 6.0.0-rc.8 → 6.0.0

package/dist/components/utils.ts

@@ -4,3 +4,105 @@ export function normalizeToPixels(value: string | number): string {
   }
   return value
 }
+
+const counters: Record<string, number> = {}
+
+/**
+ * Module-scoped sequential ID generator. Used by components to mint
+ * unique marker ids (e.g. `c1`, `c2`) for the post-render transformer.
+ *
+ * Must live here (not inside `<script setup>`) because Vue compiles
+ * `<script setup>` into the component's `setup()` function — any
+ * `let counter = 0` there resets per instance, causing id collisions.
+ */
+export function nextId(prefix: string): string {
+  counters[prefix] = (counters[prefix] ?? 0) + 1
+  return `${prefix}${counters[prefix]}`
+}
+
+export function hasWidthUtility(classStr: string): boolean {
+  return classStr.split(/\s+/).some((c) => {
+    const utility = c.split(':').pop() ?? ''
+    const clean = utility.replace(/^!/, '')
+    return /^(w-|max-w-|min-w-)/.test(clean)
+  })
+}
+
+export function hasWidthInStyle(styleStr: string): boolean {
+  return /(?:^|;\s*)(?:max-width|width)\s*:/i.test(styleStr)
+}
+
+export function hasHeightUtility(classStr: string): boolean {
+  return classStr.split(/\s+/).some((c) => {
+    const utility = c.split(':').pop() ?? ''
+    const clean = utility.replace(/^!/, '')
+    return /^(h-|max-h-|min-h-)/.test(clean)
+  })
+}
+
+export function hasHeightInStyle(styleStr: string): boolean {
+  return /(?:^|;\s*)(?:max-height|height)\s*:/i.test(styleStr)
+}
+
+/**
+ * Shared prop for components that emit MSO/VML fallback markup. The
+ * `null` default acts as the "unset" sentinel — `useOutlookFallback`
+ * treats `null` as inherit-from-ancestor (root default `true`),
+ * letting users override per-component without losing inheritance.
+ */
+export const outlookFallbackProp = {
+  type: Boolean,
+  default: null,
+} as const
+
+/**
+ * Default utility classes for a code-block `<pre>`. `whitespace-pre!` is
+ * forced important so Gmail's stylesheet can't reset it to `normal`, and
+ * `m-0` strips the browser's default `<pre>` margins so it isn't spaced
+ * away from its wrapper.
+ */
+export function codeBlockPreClass(bg: string): string {
+  return `font-mono bg-[${bg}] p-4 m-0 overflow-auto whitespace-pre! [word-wrap:normal] [word-break:normal] [word-spacing:normal]`
+}
+
+/**
+ * Build the email-safe table wrapper around highlighted code. Shared by the
+ * `<CodeBlock>` component and the Markdown fenced/indented code-block
+ * rules so both render identical markup: a full-width table whose
+ * cell carries the theme background, wrapping a `<pre>` styled
+ * with utility classes (not Shiki's raw inline styles).
+ */
+export function buildCodeBlock(
+  codeContent: string,
+  bg: string,
+  options: { preClass?: string; tdClass?: string; styleAttr?: string } = {},
+): string {
+  const preClass = options.preClass ?? codeBlockPreClass(bg)
+  const tdClass = options.tdClass ?? `bg-[${bg}] max-w-0 mso-padding-alt-4`
+  const styleAttr = options.styleAttr ?? ''
+
+  // `data-juice-important` tells the CSS inliner to keep `!important` on this
+  // element's inlined declarations (e.g. `white-space: pre !important`), which
+  // it strips by default. Juice removes the attribute from the output.
+  return `<table class="w-full"><tr><td class="${tdClass}"><pre class="${preClass}"${styleAttr} data-juice-important><code>${codeContent}</code></pre></td></tr></table>`
+}
+
+/**
+ * Re-wrap a Shiki (or plain markdown-it) `<pre><code>` block as a CodeBlock,
+ * pulling the inner code and the theme background out of the highlighted
+ * HTML. Falls back to a white background for unhighlighted blocks.
+ */
+export function shikiToCodeBlock(highlighted: string): string {
+  const trimmed = highlighted.trim()
+  // Read the background only from the opening <pre> tag's style, never from
+  // the code body — otherwise a `background-color:` inside the snippet (e.g. a
+  // CSS example, or any unhighlighted block) would hijack the wrapper color.
+  const preTag = trimmed.match(/^<pre[^>]*>/)?.[0] ?? ''
+  const bg = preTag.match(/background-color:\s*(#[0-9a-fA-F]+)/)?.[1] ?? '#fff'
+  const codeContent = trimmed
+    .replace(/^<pre[^>]*><code[^>]*>/, '')
+    .replace(/<\/code><\/pre>$/, '')
+
+  return buildCodeBlock(codeContent, bg)
+}
+

package/dist/composables/defineConfig.d.ts

@@ -0,0 +1,13 @@
+import { MaizzleConfig } from "../types/config.js";
+//#region src/composables/defineConfig.d.ts
+/**
+ * Define Maizzle config.
+ *
+ * In maizzle.config.ts: typed identity function, returns the config as-is
+ * In Vue SFC `<script setup>`: merges with the global config and provides
+ * the result to child components via `useConfig()`
+ */
+declare function defineConfig(data?: Partial<MaizzleConfig>): MaizzleConfig;
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=defineConfig.d.ts.map

package/dist/composables/defineConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig.d.ts","names":[],"sources":["../../src/composables/defineConfig.ts"],"mappings":";;;;;AAoBA;;;;iBAAgB,YAAA,CAAa,IAAA,GAAM,OAAA,CAAQ,aAAA,IAAsB,aAAA"}

package/dist/composables/{defineConfig.mjs → defineConfig.js}

@@ -1,8 +1,7 @@
-import { MaizzleConfigKey } from "./useConfig.mjs";
-import { RenderContextKey } from "./renderContext.mjs";
+import { MaizzleConfigKey } from "./useConfig.js";
+import { RenderContextKey } from "./renderContext.js";
 import { createDefu } from "defu";
 import { getCurrentInstance, inject, provide } from "vue";
-
 //#region src/composables/defineConfig.ts
 const merge = createDefu((obj, key, value) => {
 	if (Array.isArray(obj[key])) {
@@ -13,10 +12,9 @@ const merge = createDefu((obj, key, value) => {
 /**
 * Define Maizzle config.
 *
-* Works in both contexts:
-* - In maizzle.config.ts: typed identity function, returns the config as-is
-* - In Vue SFC <script setup>: merges with the global config and provides
-*   the result to child components via useConfig()
+* In maizzle.config.ts: typed identity function, returns the config as-is
+* In Vue SFC `<script setup>`: merges with the global config and provides
+* the result to child components via `useConfig()`
 */
 function defineConfig(data = {}) {
 	if (getCurrentInstance()) {
@@ -28,7 +26,7 @@ function defineConfig(data = {}) {
 	}
 	return data;
 }
-
 //#endregion
 export { defineConfig };
-//# sourceMappingURL=defineConfig.mjs.map
+
+//# sourceMappingURL=defineConfig.js.map

package/dist/composables/defineConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig.js","names":[],"sources":["../../src/composables/defineConfig.ts"],"sourcesContent":["import { getCurrentInstance, inject, provide } from 'vue'\nimport { createDefu } from 'defu'\nimport { MaizzleConfigKey } from './useConfig.ts'\nimport { RenderContextKey } from './renderContext.ts'\nimport type { MaizzleConfig } from '../types/index.ts'\n\nconst merge = createDefu((obj, key, value) => {\n  if (Array.isArray(obj[key])) {\n    obj[key] = value\n    return true\n  }\n})\n\n/**\n * Define Maizzle config.\n *\n * In maizzle.config.ts: typed identity function, returns the config as-is\n * In Vue SFC `<script setup>`: merges with the global config and provides\n * the result to child components via `useConfig()`\n */\nexport function defineConfig(data: Partial<MaizzleConfig> = {}): MaizzleConfig {\n  // Inside a Vue SFC — merge with global config and provide to children\n  if (getCurrentInstance()) {\n    const globalConfig = inject(MaizzleConfigKey, {} as MaizzleConfig)\n    const merged = merge(data, globalConfig) as MaizzleConfig\n\n    const ctx = inject(RenderContextKey)\n    if (ctx) ctx.sfcConfig = merged\n\n    provide(MaizzleConfigKey, merged)\n\n    return merged\n  }\n\n  // Outside Vue (maizzle.config.ts) — just return the config\n  return data as MaizzleConfig\n}\n"],"mappings":";;;;;AAMA,MAAM,QAAQ,YAAY,KAAK,KAAK,UAAU;CAC5C,IAAI,MAAM,QAAQ,IAAI,IAAI,GAAG;EAC3B,IAAI,OAAO;EACX,OAAO;CACT;AACF,CAAC;;;;;;;;AASD,SAAgB,aAAa,OAA+B,CAAC,GAAkB;CAE7E,IAAI,mBAAmB,GAAG;EAExB,MAAM,SAAS,MAAM,MADA,OAAO,kBAAkB,CAAC,CACT,CAAC;EAEvC,MAAM,MAAM,OAAO,gBAAgB;EACnC,IAAI,KAAK,IAAI,YAAY;EAEzB,QAAQ,kBAAkB,MAAM;EAEhC,OAAO;CACT;CAGA,OAAO;AACT"}

package/dist/composables/renderContext.d.ts

@@ -0,0 +1,37 @@
+import { EventMap, EventName } from "../events/index.js";
+import { MaizzleConfig } from "../types/config.js";
+import { UsePlaintextOptions } from "./usePlaintext.js";
+import { InjectionKey } from "vue";
+
+//#region src/composables/renderContext.d.ts
+interface FontRegistration {
+  family: string;
+  slug: string;
+  declaration: string;
+  url: string;
+}
+interface TailwindBlock {
+  id: string;
+  /** Optional raw CSS from the component's `#config` slot. */
+  css?: string;
+}
+interface RenderContext {
+  doctype?: string;
+  preheader?: {
+    text: string;
+    fillerCount: number;
+  };
+  sfcConfig?: MaizzleConfig;
+  sfcEventHandlers: Array<{
+    name: EventName;
+    handler: EventMap[EventName];
+  }>;
+  plaintext?: UsePlaintextOptions;
+  outputPath?: string;
+  fonts?: FontRegistration[];
+  tailwindBlocks?: TailwindBlock[];
+}
+declare const RenderContextKey: InjectionKey<RenderContext>;
+//#endregion
+export { FontRegistration, RenderContext, RenderContextKey, TailwindBlock };
+//# sourceMappingURL=renderContext.d.ts.map

package/dist/composables/renderContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderContext.d.ts","names":[],"sources":["../../src/composables/renderContext.ts"],"mappings":";;;;;;UAKiB,gBAAA;EACf,MAAA;EACA,IAAA;EACA,WAAA;EACA,GAAA;AAAA;AAAA,UAGe,aAAA;EACf,EAAA;EANA;EAQA,GAAG;AAAA;AAAA,UAGY,aAAA;EACf,OAAA;EACA,SAAA;IAAc,IAAA;IAAc,WAAA;EAAA;EAC5B,SAAA,GAAY,aAAA;EACZ,gBAAA,EAAkB,KAAA;IAAQ,IAAA,EAAM,SAAA;IAAW,OAAA,EAAS,QAAA,CAAS,SAAA;EAAA;EAC7D,SAAA,GAAY,mBAAA;EACZ,UAAA;EACA,KAAA,GAAQ,gBAAA;EACR,cAAA,GAAiB,aAAA;AAAA;AAAA,cAIN,gBAAA,EAAkB,YAAY,CAAC,aAAA"}

package/dist/composables/renderContext.js

@@ -0,0 +1,6 @@
+//#region src/composables/renderContext.ts
+const RenderContextKey = Symbol.for("maizzle.renderContext");
+//#endregion
+export { RenderContextKey };
+
+//# sourceMappingURL=renderContext.js.map

package/dist/composables/renderContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderContext.js","names":[],"sources":["../../src/composables/renderContext.ts"],"sourcesContent":["import type { InjectionKey } from 'vue'\nimport type { MaizzleConfig } from '../types/index.ts'\nimport type { EventName, EventMap } from '../events/index.ts'\nimport type { UsePlaintextOptions } from './usePlaintext.ts'\n\nexport interface FontRegistration {\n  family: string\n  slug: string\n  declaration: string\n  url: string\n}\n\nexport interface TailwindBlock {\n  id: string\n  /** Optional raw CSS from the component's `#config` slot. */\n  css?: string\n}\n\nexport interface RenderContext {\n  doctype?: string\n  preheader?: { text: string; fillerCount: number }\n  sfcConfig?: MaizzleConfig\n  sfcEventHandlers: Array<{ name: EventName; handler: EventMap[EventName] }>\n  plaintext?: UsePlaintextOptions\n  outputPath?: string\n  fonts?: FontRegistration[]\n  tailwindBlocks?: TailwindBlock[]\n}\n\n// Global symbol registry — same rationale as MaizzleConfigKey in useConfig.ts.\nexport const RenderContextKey: InjectionKey<RenderContext> = Symbol.for('maizzle.renderContext')\n"],"mappings":";AA8BA,MAAa,mBAAgD,OAAO,IAAI,uBAAuB"}

package/dist/composables/useBaseUrl.d.ts

@@ -0,0 +1,19 @@
+import { UrlConfig } from "../types/config.js";
+//#region src/composables/useBaseUrl.d.ts
+/**
+ * Set the base URL for the current email template — same as
+ * `config.url.base`, scoped to one SFC.
+ *
+ * Pass a string to prepend to all default tags/attributes, or an object
+ * for fine-grained control (which tags/attributes, style tags, etc.).
+ *
+ * Usage in SFC <script setup>:
+ * ```ts
+ * useBaseUrl('https://cdn.example.com/emails/')
+ * useBaseUrl({ url: 'https://cdn.example.com/', styleTag: true })
+ * ```
+ */
+declare function useBaseUrl(value: UrlConfig['base']): void;
+//#endregion
+export { useBaseUrl };
+//# sourceMappingURL=useBaseUrl.d.ts.map

package/dist/composables/useBaseUrl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBaseUrl.d.ts","names":[],"sources":["../../src/composables/useBaseUrl.ts"],"mappings":";;;;;AAkBA;;;;AAAmD;;;;;;iBAAnC,UAAA,CAAW,KAAwB,EAAjB,SAAS"}

package/dist/composables/useBaseUrl.js

@@ -0,0 +1,26 @@
+import { RenderContextKey } from "./renderContext.js";
+import { defu as defu$1 } from "defu";
+import { inject } from "vue";
+//#region src/composables/useBaseUrl.ts
+/**
+* Set the base URL for the current email template — same as
+* `config.url.base`, scoped to one SFC.
+*
+* Pass a string to prepend to all default tags/attributes, or an object
+* for fine-grained control (which tags/attributes, style tags, etc.).
+*
+* Usage in SFC <script setup>:
+* ```ts
+* useBaseUrl('https://cdn.example.com/emails/')
+* useBaseUrl({ url: 'https://cdn.example.com/', styleTag: true })
+* ```
+*/
+function useBaseUrl(value) {
+	const ctx = inject(RenderContextKey);
+	if (!ctx) return;
+	ctx.sfcConfig = defu$1({ url: { base: value } }, ctx.sfcConfig ?? {});
+}
+//#endregion
+export { useBaseUrl };
+
+//# sourceMappingURL=useBaseUrl.js.map

package/dist/composables/useBaseUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBaseUrl.js","names":["merge"],"sources":["../../src/composables/useBaseUrl.ts"],"sourcesContent":["import { inject } from 'vue'\nimport { defu as merge } from 'defu'\nimport { RenderContextKey } from './renderContext.ts'\nimport type { UrlConfig } from '../types/index.ts'\n\n/**\n * Set the base URL for the current email template — same as\n * `config.url.base`, scoped to one SFC.\n *\n * Pass a string to prepend to all default tags/attributes, or an object\n * for fine-grained control (which tags/attributes, style tags, etc.).\n *\n * Usage in SFC <script setup>:\n * ```ts\n * useBaseUrl('https://cdn.example.com/emails/')\n * useBaseUrl({ url: 'https://cdn.example.com/', styleTag: true })\n * ```\n */\nexport function useBaseUrl(value: UrlConfig['base']): void {\n  const ctx = inject(RenderContextKey)\n  if (!ctx) return\n  ctx.sfcConfig = merge({ url: { base: value } }, ctx.sfcConfig ?? {})\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,SAAgB,WAAW,OAAgC;CACzD,MAAM,MAAM,OAAO,gBAAgB;CACnC,IAAI,CAAC,KAAK;CACV,IAAI,YAAYA,OAAM,EAAE,KAAK,EAAE,MAAM,MAAM,EAAE,GAAG,IAAI,aAAa,CAAC,CAAC;AACrE"}

package/dist/composables/useConfig.d.ts

@@ -0,0 +1,16 @@
+import { MaizzleConfig } from "../types/config.js";
+import { InjectionKey } from "vue";
+
+//#region src/composables/useConfig.d.ts
+/**
+ * Use the global symbol registry so the key is identical across every
+ * module instance. In dev, `render()` (Node) and the SFC's auto-imported
+ * composables can resolve to two separate instances of this module; a plain
+ * `Symbol()` would differ between them, so `app.provide()` and the SFC's
+ * `inject()` would miss each other and `useConfig()` would throw.
+ */
+declare const MaizzleConfigKey: InjectionKey<MaizzleConfig>;
+declare function useConfig(): MaizzleConfig;
+//#endregion
+export { MaizzleConfigKey, useConfig };
+//# sourceMappingURL=useConfig.d.ts.map

package/dist/composables/useConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConfig.d.ts","names":[],"sources":["../../src/composables/useConfig.ts"],"mappings":";;;;;;;AAWA;;;;cAAa,gBAAA,EAAkB,YAAY,CAAC,aAAA;AAAA,iBAE5B,SAAA,IAAa,aAAa"}

package/dist/composables/useConfig.js

@@ -0,0 +1,19 @@
+import { inject } from "vue";
+//#region src/composables/useConfig.ts
+/**
+* Use the global symbol registry so the key is identical across every
+* module instance. In dev, `render()` (Node) and the SFC's auto-imported
+* composables can resolve to two separate instances of this module; a plain
+* `Symbol()` would differ between them, so `app.provide()` and the SFC's
+* `inject()` would miss each other and `useConfig()` would throw.
+*/
+const MaizzleConfigKey = Symbol.for("maizzle.config");
+function useConfig() {
+	const config = inject(MaizzleConfigKey);
+	if (!config) throw new Error("useConfig() requires the Maizzle plugin to provide config. Make sure you are using it inside a Maizzle template.");
+	return config;
+}
+//#endregion
+export { MaizzleConfigKey, useConfig };
+
+//# sourceMappingURL=useConfig.js.map

package/dist/composables/useConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConfig.js","names":[],"sources":["../../src/composables/useConfig.ts"],"sourcesContent":["import { inject } from 'vue'\nimport type { InjectionKey } from 'vue'\nimport type { MaizzleConfig } from '../types/index.ts'\n\n/**\n * Use the global symbol registry so the key is identical across every\n * module instance. In dev, `render()` (Node) and the SFC's auto-imported\n * composables can resolve to two separate instances of this module; a plain\n * `Symbol()` would differ between them, so `app.provide()` and the SFC's\n * `inject()` would miss each other and `useConfig()` would throw.\n */\nexport const MaizzleConfigKey: InjectionKey<MaizzleConfig> = Symbol.for('maizzle.config')\n\nexport function useConfig(): MaizzleConfig {\n  const config = inject(MaizzleConfigKey)\n\n  if (!config) {\n    throw new Error('useConfig() requires the Maizzle plugin to provide config. Make sure you are using it inside a Maizzle template.')\n  }\n\n  return config\n}\n"],"mappings":";;;;;;;;;AAWA,MAAa,mBAAgD,OAAO,IAAI,gBAAgB;AAExF,SAAgB,YAA2B;CACzC,MAAM,SAAS,OAAO,gBAAgB;CAEtC,IAAI,CAAC,QACH,MAAM,IAAI,MAAM,kHAAkH;CAGpI,OAAO;AACT"}

package/dist/composables/useCurrentTemplate.d.ts

@@ -0,0 +1,31 @@
+import { ParsedPath } from "node:path";
+
+//#region src/composables/useCurrentTemplate.d.ts
+/**
+ * Internal — set by the build loop before each template iteration and
+ * cleared in `finally`. Not exported from the package entrypoint.
+ */
+declare function _setCurrentTemplate(parsed: ParsedPath | undefined): void;
+/**
+ * Returns the parsed path of the template currently being processed,
+ * or `undefined` when called outside the per-template scope (e.g. from
+ * `beforeCreate` / `afterBuild`, or outside a build entirely).
+ *
+ * Usage in an SFC `<script setup>`:
+ * ```ts
+ * const file = useCurrentTemplate()
+ * console.log(file?.name) // 'welcome'
+ * ```
+ *
+ * Usage in an event handler:
+ * ```ts
+ * beforeRender() {
+ *   const file = useCurrentTemplate()
+ *   // file?.dir, file?.name, file?.ext, file?.base, file?.root
+ * }
+ * ```
+ */
+declare function useCurrentTemplate(): ParsedPath | undefined;
+//#endregion
+export { _setCurrentTemplate, useCurrentTemplate };
+//# sourceMappingURL=useCurrentTemplate.d.ts.map

package/dist/composables/useCurrentTemplate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrentTemplate.d.ts","names":[],"sources":["../../src/composables/useCurrentTemplate.ts"],"mappings":";;;;;AAmBA;;iBAAgB,mBAAA,CAAoB,MAA8B,EAAtB,UAAU;;AAAY;AAuBlE;;;;AAAgD;;;;;;;;;;;;;iBAAhC,kBAAA,IAAsB,UAAU"}

package/dist/composables/useCurrentTemplate.js

@@ -0,0 +1,42 @@
+//#region src/composables/useCurrentTemplate.ts
+/**
+* Stored on globalThis so the Vite SSR module graph (which loads this file
+* when a user SFC auto-imports useCurrentTemplate) and the Node import
+* graph (used by build.ts / serve.ts) share the same value. Two
+* module instances would otherwise hold independent `let`
+* bindings.
+*/
+const KEY = Symbol.for("maizzle.currentTemplate");
+/**
+* Internal — set by the build loop before each template iteration and
+* cleared in `finally`. Not exported from the package entrypoint.
+*/
+function _setCurrentTemplate(parsed) {
+	globalThis[KEY] = parsed;
+}
+/**
+* Returns the parsed path of the template currently being processed,
+* or `undefined` when called outside the per-template scope (e.g. from
+* `beforeCreate` / `afterBuild`, or outside a build entirely).
+*
+* Usage in an SFC `<script setup>`:
+* ```ts
+* const file = useCurrentTemplate()
+* console.log(file?.name) // 'welcome'
+* ```
+*
+* Usage in an event handler:
+* ```ts
+* beforeRender() {
+*   const file = useCurrentTemplate()
+*   // file?.dir, file?.name, file?.ext, file?.base, file?.root
+* }
+* ```
+*/
+function useCurrentTemplate() {
+	return globalThis[KEY];
+}
+//#endregion
+export { _setCurrentTemplate, useCurrentTemplate };
+
+//# sourceMappingURL=useCurrentTemplate.js.map

package/dist/composables/useCurrentTemplate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCurrentTemplate.js","names":[],"sources":["../../src/composables/useCurrentTemplate.ts"],"sourcesContent":["import type { ParsedPath } from 'node:path'\n\n/**\n * Stored on globalThis so the Vite SSR module graph (which loads this file\n * when a user SFC auto-imports useCurrentTemplate) and the Node import\n * graph (used by build.ts / serve.ts) share the same value. Two\n * module instances would otherwise hold independent `let`\n * bindings.\n */\nconst KEY = Symbol.for('maizzle.currentTemplate')\n\ninterface GlobalWithCurrentTemplate {\n  [KEY]?: ParsedPath\n}\n\n/**\n * Internal — set by the build loop before each template iteration and\n * cleared in `finally`. Not exported from the package entrypoint.\n */\nexport function _setCurrentTemplate(parsed: ParsedPath | undefined): void {\n  (globalThis as GlobalWithCurrentTemplate)[KEY] = parsed\n}\n\n/**\n * Returns the parsed path of the template currently being processed,\n * or `undefined` when called outside the per-template scope (e.g. from\n * `beforeCreate` / `afterBuild`, or outside a build entirely).\n *\n * Usage in an SFC `<script setup>`:\n * ```ts\n * const file = useCurrentTemplate()\n * console.log(file?.name) // 'welcome'\n * ```\n *\n * Usage in an event handler:\n * ```ts\n * beforeRender() {\n *   const file = useCurrentTemplate()\n *   // file?.dir, file?.name, file?.ext, file?.base, file?.root\n * }\n * ```\n */\nexport function useCurrentTemplate(): ParsedPath | undefined {\n  return (globalThis as GlobalWithCurrentTemplate)[KEY]\n}\n"],"mappings":";;;;;;;;AASA,MAAM,MAAM,OAAO,IAAI,yBAAyB;;;;;AAUhD,SAAgB,oBAAoB,QAAsC;CACxE,WAA0C,OAAO;AACnD;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,qBAA6C;CAC3D,OAAQ,WAAyC;AACnD"}

package/dist/composables/{useDoctype.d.mts → useDoctype.d.ts}

@@ -10,4 +10,4 @@
 declare function useDoctype(doctype: string): void;
 //#endregion
 export { useDoctype };
-//# sourceMappingURL=useDoctype.d.mts.map
+//# sourceMappingURL=useDoctype.d.ts.map

package/dist/composables/useDoctype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDoctype.d.ts","names":[],"sources":["../../src/composables/useDoctype.ts"],"mappings":";;AAWA;;;;AAA0C;;;iBAA1B,UAAA,CAAW,OAAe"}

package/dist/composables/{useDoctype.mjs → useDoctype.js}

@@ -1,6 +1,5 @@
-import { RenderContextKey } from "./renderContext.mjs";
+import { RenderContextKey } from "./renderContext.js";
 import { inject } from "vue";
-
 //#region src/composables/useDoctype.ts
 /**
 * Set the doctype for the current email template.
@@ -14,7 +13,7 @@ function useDoctype(doctype) {
 	const ctx = inject(RenderContextKey);
 	if (ctx) ctx.doctype = doctype;
 }
-
 //#endregion
 export { useDoctype };
-//# sourceMappingURL=useDoctype.mjs.map
+
+//# sourceMappingURL=useDoctype.js.map

package/dist/composables/useDoctype.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDoctype.js","names":[],"sources":["../../src/composables/useDoctype.ts"],"sourcesContent":["import { inject } from 'vue'\nimport { RenderContextKey } from './renderContext.ts'\n\n/**\n * Set the doctype for the current email template.\n *\n * Usage in SFC <script setup>:\n * ```ts\n * useDoctype('<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">')\n * ```\n */\nexport function useDoctype(doctype: string): void {\n  const ctx = inject(RenderContextKey)\n  if (ctx) ctx.doctype = doctype\n}\n"],"mappings":";;;;;;;;;;;AAWA,SAAgB,WAAW,SAAuB;CAChD,MAAM,MAAM,OAAO,gBAAgB;CACnC,IAAI,KAAK,IAAI,UAAU;AACzB"}

package/dist/composables/{useEvent.d.mts → useEvent.d.ts}

@@ -1,4 +1,4 @@
-import { EventMap, EventName } from "../events/index.mjs";
+import { EventMap, EventName } from "../events/index.js";
 
 //#region src/composables/useEvent.d.ts
 /**
@@ -7,11 +7,11 @@ import { EventMap, EventName } from "../events/index.mjs";
  * Usage:
  * ```ts
  * useEvent('beforeRender', ({ config, template }) => {
- *   return template.replace('foo', 'bar')
+ *   return template.source.replace('foo', 'bar')
  * })
  * ```
  */
 declare function useEvent<K extends EventName>(name: K, handler: EventMap[K]): void;
 //#endregion
 export { useEvent };
-//# sourceMappingURL=useEvent.d.mts.map
+//# sourceMappingURL=useEvent.d.ts.map

package/dist/composables/useEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEvent.d.ts","names":[],"sources":["../../src/composables/useEvent.ts"],"mappings":";;;;;AAcA;;;;;;;;iBAAgB,QAAA,WAAmB,SAAA,EAAW,IAAA,EAAM,CAAA,EAAG,OAAA,EAAS,QAAA,CAAS,CAAA"}

package/dist/composables/{useEvent.mjs → useEvent.js}

@@ -1,6 +1,5 @@
-import { RenderContextKey } from "./renderContext.mjs";
+import { RenderContextKey } from "./renderContext.js";
 import { inject } from "vue";
-
 //#region src/composables/useEvent.ts
 /**
 * Register an event handler from within an SFC's <script setup>.
@@ -8,7 +7,7 @@ import { inject } from "vue";
 * Usage:
 * ```ts
 * useEvent('beforeRender', ({ config, template }) => {
-*   return template.replace('foo', 'bar')
+*   return template.source.replace('foo', 'bar')
 * })
 * ```
 */
@@ -19,7 +18,7 @@ function useEvent(name, handler) {
 		handler
 	});
 }
-
 //#endregion
 export { useEvent };
-//# sourceMappingURL=useEvent.mjs.map
+
+//# sourceMappingURL=useEvent.js.map

package/dist/composables/useEvent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEvent.js","names":[],"sources":["../../src/composables/useEvent.ts"],"sourcesContent":["import { inject } from 'vue'\nimport { RenderContextKey } from './renderContext.ts'\nimport type { EventName, EventMap } from '../events/index.ts'\n\n/**\n * Register an event handler from within an SFC's <script setup>.\n *\n * Usage:\n * ```ts\n * useEvent('beforeRender', ({ config, template }) => {\n *   return template.source.replace('foo', 'bar')\n * })\n * ```\n */\nexport function useEvent<K extends EventName>(name: K, handler: EventMap[K]) {\n  const ctx = inject(RenderContextKey)\n  if (ctx) ctx.sfcEventHandlers.push({ name, handler })\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,SAAgB,SAA8B,MAAS,SAAsB;CAC3E,MAAM,MAAM,OAAO,gBAAgB;CACnC,IAAI,KAAK,IAAI,iBAAiB,KAAK;EAAE;EAAM;CAAQ,CAAC;AACtD"}

package/dist/composables/useFont.d.ts

@@ -0,0 +1,50 @@
+//#region src/composables/useFont.d.ts
+type FontProvider = 'google' | 'bunny';
+interface UseFontOptions {
+  /**
+   * A single font family name, e.g. `"Roboto"` or `"Open Sans"`.
+   *
+   * For fallback fonts, use the `fallback` option instead of a
+   * comma-separated list here.
+   */
+  family: string;
+  /** CSS fallback list appended to the `font-family` declaration. */
+  fallback?: string;
+  /**
+   * Font provider used to build the stylesheet URL when `url` is omitted.
+   * Bunny Fonts is a drop-in, privacy-friendly Google Fonts mirror.
+   * @default 'google'
+   */
+  provider?: FontProvider;
+  /**
+   * Stylesheet URL. When provided, used as-is for the `<link href>`.
+   * When omitted, a URL is built from `provider`, `family`, `weights`,
+   * `display` and `styles`.
+   */
+  url?: string;
+  /** Font weights to load. Ignored when `url` is provided. */
+  weights?: number[];
+  /** `font-display` value. Ignored when `url` is provided. */
+  display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+  /** Font styles to load. Ignored when `url` is provided. */
+  styles?: Array<'normal' | 'italic'>;
+}
+/**
+ * Register a font for the current email template.
+ *
+ * Builds a Google Fonts stylesheet URL from `family`/`weights`/`display`/`styles`
+ * (or uses `url` as-is). The renderer injects a `<link>` tag into `<head>`
+ * and merges `--font-{slug}` declarations into the template's existing
+ * `@import "tailwindcss"` style block so a `font-{slug}` utility class
+ * is generated. If no Tailwind import is found, falls back to a `:root`
+ * declaration so the CSS variable is still available.
+ *
+ * Usage in SFC <script setup>:
+ * ```ts
+ * useFont({ family: 'Roboto', fallback: 'Verdana, sans-serif', weights: [400, 600] })
+ * ```
+ */
+declare function useFont(options: UseFontOptions): void;
+//#endregion
+export { FontProvider, UseFontOptions, useFont };
+//# sourceMappingURL=useFont.d.ts.map

package/dist/composables/useFont.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFont.d.ts","names":[],"sources":["../../src/composables/useFont.ts"],"mappings":";KA8CY,YAAA;AAAA,UAEK,cAAA;EAFO;;;AAAA;AAExB;;EAOE,MAAA;EAoBc;EAlBd,QAAA;EAAA;;;;;EAMA,QAAA,GAAW,YAAA;EAYX;;;AAAc;AA+ChB;EArDE,GAAA;;EAEA,OAAA;EAmD6C;EAjD7C,OAAA;;EAEA,MAAA,GAAS,KAAK;AAAA;;;;;;;;;;;;;;;;iBA+CA,OAAA,CAAQ,OAAuB,EAAd,cAAc"}

package/dist/composables/useFont.js

@@ -0,0 +1,92 @@
+import { RenderContextKey } from "./renderContext.js";
+import { inject } from "vue";
+//#region src/composables/useFont.ts
+const FAMILY_CATEGORIES = {
+	"Roboto": "sans",
+	"Open Sans": "sans",
+	"Inter": "sans",
+	"Lato": "sans",
+	"Montserrat": "sans",
+	"Merriweather": "serif",
+	"Playfair Display": "serif",
+	"Lora": "serif",
+	"PT Serif": "serif",
+	"Noto Serif": "serif",
+	"Oswald": "display",
+	"Bebas Neue": "display",
+	"Anton": "display",
+	"Lobster": "display",
+	"Pacifico": "display",
+	"Dancing Script": "handwriting",
+	"Caveat": "handwriting",
+	"Shadows Into Light": "handwriting",
+	"Satisfy": "handwriting",
+	"Great Vibes": "handwriting",
+	"Roboto Mono": "mono",
+	"Source Code Pro": "mono",
+	"JetBrains Mono": "mono",
+	"Fira Code": "mono",
+	"Inconsolata": "mono"
+};
+const DEFAULT_FALLBACKS = {
+	sans: "ui-sans-serif, system-ui, -apple-system, \"Segoe UI\", sans-serif",
+	serif: "ui-serif, Georgia, Cambria, \"Times New Roman\", Times, serif",
+	mono: "ui-monospace, Menlo, Consolas, monospace",
+	display: "Impact, \"Arial Black\", system-ui, sans-serif",
+	handwriting: "\"Segoe Script\", \"Brush Script MT\", cursive"
+};
+const PROVIDER_BASE_URL = {
+	google: "https://fonts.googleapis.com/css2",
+	bunny: "https://fonts.bunny.net/css2"
+};
+function slugify(family) {
+	return family.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+function buildProviderUrl(opts) {
+	const familyParam = opts.family.trim().replace(/\s+/g, "+");
+	const weights = [...opts.weights].sort((a, b) => a - b);
+	const hasItalic = opts.styles.includes("italic");
+	const hasNormal = opts.styles.includes("normal");
+	const axis = hasItalic ? `:ital,wght@${weights.flatMap((w) => [...hasNormal ? [`0,${w}`] : [], `1,${w}`]).join(";")}` : `:wght@${weights.join(";")}`;
+	return `${PROVIDER_BASE_URL[opts.provider]}?family=${familyParam}${axis}&display=${opts.display}`;
+}
+/**
+* Register a font for the current email template.
+*
+* Builds a Google Fonts stylesheet URL from `family`/`weights`/`display`/`styles`
+* (or uses `url` as-is). The renderer injects a `<link>` tag into `<head>`
+* and merges `--font-{slug}` declarations into the template's existing
+* `@import "tailwindcss"` style block so a `font-{slug}` utility class
+* is generated. If no Tailwind import is found, falls back to a `:root`
+* declaration so the CSS variable is still available.
+*
+* Usage in SFC <script setup>:
+* ```ts
+* useFont({ family: 'Roboto', fallback: 'Verdana, sans-serif', weights: [400, 600] })
+* ```
+*/
+function useFont(options) {
+	const ctx = inject(RenderContextKey);
+	if (!ctx) return;
+	ctx.fonts = ctx.fonts ?? [];
+	if (ctx.fonts.some((f) => f.family === options.family)) return;
+	const url = options.url ?? buildProviderUrl({
+		family: options.family,
+		provider: options.provider ?? "google",
+		weights: options.weights ?? [400],
+		display: options.display ?? "swap",
+		styles: options.styles ?? ["normal"]
+	});
+	const fallback = options.fallback ?? DEFAULT_FALLBACKS[FAMILY_CATEGORIES[options.family] ?? "sans"];
+	const declaration = `${/\s/.test(options.family) ? `"${options.family}"` : options.family}, ${fallback}`;
+	ctx.fonts.push({
+		family: options.family,
+		slug: slugify(options.family),
+		declaration,
+		url
+	});
+}
+//#endregion
+export { useFont };
+
+//# sourceMappingURL=useFont.js.map