@maizzle/framework 6.0.0-8 → 6.0.0-rc.0

package/dist/components/Vml.vue

@@ -0,0 +1,89 @@
+<script lang="ts">
+import { computed, createStaticVNode } from 'vue'
+import { normalizeToPixels } from './utils.ts'
+
+export default {
+  name: 'Vml',
+  props: {
+    width: {
+      type: [String, Number],
+      default: '600px'
+    },
+    height: {
+      type: [String, Number],
+      default: null
+    },
+    type: {
+      type: String,
+      default: 'frame'
+    },
+    sizes: String,
+    origin: String,
+    position: String,
+    aspect: String,
+    color: String,
+    inset: {
+      type: String,
+      default: '0,0,0,0'
+    },
+    stroke: {
+      type: String,
+      default: 'f'
+    },
+    strokecolor: String,
+    fill: {
+      type: String,
+      default: 't'
+    },
+    fillcolor: {
+      type: String,
+      default: 'none'
+    },
+    src: {
+      type: String,
+      default: 'https://via.placeholder.com/600x400'
+    }
+  },
+  setup(props, { slots }) {
+    const before = computed(() => {
+      const width = normalizeToPixels(props.width)
+
+      const rectAttrs = [
+        `fill="${props.fillcolor ? 't' : props.fill}"`,
+        `stroke="${props.strokecolor ? 't' : props.stroke}"`,
+        `style="width: ${width};${props.height ? ` height: ${normalizeToPixels(props.height)};` : ''}"`,
+        props.strokecolor ? `strokecolor="${props.strokecolor}"` : '',
+        props.fillcolor ? `fillcolor="${props.fillcolor}"` : ''
+      ].filter(Boolean).join(' ')
+
+      const fillAttrs = [
+        `type="${props.type}"`,
+        `src="${props.src}"`,
+        props.sizes ? `sizes="${props.sizes}"` : '',
+        props.aspect ? `aspect="${props.aspect}"` : '',
+        props.origin ? `origin="${props.origin}"` : '',
+        props.position ? `position="${props.position}"` : '',
+        props.color ? `color="${props.color}"` : ''
+      ].filter(Boolean).join(' ')
+
+      return [
+        `<!--[if mso]>`,
+        `<v:rect xmlns:v="urn:schemas-microsoft-com:vml" ${rectAttrs}>`,
+        `<v:fill ${fillAttrs} />`,
+        `<v:textbox inset="${props.inset}" style="mso-fit-shape-to-text: true">`,
+        `<div><![endif]-->`
+      ].join('')
+    })
+
+    const after = computed(() => {
+      return `<!--[if mso]></div></v:textbox></v:rect><![endif]-->`
+    })
+
+    return () => [
+      createStaticVNode(before.value, 1),
+      slots.default?.(),
+      createStaticVNode(after.value, 1)
+    ]
+  }
+}
+</script>

package/dist/components/WithUrl.vue

