best-email-builder 0.3.0 → 0.5.0

package/dist/types/engine/model.d.ts

@@ -0,0 +1,130 @@
+/** A fresh id: short, unique for the page's lifetime, `[a-z0-9]` only. */
+export function createId(): string;
+/**
+ * @param {string} tag
+ * @param {{attributes?: Record<string, string>, children?: EmailNode[], content?: string|null, id?: string}} [parts]
+ * @returns {EmailNode}
+ */
+export function createNode(tag: string, { attributes, children, content, id }?: {
+    attributes?: Record<string, string>;
+    children?: EmailNode[];
+    content?: string | null;
+    id?: string;
+}): EmailNode;
+/**
+ * Deep copy with NEW ids everywhere (duplicate, paste, insert a block twice).
+ * @param {EmailNode} node
+ * @returns {EmailNode}
+ */
+export function cloneWithNewIds(node: EmailNode): EmailNode;
+/**
+ * The node with this id and its ancestors (root first), or null.
+ * @param {EmailNode} root @param {string} id
+ * @returns {EmailNode[]|null}
+ */
+export function pathTo(root: EmailNode, id: string): EmailNode[] | null;
+/** @param {EmailNode} root @param {string|null|undefined} id */
+export function findNode(root: EmailNode, id: string | null | undefined): EmailNode | null;
+/** @param {EmailNode} root @param {string} id */
+export function parentOf(root: EmailNode, id: string): EmailNode | null;
+/**
+ * Closest node (itself included) whose tag is one of `tags`.
+ * @param {EmailNode} root @param {string} id @param {Set<string>|string[]} tags
+ */
+export function closestOfTags(root: EmailNode, id: string, tags: Set<string> | string[]): EmailNode | null;
+/** First node of a tag, depth first. @param {EmailNode} root @param {string} tag @returns {EmailNode|null} */
+export function findFirst(root: EmailNode, tag: string): EmailNode | null;
+/** Every node, depth first. @param {EmailNode} root @param {(node: EmailNode) => void} visit */
+export function walk(root: EmailNode, visit: (node: EmailNode) => void): void;
+/**
+ * The tree with the node `id` replaced by `update(node)`.
+ * @param {EmailNode} root @param {string} id @param {(node: EmailNode) => EmailNode} update
+ * @returns {EmailNode}
+ */
+export function updateNode(root: EmailNode, id: string, update: (node: EmailNode) => EmailNode): EmailNode;
+/**
+ * Sets (string) or removes (null, '') attributes.
+ * @param {EmailNode} root @param {string} id @param {Record<string, string|null|undefined>} attributes
+ */
+export function setAttributes(root: EmailNode, id: string, attributes: Record<string, string | null | undefined>): EmailNode;
+/** @param {EmailNode} root @param {string} id @param {string} content */
+export function setContent(root: EmailNode, id: string, content: string): EmailNode;
+/**
+ * Inserts nodes into `parentId` at `index` (clamped).
+ * @param {EmailNode} root @param {string} parentId @param {number} index @param {EmailNode[]} nodes
+ */
+export function insertNodes(root: EmailNode, parentId: string, index: number, nodes: EmailNode[]): EmailNode;
+/** @param {EmailNode} root @param {string} id */
+export function removeNode(root: EmailNode, id: string): EmailNode;
+/**
+ * Moves a node under `parentId` at `index`, where `index` counts the target's
+ * children BEFORE the node leaves its place (what a drop indicator shows).
+ * @param {EmailNode} root @param {string} id @param {string} parentId @param {number} index
+ */
+export function moveNode(root: EmailNode, id: string, parentId: string, index: number): EmailNode;
+/**
+ * Index of a node among its siblings, and their count.
+ * @param {EmailNode} root @param {string} id
+ */
+export function positionOf(root: EmailNode, id: string): {
+    parent: null;
+    index: number;
+    count: number;
+} | {
+    parent: EmailNode;
+    index: number;
+    count: number;
+};
+/** @param {EmailNode} root */
+export function toProject(root: EmailNode): {
+    format: number;
+    root: any;
+};
+/**
+ * Reads a stored project back into a tree. Ids are kept when they are valid
+ * and unique, replaced otherwise. Throws on anything that is not a project of
+ * this format.
+ * @param {unknown} project
+ * @returns {EmailNode}
+ */
+export function fromProject(project: unknown): EmailNode;
+/**
+ * THE EMAIL MODEL — the builder's own document, an MJML tree with ids.
+ *
+ *   { id, tag: 'mj-text', attributes: { color: '#2b3038' }, children: [], content: 'Hello' }
+ *
+ * One node per MJML element. "Ending" elements (`mj-text`, `mj-button`…)
+ * keep their inner HTML in `content`; the others hold `children`. Ids are
+ * opaque, unique within a tree, made of `[a-z0-9]` so they can live in a CSS
+ * class (the canvas finds an element by them, see `canvasMjml.js`).
+ *
+ * Every operation is PURE: it returns a new tree and never changes the one it
+ * got, sharing the untouched branches. The undo history is then just a list
+ * of trees.
+ *
+ * Dependency-free: runs in the browser, on the server and in unit tests.
+ */
+/**
+ * @typedef {{
+ *   id: string,
+ *   tag: string,
+ *   attributes: Record<string, string>,
+ *   children: EmailNode[],
+ *   content: string|null,
+ * }} EmailNode
+ */
+/** MJML elements whose inner content is HTML (MJML calls them "ending tags"). */
+export const ENDING_TAGS: Set<string>;
+/** Elements that hold a whole section's place in the body. */
+export const SECTION_TAGS: Set<string>;
+/** Elements that are never removed, moved or duplicated. */
+export const LOCKED_TAGS: Set<string>;
+/** Shape version of the stored project (`{ format, root }`). */
+export const PROJECT_FORMAT: 1;
+export type EmailNode = {
+    id: string;
+    tag: string;
+    attributes: Record<string, string>;
+    children: EmailNode[];
+    content: string | null;
+};