@@ -0,0 +1,190 @@
+<script lang="ts">
+import { defineComponent, h, Fragment } from 'vue'
+import queryString from 'query-string'
+import isUrl from 'is-url-superb'
+
+const defaultTags: Record<string, string[]> = {
+  a: ['href'],
+  img: ['src', 'srcset'],
+  video: ['src', 'poster'],
+  source: ['src', 'srcset'],
+  link: ['href'],
+  script: ['src'],
+  object: ['data'],
+  embed: ['src'],
+  iframe: ['src'],
+  'v:image': ['src'],
+  'v:fill': ['src'],
+}
+
+const urlAttributes = [...new Set(Object.values(defaultTags).flat())]
+
+function isAbsoluteUrl(url: string): boolean {
+  if (!url) return true
+
+  return url.startsWith('//') || url.startsWith('#') || url.startsWith('?') || isUrl(url)
+}
+
+function processSrcset(srcset: string, baseUrl: string): string {
+  return srcset.split(',').map(entry => {
+    const parts = entry.trim().split(/\s+/)
+
+    if (parts[0] && !isAbsoluteUrl(parts[0])) {
+      parts[0] = baseUrl + parts[0]
+    }
+
+    return parts.join(' ')
+  }).join(', ')
+}
+
+// ─── Base URL helpers ────────────────────────────────────────────────────────
+
+/**
+ * Join a base URL and a relative path, normalising slashes between them so
+ * neither the user nor the template author needs to worry about trailing /
+ * on the base or leading / on the path.
+ *
+ * Examples:
+ *   joinUrl('https://example.com',  'about')     → 'https://example.com/about'
+ *   joinUrl('https://example.com/', '/about')    → 'https://example.com/about'
+ *   joinUrl('https://cdn.example.com/assets', 'image.jpg') → 'https://cdn.example.com/assets/image.jpg'
+ */
+function joinUrl(base: string, path: string): string {
+  return base.replace(/\/+$/, '') + '/' + path.replace(/^\/+/, '')
+}
+
+function applyBaseUrl(attrs: string[], props: Record<string, any> | null, baseUrl: string): Record<string, any> | null {
+  if (!props) return props
+
+  let newProps: Record<string, any> | undefined
+
+  for (const attr of attrs) {
+    const value = props[attr]
+
+    if (typeof value !== 'string' || isAbsoluteUrl(value)) continue
+
+    if (!newProps) newProps = { ...props }
+
+    newProps[attr] = attr === 'srcset'
+      ? processSrcset(value, baseUrl.replace(/\/+$/, '') + '/')
+      : joinUrl(baseUrl, value)
+  }
+
+  return newProps ?? props
+}
+
+// ─── Query parameter helpers ──────────────────────────────────────────────────
+
+function applyQueryParams(attrs: string[], props: Record<string, any> | null, params: Record<string, unknown>): Record<string, any> | null {
+  if (!props) return props
+
+  let newProps: Record<string, any> | undefined
+
+  for (const attr of attrs) {
+    const value = props[attr]
+
+    if (typeof value !== 'string' || !value) continue
+
+    const updated = queryString.stringifyUrl(
+      { url: value, query: params as queryString.StringifiableRecord },
+      { encode: false },
+    )
+
+    if (updated === value) continue
+
+    if (!newProps) newProps = { ...props }
+
+    newProps[attr] = updated
+  }
+
+  return newProps ?? props
+}
+
+// ─── VNode walker ─────────────────────────────────────────────────────────────
+
+function processVNode(vnode: any, baseUrl: string | undefined, params: Record<string, unknown> | undefined): any {
+  if (vnode == null || typeof vnode !== 'object') return vnode
+
+  if (vnode.type === Fragment) {
+    return h(
+      Fragment,
+      null,
+      Array.isArray(vnode.children)
+        ? vnode.children.map((child: any) => processVNode(child, baseUrl, params))
+        : vnode.children,
+    )
+  }
+
+  if (typeof vnode.type === 'string') {
+    const attrs = defaultTags[vnode.type]
+    let newProps = vnode.props
+
+    if (attrs) {
+      if (baseUrl) newProps = applyBaseUrl(attrs, newProps, baseUrl)
+      if (params) newProps = applyQueryParams(attrs, newProps, params)
+    }
+
+    const newChildren = Array.isArray(vnode.children)
+      ? vnode.children.map((child: any) => processVNode(child, baseUrl, params))
+      : vnode.children
+
+    return h(vnode.type, newProps, newChildren)
+  }
+
+  // Component VNode — rewrite any URL-like props before the component renders
+  if (typeof vnode.type === 'object' || typeof vnode.type === 'function') {
+    let newProps = vnode.props
+
+    if (baseUrl) newProps = applyBaseUrl(urlAttributes, newProps, baseUrl)
+    if (params) newProps = applyQueryParams(urlAttributes, newProps, params)
+
+    return h(vnode.type, newProps, vnode.children)
+  }
+
+  return vnode
+}
+
+/**
+ * Maizzle component that rewrites URL attributes in all child elements.
+ *
+ * - `base` — optional base URL prepended to all relative URLs
+ * - `parameters` — optional query string (e.g. `"utm_source=foo&bar=baz"`)
+ *   appended to all URLs
+ *
+ * @see https://maizzle.com/docs/components/with-url
+ */
+export default defineComponent({
+  name: 'WithUrl',
+
+  props: {
+    /**
+     * Base URL to prepend to all relative URLs found in child elements.
+     */
+    base: {
+      type: String,
+      default: undefined,
+    },
+
+    /**
+     * Query parameters to append to all URLs found in child elements.
+     * Provide as a query string, e.g. `"utm_source=foo&bar=baz"`.
+     */
+    parameters: {
+      type: String,
+      default: undefined,
+    },
+  },
+
+  setup(props, { slots }) {
+    return () => {
+      const params = props.parameters
+        ? queryString.parse(props.parameters, { decode: false })
+        : undefined
+
+      return (slots.default?.() ?? []).map(
+        (vnode: any) => processVNode(vnode, props.base, params),
+      )
+    }
+  },
+})
+</script>