package/dist/types/engine/placement.d.ts

@@ -0,0 +1,69 @@
+/**
+ * @typedef {{parentId: string, index: number, wrap: boolean}} Placement
+ *   `wrap`: the content must be wrapped in a new section first.
+ */
+/**
+ * Click placement.
+ * @param {EmailNode} root
+ * @param {'content'|'layout'} kind
+ * @param {string|null} targetId  selected element, if any
+ * @returns {Placement}
+ */
+export function placementFor(root: EmailNode, kind: "content" | "layout", targetId: string | null): Placement;
+/**
+ * The body-level section holding a node (itself if it is one).
+ * @param {EmailNode} root @param {string} id @param {EmailNode} body
+ */
+export function sectionOf(root: EmailNode, id: string, body: EmailNode): import("./model.js").EmailNode | null;
+/**
+ * @typedef {{top: number, bottom: number, left: number, right: number}} Box
+ * @typedef {Placement & {line: {x: number, y: number, width: number}}} DropTarget
+ *   `line`: where the canvas draws the drop indicator (frame coordinates).
+ */
+/**
+ * Drop placement for a pointer at (x, y), in canvas frame coordinates.
+ *
+ * @param {EmailNode} root
+ * @param {{kind: 'content'|'layout', nodeId?: string|null}} dragged
+ *   `nodeId`: the element being moved (it is skipped when measuring, and
+ *   cannot be dropped into itself)
+ * @param {{x: number, y: number}} point
+ * @param {string|null} hitId  the marked element under the pointer
+ * @param {(id: string) => Box|null} boxOf  its box in the frame
+ * @returns {DropTarget|null}
+ */
+export function dropTargetFor(root: EmailNode, dragged: {
+    kind: "content" | "layout";
+    nodeId?: string | null;
+}, point: {
+    x: number;
+    y: number;
+}, hitId: string | null, boxOf: (id: string) => Box | null): DropTarget | null;
+/** @typedef {import('./model.js').EmailNode} EmailNode */
+/** Containers whose children are content blocks. */
+export const CONTENT_CONTAINERS: Set<string>;
+/**
+ * `wrap`: the content must be wrapped in a new section first.
+ */
+export type Placement = {
+    parentId: string;
+    index: number;
+    wrap: boolean;
+};
+export type Box = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+/**
+ * `line`: where the canvas draws the drop indicator (frame coordinates).
+ */
+export type DropTarget = Placement & {
+    line: {
+        x: number;
+        y: number;
+        width: number;
+    };
+};
+export type EmailNode = import("./model.js").EmailNode;