package/dist/components/utils.d.mts

@@ -0,0 +1,5 @@
+//#region src/components/utils.d.ts
+declare function normalizeToPixels(value: string | number): string;
+//#endregion
+export { normalizeToPixels };
+//# sourceMappingURL=utils.d.mts.map

package/dist/components/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../../src/components/utils.ts"],"mappings":";iBAAgB,iBAAA,CAAkB,KAAA"}

package/dist/components/utils.mjs

@@ -0,0 +1,9 @@
+//#region src/components/utils.ts
+function normalizeToPixels(value) {
+	if (typeof value === "number" || Number.isFinite(Number(value))) return `${value}px`;
+	return value;
+}
+
+//#endregion
+export { normalizeToPixels };
+//# sourceMappingURL=utils.mjs.map

package/dist/components/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../src/components/utils.ts"],"sourcesContent":["export function normalizeToPixels(value: string | number): string {\n  if (typeof value === 'number' || Number.isFinite(Number(value))) {\n    return `${value}px`\n  }\n  return value\n}\n"],"mappings":";AAAA,SAAgB,kBAAkB,OAAgC;AAChE,KAAI,OAAO,UAAU,YAAY,OAAO,SAAS,OAAO,MAAM,CAAC,CAC7D,QAAO,GAAG,MAAM;AAElB,QAAO"}

package/dist/components/utils.ts

@@ -0,0 +1,6 @@
+export function normalizeToPixels(value: string | number): string {
+  if (typeof value === 'number' || Number.isFinite(Number(value))) {
+    return `${value}px`
+  }
+  return value
+}

package/dist/composables/defineConfig.d.mts

@@ -0,0 +1,14 @@
+import { MaizzleConfig } from "../types/config.mjs";
+//#region src/composables/defineConfig.d.ts
+/**
+ * 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()
+ */
+declare function defineConfig(data?: Partial<MaizzleConfig>): MaizzleConfig;
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=defineConfig.d.mts.map

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

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

package/dist/composables/defineConfig.mjs

@@ -0,0 +1,34 @@
+import { MaizzleConfigKey } from "./useConfig.mjs";
+import { RenderContextKey } from "./renderContext.mjs";
+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])) {
+		obj[key] = value;
+		return true;
+	}
+});
+/**
+* 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()
+*/
+function defineConfig(data = {}) {
+	if (getCurrentInstance()) {
+		const merged = merge(data, inject(MaizzleConfigKey, {}));
+		const ctx = inject(RenderContextKey);
+		if (ctx) ctx.sfcConfig = merged;
+		provide(MaizzleConfigKey, merged);
+		return merged;
+	}
+	return data;
+}
+
+//#endregion
+export { defineConfig };
+//# sourceMappingURL=defineConfig.mjs.map

package/dist/composables/defineConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineConfig.mjs","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 * Works in both contexts:\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;AAC5C,KAAI,MAAM,QAAQ,IAAI,KAAK,EAAE;AAC3B,MAAI,OAAO;AACX,SAAO;;EAET;;;;;;;;;AAUF,SAAgB,aAAa,OAA+B,EAAE,EAAiB;AAE7E,KAAI,oBAAoB,EAAE;EAExB,MAAM,SAAS,MAAM,MADA,OAAO,kBAAkB,EAAE,CAAkB,CAC1B;EAExC,MAAM,MAAM,OAAO,iBAAiB;AACpC,MAAI,IAAK,KAAI,YAAY;AAEzB,UAAQ,kBAAkB,OAAO;AAEjC,SAAO;;AAIT,QAAO"}

package/dist/composables/renderContext.d.mts

@@ -0,0 +1,19 @@
+import { MaizzleConfig } from "../types/config.mjs";
+import { EventMap, EventName } from "../events/index.mjs";
+import { UsePlaintextOptions } from "./usePlaintext.mjs";
+import { InjectionKey } from "vue";
+
+//#region src/composables/renderContext.d.ts
+interface RenderContext {
+  doctype?: string;
+  sfcConfig?: MaizzleConfig;
+  sfcEventHandlers: Array<{
+    name: EventName;
+    handler: EventMap[EventName];
+  }>;
+  plaintext?: UsePlaintextOptions;
+}
+declare const RenderContextKey: InjectionKey<RenderContext>;
+//#endregion
+export { RenderContext, RenderContextKey };
+//# sourceMappingURL=renderContext.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderContext.d.mts","names":[],"sources":["../../src/composables/renderContext.ts"],"mappings":";;;;;;UAKiB,aAAA;EACf,OAAA;EACA,SAAA,GAAY,aAAA;EACZ,gBAAA,EAAkB,KAAA;IAAQ,IAAA,EAAM,SAAA;IAAW,OAAA,EAAS,QAAA,CAAS,SAAA;EAAA;EAC7D,SAAA,GAAY,mBAAA;AAAA;AAAA,cAGD,gBAAA,EAAkB,YAAA,CAAa,aAAA"}

package/dist/composables/renderContext.mjs

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

package/dist/composables/renderContext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderContext.mjs","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 RenderContext {\n  doctype?: string\n  sfcConfig?: MaizzleConfig\n  sfcEventHandlers: Array<{ name: EventName; handler: EventMap[EventName] }>\n  plaintext?: UsePlaintextOptions\n}\n\nexport const RenderContextKey: InjectionKey<RenderContext> = Symbol('RenderContext')\n"],"mappings":";AAYA,MAAa,mBAAgD,OAAO,gBAAgB"}

package/dist/composables/useConfig.d.mts

@@ -0,0 +1,9 @@
+import { MaizzleConfig } from "../types/config.mjs";
+import { InjectionKey } from "vue";
+
+//#region src/composables/useConfig.d.ts
+declare const MaizzleConfigKey: InjectionKey<MaizzleConfig>;
+declare function useConfig(): MaizzleConfig;
+//#endregion
+export { MaizzleConfigKey, useConfig };
+//# sourceMappingURL=useConfig.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useConfig.d.mts","names":[],"sources":["../../src/composables/useConfig.ts"],"mappings":";;;;cAIa,gBAAA,EAAkB,YAAA,CAAa,aAAA;AAAA,iBAE5B,SAAA,CAAA,GAAa,aAAA"}

package/dist/composables/useConfig.mjs

@@ -0,0 +1,13 @@
+import { inject } from "vue";
+
+//#region src/composables/useConfig.ts
+const MaizzleConfigKey = Symbol("MaizzleConfig");
+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.mjs.map

package/dist/composables/useConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConfig.mjs","names":[],"sources":["../../src/composables/useConfig.ts"],"sourcesContent":["import { inject } from 'vue'\nimport type { InjectionKey } from 'vue'\nimport type { MaizzleConfig } from '../types/index.ts'\n\nexport const MaizzleConfigKey: InjectionKey<MaizzleConfig> = Symbol('MaizzleConfig')\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":";;;AAIA,MAAa,mBAAgD,OAAO,gBAAgB;AAEpF,SAAgB,YAA2B;CACzC,MAAM,SAAS,OAAO,iBAAiB;AAEvC,KAAI,CAAC,OACH,OAAM,IAAI,MAAM,mHAAmH;AAGrI,QAAO"}

package/dist/composables/useDoctype.d.mts

@@ -0,0 +1,13 @@
+//#region src/composables/useDoctype.d.ts
+/**
+ * Set the doctype for the current email template.
+ *
+ * Usage in SFC <script setup>:
+ * ```ts
+ * useDoctype('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">')
+ * ```
+ */
+declare function useDoctype(doctype: string): void;
+//#endregion
+export { useDoctype };
+//# sourceMappingURL=useDoctype.d.mts.map

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

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

package/dist/composables/useDoctype.mjs

@@ -0,0 +1,20 @@
+import { RenderContextKey } from "./renderContext.mjs";
+import { inject } from "vue";
+
+//#region src/composables/useDoctype.ts
+/**
+* Set the doctype for the current email template.
+*
+* Usage in SFC <script setup>:
+* ```ts
+* useDoctype('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">')
+* ```
+*/
+function useDoctype(doctype) {
+	const ctx = inject(RenderContextKey);
+	if (ctx) ctx.doctype = doctype;
+}
+
+//#endregion
+export { useDoctype };
+//# sourceMappingURL=useDoctype.mjs.map