package/dist/types/engine/richText.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @param {string} html
+ * @param {Document} document  any document (to parse without running anything)
+ */
+export function cleanRichText(html: string, document: Document): string;
+/**
+ * Plain text, escaped, for a label (button, menu link).
+ * @param {string} text
+ */
+export function escapeText(text: string): string;
+/**
+ * The text of an HTML fragment (`<br>` as a space), entities decoded.
+ * @param {string} html
+ */
+export function textOfHtml(html: string): string;

package/dist/types/engine/unwrapModule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * A dynamically imported module → the value it exports by default.
+ *
+ * `mjml-browser` (the canvas compiler) is a CommonJS/UMD module. How
+ * `import()` hands such a module over depends on the bundler:
+ *
+ *   Vite, esbuild               { default: value }
+ *   webpack (Next.js), from an   { default: { __esModule: true, default: value } }
+ *   ES module package
+ *
+ * so a single `.default` once returned an object instead of the function under
+ * Next.js (0.1.1: "mjmlPlugin is not a function"). Every interop layer is peeled —
+ * a module namespace or an `__esModule` object — never the value itself.
+ *
+ * @param {any} mod
+ * @returns {any}
+ */
+export function unwrapModule(mod: any): any;
+/**
+ * A module whose export is a FUNCTION (`mjml-browser`) → that function, under
+ * any bundler. On top of `unwrapModule`, Vite's dynamic import of a CommonJS
+ * module hands over a plain object `{ ...props, default: fn }` (no module
+ * flag): since a function is expected, `default` is followed while the value
+ * is not one.
+ *
+ * @param {any} mod
+ * @returns {Function|null}
+ */
+export function functionExport(mod: any): Function | null;

package/dist/types/features/brand/BrandButton.d.ts

@@ -0,0 +1,4 @@
+export default function BrandButton({ context }: {
+    context: any;
+}): import("react").JSX.Element;
+export type Brand = import("./brand.js").Brand;

package/dist/types/features/brand/brand.d.ts