package/dist/composables/useDoctype.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDoctype.mjs","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,iBAAiB;AACpC,KAAI,IAAK,KAAI,UAAU"}

package/dist/composables/useEvent.d.mts

@@ -0,0 +1,17 @@
+import { EventMap, EventName } from "../events/index.mjs";
+
+//#region src/composables/useEvent.d.ts
+/**
+ * Register an event handler from within an SFC's <script setup>.
+ *
+ * Usage:
+ * ```ts
+ * useEvent('beforeRender', ({ config, template }) => {
+ *   return template.replace('foo', 'bar')
+ * })
+ * ```
+ */
+declare function useEvent<K extends EventName>(name: K, handler: EventMap[K]): void;
+//#endregion
+export { useEvent };
+//# sourceMappingURL=useEvent.d.mts.map

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

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

package/dist/composables/useEvent.mjs

@@ -0,0 +1,25 @@
+import { RenderContextKey } from "./renderContext.mjs";
+import { inject } from "vue";
+
+//#region src/composables/useEvent.ts
+/**
+* Register an event handler from within an SFC's <script setup>.
+*
+* Usage:
+* ```ts
+* useEvent('beforeRender', ({ config, template }) => {
+*   return template.replace('foo', 'bar')
+* })
+* ```
+*/
+function useEvent(name, handler) {
+	const ctx = inject(RenderContextKey);
+	if (ctx) ctx.sfcEventHandlers.push({
+		name,
+		handler
+	});
+}
+
+//#endregion
+export { useEvent };
+//# sourceMappingURL=useEvent.mjs.map

package/dist/composables/useEvent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEvent.mjs","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.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,iBAAiB;AACpC,KAAI,IAAK,KAAI,iBAAiB,KAAK;EAAE;EAAM;EAAS,CAAC"}

package/dist/composables/usePlaintext.d.mts

@@ -0,0 +1,19 @@
+//#region src/composables/usePlaintext.d.ts
+interface UsePlaintextOptions {
+  extension?: string;
+  destination?: string;
+}
+/**
+ * Enable plaintext generation for the current email template.
+ *
+ * Usage in SFC <script setup>:
+ * ```ts
+ * usePlaintext()
+ * usePlaintext({ extension: 'text' })
+ * usePlaintext({ destination: '/custom/path' })
+ * ```
+ */
+declare function usePlaintext(options?: UsePlaintextOptions): void;
+//#endregion
+export { UsePlaintextOptions, usePlaintext };
+//# sourceMappingURL=usePlaintext.d.mts.map

package/dist/composables/usePlaintext.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlaintext.d.mts","names":[],"sources":["../../src/composables/usePlaintext.ts"],"mappings":";UAGiB,mBAAA;EACf,SAAA;EACA,WAAA;AAAA;;;AAaF;;;;;;;;iBAAgB,YAAA,CAAa,OAAA,GAAU,mBAAA"}

package/dist/composables/usePlaintext.mjs

@@ -0,0 +1,22 @@
+import { RenderContextKey } from "./renderContext.mjs";
+import { inject } from "vue";
+
+//#region src/composables/usePlaintext.ts
+/**
+* Enable plaintext generation for the current email template.
+*
+* Usage in SFC <script setup>:
+* ```ts
+* usePlaintext()
+* usePlaintext({ extension: 'text' })
+* usePlaintext({ destination: '/custom/path' })
+* ```
+*/
+function usePlaintext(options) {
+	const ctx = inject(RenderContextKey);
+	if (ctx) ctx.plaintext = options ?? {};
+}
+
+//#endregion
+export { usePlaintext };
+//# sourceMappingURL=usePlaintext.mjs.map