@@ -0,0 +1,108 @@
+/**
+ * A CSS color as RGB(A), or null: #rgb, #rgba, #rrggbb, #rrggbbaa, rgb(),
+ * rgba(), hsl(), hsla(), and the keywords white and black.
+ * @param {unknown} value
+ * @returns {{r: number, g: number, b: number, a: number}|null}
+ */
+export function parseColor(value: unknown): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+} | null;
+/** Hue (0-360), saturation and lightness (0-1). @param {{r: number, g: number, b: number}} color */
+export function toHsl({ r, g, b }: {
+    r: number;
+    g: number;
+    b: number;
+}): {
+    h: number;
+    s: number;
+    l: number;
+};
+/** WCAG contrast ratio of two colors (1 to 21). @param {string} a @param {string} b */
+export function contrastRatio(a: string, b: string): number;
+/** The text color that reads on `background`: white or ink. @param {string} background */
+export function readableOn(background: string): string;
+/**
+ * A color meant to be noticed (a banner, a filled button), as opposed to
+ * white, light tints, grays and near-black.
+ * @param {unknown} value
+ */
+export function isColored(value: unknown): boolean;
+/**
+ * A brand as stored and used: unknown fields dropped, colors as #rrggbb,
+ * the font one of the builder's stacks, the logo an https or site-relative
+ * image. Whatever is invalid is left out (the builder's default is used).
+ * @param {unknown} input
+ * @returns {Brand}
+ */
+export function cleanBrand(input: unknown): Brand;
+/**
+ * The sender the templates use: the brand's name and logo over the host's
+ * sender (whose postal address stays).
+ * @param {import('../templates/starter.js').StarterSender|null|undefined} sender
+ * @param {Brand|null|undefined} brand
+ */
+export function brandedSender(sender: import("../templates/starter.js").StarterSender | null | undefined, brand: Brand | null | undefined): {
+    name?: string;
+    address?: string;
+    logoUrl?: string;
+    logoWidth?: number;
+};
+/**
+ * An email in the brand's look.
+ * @param {string} mjml
+ * @param {Brand|null|undefined} brand
+ * @param {{header?: boolean, previous?: {names?: (string|undefined)[], logos?: (string|undefined)[]}}} [options]
+ *   `header`: also put the logo (or name) at the top and the name in the
+ *   footer, replacing what `previous` lists (the names and logos the email
+ *   may still show: the host's sender, the brand before, "Your company").
+ * @returns {string}
+ */
+export function applyBrand(mjml: string, brand: Brand | null | undefined, { header, previous }?: {
+    header?: boolean;
+    previous?: {
+        names?: (string | undefined)[];
+        logos?: (string | undefined)[];
+    };
+}): string;
+/**
+ * A fragment (a block about to be inserted) in the brand's look.
+ * @param {string} mjml @param {Brand|null|undefined} brand
+ */
+export function applyBrandToFragment(mjml: string, brand: Brand | null | undefined): string;
+/**
+ * A ready-made email (the starter, a gallery template) in the brand's look,
+ * its header and footer naming the brand rather than the host's sender or
+ * the "Your company" placeholder.
+ * @param {string} mjml
+ * @param {Brand|null|undefined} brand
+ * @param {{sender?: import('../templates/starter.js').StarterSender|null, t?: (key: string) => string}} [context]
+ */
+export function brandTemplate(mjml: string, brand: Brand | null | undefined, { sender, t }?: {
+    sender?: import("../templates/starter.js").StarterSender | null;
+    t?: (key: string) => string;
+}): string;
+export const MAX_LOGO_WIDTH: 240;
+export function toHex({ r, g, b }: {
+    r: number;
+    g: number;
+    b: number;
+}): string;
+export function hasBrand(brand: Brand | null | undefined): boolean;
+/**
+ * `primary`: buttons, banners, links; `heading`: headings; colors as
+ * `#rrggbb`. `font`: one of the builder's web-safe stacks (FONT_OPTIONS).
+ * `website`: where it was read from, to read it again.
+ */
+export type Brand = {
+    name?: string;
+    logoUrl?: string;
+    logoWidth?: number;
+    primary?: string;
+    heading?: string;
+    font?: string;
+    website?: string;
+};
+export type EmailNode = import("../../engine/model.js").EmailNode;

package/dist/types/features/brand/extract.d.ts