package/dist/composables/usePlaintext.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePlaintext.mjs","names":[],"sources":["../../src/composables/usePlaintext.ts"],"sourcesContent":["import { inject } from 'vue'\nimport { RenderContextKey } from './renderContext.ts'\n\nexport interface UsePlaintextOptions {\n  extension?: string\n  destination?: string\n}\n\n/**\n * Enable plaintext generation for the current email template.\n *\n * Usage in SFC <script setup>:\n * ```ts\n * usePlaintext()\n * usePlaintext({ extension: 'text' })\n * usePlaintext({ destination: '/custom/path' })\n * ```\n */\nexport function usePlaintext(options?: UsePlaintextOptions): void {\n  const ctx = inject(RenderContextKey)\n  if (ctx) ctx.plaintext = options ?? {}\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,SAAgB,aAAa,SAAqC;CAChE,MAAM,MAAM,OAAO,iBAAiB;AACpC,KAAI,IAAK,KAAI,YAAY,WAAW,EAAE"}

package/dist/config/defaults.d.mts

@@ -0,0 +1,6 @@
+import { MaizzleConfig } from "../types/config.mjs";
+//#region src/config/defaults.d.ts
+declare const defaults: MaizzleConfig;
+//#endregion
+export { defaults };
+//# sourceMappingURL=defaults.d.mts.map

package/dist/config/defaults.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.mts","names":[],"sources":["../../src/config/defaults.ts"],"mappings":";;cAEa,QAAA,EAAU,aAAA"}

package/dist/config/defaults.mjs

@@ -0,0 +1,28 @@
+//#region src/config/defaults.ts
+const defaults = {
+	content: ["emails/**/*.{vue,md}"],
+	output: {
+		path: "dist",
+		extension: "html"
+	},
+	static: {
+		source: ["public/**/*.*"],
+		destination: "public"
+	},
+	server: {
+		port: 3e3,
+		watch: []
+	},
+	css: {
+		safe: true,
+		preferUnitless: true,
+		resolveCalc: true,
+		resolveProps: true
+	},
+	html: { decodeEntities: true },
+	useTransformers: true
+};
+
+//#endregion
+export { defaults };
+//# sourceMappingURL=defaults.mjs.map

package/dist/config/defaults.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.mjs","names":[],"sources":["../../src/config/defaults.ts"],"sourcesContent":["import type { MaizzleConfig } from '../types/index.ts'\n\nexport const defaults: MaizzleConfig = {\n  content: ['emails/**/*.{vue,md}'],\n  output: {\n    path: 'dist',\n    extension: 'html',\n  },\n  static: {\n    source: ['public/**/*.*'],\n    destination: 'public',\n  },\n  server: {\n    port: 3000,\n    watch: [],\n  },\n  css: {\n    safe: true,\n    preferUnitless: true,\n    resolveCalc: true,\n    resolveProps: true,\n  },\n  html: {\n    decodeEntities: true,\n  },\n  useTransformers: true,\n}\n"],"mappings":";AAEA,MAAa,WAA0B;CACrC,SAAS,CAAC,uBAAuB;CACjC,QAAQ;EACN,MAAM;EACN,WAAW;EACZ;CACD,QAAQ;EACN,QAAQ,CAAC,gBAAgB;EACzB,aAAa;EACd;CACD,QAAQ;EACN,MAAM;EACN,OAAO,EAAE;EACV;CACD,KAAK;EACH,MAAM;EACN,gBAAgB;EAChB,aAAa;EACb,cAAc;EACf;CACD,MAAM,EACJ,gBAAgB,MACjB;CACD,iBAAiB;CAClB"}

package/dist/config/index.d.mts

@@ -0,0 +1,15 @@
+import { MaizzleConfig } from "../types/config.mjs";
+import { defineConfig } from "../composables/defineConfig.mjs";
+import { defaults } from "./defaults.mjs";
+
+//#region src/config/index.d.ts
+/**
+ * Resolve the Maizzle config.
+ *
+ * Always loads from the config file on disk (maizzle.config.{ts,js}),
+ * then merges the programmatic config on top, then fills in defaults.
+ */
+declare function resolveConfig(config?: Partial<MaizzleConfig> | string, cwd?: string): Promise<MaizzleConfig>;
+//#endregion
+export { defaults, defineConfig, resolveConfig };
+//# sourceMappingURL=index.d.mts.map

package/dist/config/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/config/index.ts"],"mappings":";;;;;;;;AA8BA;;;iBAAsB,aAAA,CACpB,MAAA,GAAS,OAAA,CAAQ,aAAA,YACjB,GAAA,YACC,OAAA,CAAQ,aAAA"}