@@ -0,0 +1,61 @@
+/**
+ * The attributes of one start tag, names in lower case.
+ * @param {string} tag  `<img src="…" class=logo>`
+ * @returns {Record<string, string>}
+ */
+export function tagAttributes(tag: string): Record<string, string>;
+/**
+ * What a home page says about its brand.
+ * @param {string} html
+ * @param {string} pageUrl  the address it was read from (after redirects)
+ * @returns {PageReading}
+ */
+export function readPage(html: string, pageUrl: string): PageReading;
+/**
+ * The web-safe stack nearest to a CSS font-family.
+ * @param {string} family
+ * @returns {string|undefined}
+ */
+export function nearestFont(family: string): string | undefined;
+/**
+ * Main color, headings color and font of a site, from its CSS.
+ * @param {{css: string, themeColor?: string}} input
+ * @returns {{primary?: string, heading?: string, font?: string}}
+ */
+export function brandFromCss({ css, themeColor }: {
+    css: string;
+    themeColor?: string;
+}): {
+    primary?: string;
+    heading?: string;
+    font?: string;
+};
+/**
+ * Width and height of a PNG, GIF or JPEG, from its header; null otherwise.
+ * @param {Uint8Array} bytes
+ * @returns {{width: number, height: number}|null}
+ */
+export function imageSize(bytes: Uint8Array): {
+    width: number;
+    height: number;
+} | null;
+/**
+ * The width a logo is shown at in an email: a wordmark wider, a square mark
+ * smaller; never wider than the image itself (a blurry logo is worse than a
+ * small one). Retina images (twice the size shown) are common: halved first.
+ * @param {{width: number, height: number}} size
+ */
+export function logoWidthFor({ width, height }: {
+    width: number;
+    height: number;
+}): number;
+export type PageReading = {
+    name: string;
+    logos: {
+        url: string;
+        from: "schema" | "img" | "icon";
+    }[];
+    stylesheets: string[];
+    css: string;
+    themeColor: string;
+};

package/dist/types/features/brand/index.d.ts

@@ -0,0 +1,2 @@
+/** @type {import('../../core/EmailEditor.js').EmailBuilderFeature} */
+export const brandFeature: import("../../core/EmailEditor.js").EmailBuilderFeature;

package/dist/types/features/brand/messages.d.ts

@@ -0,0 +1,13 @@
+/**
+ * What the user is told about reading a brand from a website: why it failed
+ * (the server's answer) and what it could not find (notes under the field).
+ * English source strings, translated where they are shown.
+ */
+/**
+ * Why a website could not be read: [HTTP status, message], by
+ * BrandImportError code (src/server/brandImport.js).
+ * @type {Record<string, [number, string]>}
+ */
+export const BRAND_IMPORT_ERRORS: Record<string, [number, string]>;
+/** What could not be read, by note code. @type {Record<string, string>} */
+export const BRAND_NOTES: Record<string, string>;

package/dist/types/features/brand/useBrand.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The brand of a storage: `loaded` resolves once it is known ({} when the
+ * storage keeps none, or could not be read — the builder then uses its own look).
+ * @param {any} storage
+ * @returns {BrandEntry}
+ */
+export function brandOf(storage: any): BrandEntry;
+/**
+ * @param {any} storage
+ * @returns {{brand: Brand, setBrand: (brand: Brand) => void}}
+ *   `setBrand`: tells every screen of this storage about a brand just saved.
+ */
+export function useBrand(storage: any): {
+    brand: Brand;
+    setBrand: (brand: Brand) => void;
+};
+export type Brand = import("./brand.js").Brand;
+export type BrandEntry = {
+    value: Brand;
+    loaded: Promise<Brand>;
+    listeners: Set<(brand: Brand) => void>;
+};

package/dist/types/features/preview/PreviewButton.d.ts

@@ -2,7 +2,7 @@ export function QualityList({ quality, warnings }: {
     quality?: never[] | undefined;
     warnings?: never[] | undefined;
 }): import("react").JSX.Element;
-/** Sandboxed preview frame, desktop or mobile width. */
+/** Sandboxed preview frame, desktop or mobile width, light or dark. */
 export function EmailPreview({ html, loading, error, device, onDeviceChange, onRefresh, hint }: {
     html: any;
     loading?: boolean | undefined;

package/dist/types/features/preview/darkMode.d.ts

@@ -0,0 +1,65 @@
+/** @param {string} token @returns {Rgba|null} */
+export function parseCssColor(token: string): Rgba | null;
+/** WCAG relative luminance, 0 (black) to 1 (white). @param {Rgba} color */
+export function luminance({ r, g, b }: Rgba): number;
+/** WCAG contrast ratio, 1 to 21. @param {Rgba} a @param {Rgba} b */
+export function contrast(a: Rgba, b: Rgba): number;
+/**
+ * One color in dark mode. `surface`: a background; `text`: a text color;
+ * `line`: a border. Text and lines are decided against `background` (the
+ * repainted one behind them; the dark page by default). Unknown values
+ * (`transparent`, `inherit`…) come back as given.
+ * @param {string} token @param {'surface'|'text'|'line'} role @param {string|Rgba} [background]
+ */
+export function darkColor(token: string, role: "surface" | "text" | "line", background?: string | Rgba): string;
+/**
+ * The colors of a CSS text in dark mode: a `style` attribute's declarations,
+ * or a sheet (each rule on its own; behind it, the dark page).
+ * @param {string} css @param {string|Rgba} [background]
+ */
+export function darkCss(css: string, background?: string | Rgba): string;
+/**
+ * A compiled email as a dark-mode app would show it.
+ * @param {string} html
+ */
+export function simulateDarkMode(html: string): string;
+/**
+ * DARK MODE, simulated — an email as the mail apps that repaint it in dark
+ * mode show it (Gmail and Outlook apps, Outlook.com): light backgrounds
+ * turned dark, dark text turned light where it would no longer read,
+ * everything else left as it is.
+ *
+ *   surfaces   background colors (`background`, `bgcolor`…): a LIGHT one
+ *              becomes dark, same hue; a darker one (a brand button, an
+ *              orange banner) stays.
+ *   text       `color`, `<font color>`, `<body text>`: decided against the
+ *              background it sits on, once that one is repainted. Dark text
+ *              on what became dark turns light, same hue; dark text on a
+ *              background that stayed light enough (black on an orange
+ *              button) stays; light text stays.
+ *   lines      border and outline colors: a light one darkens like a
+ *              surface, a dark one is decided like text (a black divider on
+ *              the dark page turns light).
+ *   images     untouched: a dark logo on a transparent background disappears
+ *              here as it does in those apps — what the preview is for.
+ *
+ * Works on the compiled HTML as a string, tag by tag, keeping which
+ * background each element sits on: the colors of `style` attributes, of
+ * `bgcolor`/`color`/`text` attributes and of `<style>` sheets (where the
+ * background is not known: the dark page). Comments are left alone (Outlook's
+ * conditional blocks). No script, no DOM: the preview frame stays sandboxed.
+ * Only color values change; tags and attribute names stay as they are.
+ *
+ * Dependency-free: runs in the browser, on the server and in unit tests.
+ */
+/** The page behind the email, and its default text, in dark apps. */
+export const DARK_PAGE: "#121212";
+/**
+ * channels 0–255, alpha 0–1
+ */
+export type Rgba = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};

package/dist/types/features/variables/VariablePicker.d.ts

@@ -2,8 +2,9 @@
  * List of variables with a search field — shared by the toolbar menu and the
  * buttons next to the subject and preview text fields.
  *
- * Keyboard: type to filter, ↑/↓ to move, Enter to insert. A search with no
- * result offers to create the variable under that name.
+ * Keyboard: type to filter, ↑/↓ to move, Enter to insert, Ctrl+K (⌘K) back
+ * to the search. A search with no result offers to create the variable under
+ * that name.
  *
  * @param {{
  *   variables: import('./catalog.js').EmailVariable[],

package/dist/types/i18n/index.d.ts

@@ -12,6 +12,14 @@ export function createTranslator(messages?: Messages): Translate;
  * @returns {Translate}
  */
 export function translatorFor(locale?: string, overrides?: Messages): Translate;
+/**
+ * The dictionary of a locale among several (`'fr-FR'` finds `fr`); an empty
+ * one when there is none.
+ * @param {Record<string, Messages>|null|undefined} dictionaries
+ * @param {string} [locale]
+ * @returns {Messages}
+ */
+export function messagesOf(dictionaries: Record<string, Messages> | null | undefined, locale?: string): Messages;
 /** @typedef {Record<string, string>} Messages */
 /** @typedef {(text: string, params?: Record<string, string|number|null|undefined>) => string} Translate */
 /** Built-in locales. English is the source language: an empty dictionary. */

package/dist/types/index.d.ts

@@ -6,11 +6,13 @@ export { default as TemplateLibrary } from "./ui/library/TemplateLibrary.jsx";
 export { default as EmailStudio } from "./ui/EmailStudio.jsx";
 export { default as EmailBuilderBoundary } from "./ui/EmailBuilderBoundary.jsx";
 export { default as EmailCanvas } from "./ui/EmailCanvas.jsx";
-export { createGrapesJsAdapter } from "./adapters/grapesjs/GrapesJsAdapter.js";
 export { createRegistry } from "./core/registry.js";
+export { simulateDarkMode } from "./features/preview/darkMode.js";
 export { emailBuilderFeatures, isFeatureEnabled } from "./features/index.js";
 export { UiProvider, useUi, useT } from "./ui/context.jsx";
 export { createHttpStorage, createMemoryStorage, StorageError } from "./storage/client.js";
+export { createNativeAdapter, ENGINE_NAME, EMPTY_MJML } from "./engine/NativeAdapter.js";
+export { parseMjml, parseMjmlFragment, serializeMjml } from "./engine/mjml.js";
 export { readDocument, createDocument, serializeDocument, EmailDocumentError } from "./core/document.js";
 export { EMAIL_BUILDER_VERSION, EMAIL_DOCUMENT_SCHEMA_VERSION, EMAIL_DEVICES } from "./core/constants.js";
 export { DEFAULT_VARIABLES, CUSTOM_GROUP, defineVariables, mergeVariables, keyFromLabel, validateCustomVariable, tokenOf } from "./features/variables/catalog.js";
@@ -18,4 +20,5 @@ export { applyVariables, applyVariablesToText, usedVariables, unknownVariables }
 export { createStarterMjml, STARTER_MJML } from "./features/templates/starter.js";
 export { TEMPLATE_GALLERY, buildGallery, withPlaceholderImages } from "./features/templates/gallery.js";
 export { isAssetPath, absoluteAssetUrls, DEFAULT_ASSETS_PATH } from "./renderer/links.js";
-export { createTranslator, translatorFor, LOCALES } from "./i18n/index.js";
+export { applyBrand, cleanBrand, brandedSender } from "./features/brand/brand.js";
+export { createTranslator, translatorFor, messagesOf, LOCALES } from "./i18n/index.js";

package/dist/types/server/brand.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @typedef {import('../features/brand/brand.js').Brand} Brand
+ *
+ * @typedef {{
+ *   get: () => Promise<Brand|null>,
+ *   save: (brand: Brand & {updatedBy: string|null}) => Promise<void>,
+ * }} BrandRepository
+ */
+/**
+ * @param {{repository?: BrandRepository|null, t?: import('../i18n/index.js').Translate}} options
+ */
+export function createBrandService({ repository, t }: {
+    repository?: BrandRepository | null;
+    t?: import("../i18n/index.js").Translate;
+}): {
+    /** The brand, `{}` when none was set (or no repository). */
+    get(): Promise<import("../features/brand/brand.js").Brand>;
+    /** @param {unknown} input @param {{id?: string|number, name?: string}|null} [user] */
+    save(input: unknown, user?: {
+        id?: string | number;
+        name?: string;
+    } | null): Promise<import("../features/brand/brand.js").Brand>;
+};
+/** @returns {BrandRepository} */
+export function createMemoryBrandRepository(): BrandRepository;
+export type Brand = import("../features/brand/brand.js").Brand;
+export type BrandRepository = {
+    get: () => Promise<Brand | null>;
+    save: (brand: Brand & {
+        updatedBy: string | null;
+    }) => Promise<void>;
+};