@antelopejs/dms-mailing 0.6.1 → 0.7.1

package/src/data/templates-table.ts

@@ -1,6 +1,7 @@
 import {
   Controller,
   HTTPResult,
+  Parameter,
   type RequestContext,
 } from "@antelopejs/interface-api";
 import { assertValidation } from "@antelopejs/interface-api-util";
@@ -9,6 +10,7 @@ import {
   type DataControllerCallback,
   RegisterDataController,
 } from "@antelopejs/interface-data-api";
+import type { Validation } from "@antelopejs/interface-data-api/components";
 import {
   Access,
   AccessMode,
@@ -17,9 +19,17 @@ import {
   Listable,
   Mandatory,
   ModelReference,
+  ModifierKey,
   Sortable,
 } from "@antelopejs/interface-data-api/metadata";
-import { GetModel } from "@antelopejs/interface-database-decorators";
+import {
+  GetModel,
+  LocalizationModifier,
+} from "@antelopejs/interface-database-decorators";
+import {
+  LOCALIZED_TEXT_FALLBACK_LOCALE,
+  type LocalizedText,
+} from "@antelopejs/interface-dms-mailing";
 import { authenticateTenantRequest } from "@antelopejs/interface-dms/guards";
 import { getRequestTenantId } from "@antelopejs/interface-dms/request-tenant";
 import { TenantScopedModel } from "@antelopejs/interface-dms/tenant-scoped-model";
@@ -48,28 +58,35 @@ import { footerForCategory } from "../engine";
 import {
   MailingTemplate,
   SendModel,
+  type TemplateFields,
   TemplateModel,
   TemplateVersionModel,
 } from "../db";
+import {
+  CONTENT_LANGUAGE_HEADER,
+  localeOfRequest,
+  withTextIn,
+} from "../services/localized-text";
 import { findCategory, getSettings } from "../services/settings";
 import { findStarter, starterFields } from "../services/starters";
 import { refreshTemplateAttention } from "../services/template-attention";
 import {
-  assertSlugClaimed,
   blankContent,
   blankFields,
   contentFieldsOf,
   displayName,
   initializeTemplate,
-  releaseTemplateSlugs,
+  refuseTakenSlug,
 } from "../services/templates";
 import type { TemplateCategory } from "../types";
 
-import { createTemplateSchema } from "../validation/templates.schema";
+import {
+  createTemplateSchema,
+  templateDetailsSchema,
+} from "../validation/templates.schema";
 import { parseBody } from "./body";
 import { CategoryDisplay, LocaleChipsDisplay } from "./displays";
 
-const DUPLICATE_SLUG = "$dms_mailing.errors.duplicate_slug";
 const SLUG_IMMUTABLE = "$dms_mailing.errors.slug_immutable";
 const SOURCE_NOT_FOUND = "$dms_mailing.errors.template_not_found";
 const STARTER_NOT_FOUND = "$dms_mailing.errors.starter_not_found";
@@ -116,7 +133,7 @@ async function seedFields(
   tenantId: string,
   seed: TemplateSeed,
   fallbackLocale: string,
-): Promise<Partial<MailingTemplate>> {
+): Promise<TemplateFields> {
   const source = await resolveSource(tenantId, seed.sourceTemplateId);
   if (source) return contentFieldsOf(source);
   if (!seed.starterId) {
@@ -144,23 +161,43 @@ function assertKnownCategory(
   throw new HTTPResult(HTTP_UNPROCESSABLE, UNKNOWN_CATEGORY);
 }
 
-/** The creation's seed, and the body to store: slug and name trimmed. */
-function parseCreation(body: Buffer | string) {
-  const raw = parseBody(body);
+/** The row `new` answers since interface-data-api 0.3: its key and fields. */
+interface CreatedRow {
+  _id: string;
+  [field: string]: unknown;
+}
+
+/**
+ * The creation's seed, and the body to store: slug trimmed, and the name
+ * typed in the reader's language as every language of the localized field,
+ * the fallback one included until someone translates it. A body a guard
+ * already parsed arrives as an object.
+ */
+function parseCreation(body: Validation.WrittenBody, locale: string) {
+  const raw = Buffer.isBuffer(body) ? parseBody(body) : body;
   const seed = assertValidation(
     raw,
     (value) => createTemplateSchema.parse(value),
     () => INVALID_TEMPLATE,
     HTTP_BAD_REQUEST,
   );
-  const normalized = JSON.stringify({
+  // Handed as an object: interface-data-api 0.3 refuses a JSON string.
+  const normalized = {
     ...raw,
     slug: seed.slug,
-    name: seed.name,
-  });
+    name: withTextIn(undefined, locale, seed.name),
+  };
   return { seed, normalized };
 }
 
+/** What the data API locks a localized field with: the controller's key. */
+interface LocalizedController {
+  language: string;
+}
+
+/** The key that writes every language of a localized field at once. */
+const ALL_LANGUAGES = "*";
+
 function withSeeding(base: DataControllerCallback): DataControllerCallback {
   return {
     ...base,
@@ -168,30 +205,24 @@ function withSeeding(base: DataControllerCallback): DataControllerCallback {
       this: unknown,
       ctx: RequestContext,
       params: unknown,
-      body: Buffer | string,
+      body: Validation.WrittenBody,
       ...rest: unknown[]
     ) {
-      const { seed, normalized } = parseCreation(body);
+      const { seed, normalized } = parseCreation(body, localeOfRequest(ctx));
       const tenantId = getRequestTenantId(ctx);
-      const model = GetModel(TemplateModel, tenantId);
-      if (await model.getBySlug(seed.slug)) {
-        throw new HTTPResult(HTTP_CONFLICT, DUPLICATE_SLUG);
-      }
       const settings = await getSettings(tenantId);
       assertKnownCategory(settings.categories, seed.category);
       const fields = await seedFields(tenantId, seed, settings.fallbackLocale);
-      const ids = (await base.func.call(
-        this,
-        ctx,
-        params,
-        normalized,
-        ...rest,
-      )) as string[];
-      const templateId = ids[0] as string;
-      await assertSlugClaimed(tenantId, seed.slug, templateId);
+      // The module's creation dialogs send one typed name; the stored name
+      // holds every language, written at once.
+      (this as LocalizedController).language = ALL_LANGUAGES;
+      const created = (await refuseTakenSlug(
+        base.func.call(this, ctx, params, normalized, ...rest),
+      )) as CreatedRow;
+      const templateId = created._id;
       const user = await authenticateTenantRequest(ctx);
       await initializeTemplate(tenantId, templateId, displayName(user), fields);
-      return ids;
+      return created;
     },
   };
 }
@@ -249,7 +280,6 @@ export function afterDelete(tenantId: string, ids: string[]): AfterWrite {
     await Promise.all(
       ids.map((id) => versions.getAll(id, "templateId").delete().run()),
     );
-    await releaseTemplateSlugs(tenantId, ids);
     await refreshTemplateAttention(tenantId);
   };
 }
@@ -266,21 +296,78 @@ export async function assertEditable(
 ): Promise<void> {
   if (body.slug !== undefined && body.slug !== current.slug)
     throw new HTTPResult(HTTP_CONFLICT, SLUG_IMMUTABLE);
-  if (typeof body.name === "string" && !body.name.trim())
+  if (body.name !== undefined && isBlankName(body.name))
     throw new HTTPResult(HTTP_BAD_REQUEST, BLANK_NAME);
   const { categories } = await getSettings(tenantId);
   assertKnownCategory(categories, body.category);
 }
 
-/** Stores an edited name trimmed, once the edit is written. */
+/**
+ * Saves what the module's drawer and editor change: the name, typed in the
+ * reader's language (its other languages kept), and the category.
+ */
+export async function saveDetails(
+  ctx: RequestContext,
+  template: MailingTemplate,
+  body: unknown,
+  author: string,
+): Promise<void> {
+  const details = assertValidation(
+    body,
+    (value) => templateDetailsSchema.parse(value),
+    () => INVALID_TEMPLATE,
+  );
+  const tenantId = getRequestTenantId(ctx);
+  await assertEditable(tenantId, details, template);
+  const names = TemplateModel.namesOf(template);
+  await GetModel(TemplateModel, tenantId).updateFields(template._id, {
+    name: withTextIn(names, localeOfRequest(ctx), details.name),
+    ...(details.category !== undefined && {
+      category: details.category ?? "",
+    }),
+    updatedBy: author,
+  });
+}
+
+/**
+ * Whether an edited name holds no text: the text of the reader's language,
+ * or, from a form editing every language, all of them.
+ */
+function isBlankName(name: unknown): boolean {
+  const texts = typeof name === "object" && name ? Object.values(name) : [name];
+  return !texts.some((text) => typeof text === "string" && text.trim());
+}
+
+/** The names trimmed, blank ones left out, the fallback language filled. */
+function tidyNames(names: LocalizedText, locale: string): LocalizedText {
+  const tidy = Object.fromEntries(
+    Object.entries(names)
+      .map(([code, text]) => [code, text.trim()] as const)
+      .filter(([, text]) => text),
+  );
+  if (tidy[LOCALIZED_TEXT_FALLBACK_LOCALE]) return tidy;
+  const [first = ""] = Object.values(tidy);
+  return { ...tidy, [LOCALIZED_TEXT_FALLBACK_LOCALE]: tidy[locale] ?? first };
+}
+
+/**
+ * Once an edit of the name is written, stores it trimmed, and gives the
+ * fallback language a name when it has none, so every reader sees one.
+ */
 export function afterEdit(
   model: TemplateModel,
   id: string,
   name: unknown,
+  locale: string,
 ): AfterWrite | undefined {
-  if (typeof name !== "string" || name === name.trim()) return undefined;
+  if (name === undefined) return undefined;
   return async () => {
-    await model.update(id, { name: name.trim() });
+    const template = await model.get(id);
+    if (!template) return;
+    const names = TemplateModel.namesOf(template);
+    const tidy = tidyNames(names, locale);
+    if (JSON.stringify(tidy) !== JSON.stringify(names))
+      await model.updateFields(id, { name: tidy });
   };
 }
 
@@ -306,6 +393,11 @@ export class TemplatesTableAPI extends DataController(
   @TenantScopedModel(SendModel)
   declare sends: SendModel;
 
+  /** The language names are read, searched, sorted and written in. */
+  @Parameter(CONTENT_LANGUAGE_HEADER, "header")
+  @ModifierKey(LocalizationModifier)
+  declare language: string;
+
   @Select()
   @Listable()
   @Exported()

package/src/db/models/index.ts

@@ -2,7 +2,6 @@ export * from "./send-events.model";
 export * from "./sends.model";
 export * from "./settings.model";
 export * from "./suppressions.model";
-export * from "./template-slugs.model";
 export * from "./template-versions.model";
 export * from "./templates.model";
 export * from "./webhook-status.model";

package/src/db/models/send-events.model.ts

@@ -1,3 +1,4 @@
+import { IsDuplicateKeyError } from "@antelopejs/interface-database";
 import { BasicDataModel } from "@antelopejs/interface-database-decorators";
 import { MAILING_SEND_EVENTS_TABLE_NAME, MailingSendEvent } from "../tables";
 import { SendModel } from "./sends.model";
@@ -28,11 +29,10 @@ export class SendEventModel extends BasicDataModel(
    * the same import already did.
    */
   async insertImported(event: MailingSendEvent): Promise<void> {
-    if (await this.get(event._id)) return;
     try {
       await this.insert(event);
     } catch (error) {
-      if (!(await this.get(event._id))) throw error;
+      if (!IsDuplicateKeyError(error)) throw error;
     }
   }
 

package/src/db/models/sends.model.ts

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { BasicDataModel } from "@antelopejs/interface-database-decorators";
-import type {
-  AtomicMutationOutcome,
-  ValueProxy,
+import {
+  type AtomicMutationOutcome,
+  IsDuplicateKeyError,
+  type ValueProxy,
 } from "@antelopejs/interface-database";
 import { isResolvedStage, stageOf } from "../../types";
 import { MAILING_SENDS_TABLE_NAME, MailingSend } from "../tables";
@@ -89,17 +90,15 @@ export class SendModel extends BasicDataModel(
   }
 
   /**
-   * Writes an imported send under its own id; false when that id is already
-   * taken, by an earlier run of the same import. Probed by state like the
-   * slug claims, since the database exposes no typed conflict error.
+   * Writes an imported send under its own id; false when an earlier run of
+   * the same import already wrote it (its id is derived from the import's).
    */
   async insertImported(send: ImportedSendRow): Promise<boolean> {
-    if (await this.get(send._id)) return false;
     try {
       await this.table.insert({ ...send, revision: randomUUID() }).run();
       return true;
     } catch (error) {
-      if (await this.get(send._id)) return false;
+      if (IsDuplicateKeyError(error)) return false;
       throw error;
     }
   }

package/src/db/models/templates.model.ts

@@ -1,7 +1,10 @@
 import { randomUUID } from "node:crypto";
-import { BasicDataModel } from "@antelopejs/interface-database-decorators";
+import {
+  BasicDataModel,
+  triggerEvent,
+} from "@antelopejs/interface-database-decorators";
+import type { LocalizedText } from "@antelopejs/interface-dms-mailing";
 import { MAILING_TEMPLATES_TABLE_NAME, MailingTemplate } from "../tables";
-import { TemplateSlugModel } from "./template-slugs.model";
 
 /** The attention fields of a template, as the refresh writes them. */
 export type TemplateAttentionFields = Pick<
@@ -9,22 +12,76 @@ export type TemplateAttentionFields = Pick<
   "attention" | "needsAttention"
 >;
 
+const isLocalizedText = (value: unknown): value is LocalizedText =>
+  typeof value === "object" &&
+  value !== null &&
+  Object.values(value).every((text) => typeof text === "string");
+
+/** Where a row keeps its modifier-held fields, the localized name among them. */
+const MODIFIER_CONTAINER = "_internal";
+
+/**
+ * Template fields as code writes them: the name holds every language
+ * (`{ en: "Welcome", fr: "Bienvenue" }`).
+ */
+export type TemplateFields = Omit<Partial<MailingTemplate>, "name"> & {
+  name?: LocalizedText;
+};
+
 export class TemplateModel extends BasicDataModel(
   MailingTemplate,
   MAILING_TEMPLATES_TABLE_NAME,
 ) {
+  /** The row of `fields`, its name written in every language it holds. */
+  static fromFields(fields: TemplateFields): MailingTemplate {
+    return TemplateModel.fromPlainData(fields).localize("*", ["name"]);
+  }
+
+  /** The names of `template`, one per language. */
+  static namesOf(template: MailingTemplate): LocalizedText {
+    // Unlocked with "*", the localized field holds the whole per-language record.
+    const names: unknown = template.localize("*", ["name"]).name;
+    return isLocalizedText(names) ? names : {};
+  }
+
+  /** The name of `template` in `locale`, else in the fallback language. */
+  static nameIn(template: MailingTemplate, locale: string): string {
+    return template.localize(locale, ["name"]).name ?? "";
+  }
+
+  /** Inserts a template whose name holds every language. */
+  insertFields(fields: TemplateFields) {
+    return this.insert(TemplateModel.fromFields(fields));
+  }
+
+  /**
+   * Updates a template, a name given holding every language. Every write of
+   * a template goes through here rather than `update`: an update event leaves
+   * the row's modifier container (`_internal`, where the localized name
+   * lives) empty when the patch has no name, and the database merges a row
+   * shallowly, so that empty container would wipe the stored name.
+   */
+  updateFields(id: string, fields: TemplateFields): Promise<number> {
+    const row = TemplateModel.fromFields(fields);
+    triggerEvent(row, "update");
+    const stored = TemplateModel.toDatabase(row);
+    if (fields.name === undefined) delete stored[MODIFIER_CONTAINER];
+    return this.table.get(id).update(stored).run();
+  }
+
   /** Publishes only over the exact semantic revision that was inspected. */
   async publishIfCurrent(
     template: MailingTemplate,
-    patch: Partial<MailingTemplate>,
+    patch: TemplateFields,
   ): Promise<boolean> {
+    const stored = TemplateModel.toDatabase(TemplateModel.fromFields(patch));
     const outcome = await this.table
       .atomicMutation(template._id, {
         type: "update",
         revisionField: "revision",
         expectedRevision: template.revision ?? { kind: "missing" },
         nextRevision: randomUUID(),
-        patch: { ...patch, updatedAt: new Date() },
+        patch: { ...stored, updatedAt: new Date() },
       })
       .run();
     if (outcome === "unknown")
@@ -32,19 +89,10 @@ export class TemplateModel extends BasicDataModel(
     return outcome === "applied";
   }
 
+  /** The template holding `slug`: the unique index keeps it to one. */
   async getBySlug(slug: string): Promise<MailingTemplate | undefined> {
-    const rows = await this.getBy("slug", slug);
-    // A losing creation can still be cleaning up (or its process can crash).
-    // Senders must see the claimed template, not an earlier draft candidate.
-    if (rows.length > 1) {
-      const claims = await new TemplateSlugModel(this.database).getBy(
-        "templateId",
-        ...rows.map((row) => row._id),
-      );
-      const claim = claims.find((candidate) => candidate.slug === slug);
-      if (claim) return rows.find((row) => row._id === claim.templateId);
-    }
-    return rows[0];
+    const [template] = await this.getBy("slug", slug);
+    return template;
   }
 
   /**

package/src/db/tables/index.ts

@@ -2,7 +2,6 @@ export * from "./send-events.table";
 export * from "./sends.table";
 export * from "./settings.table";
 export * from "./suppressions.table";
-export * from "./template-slugs.table";
 export * from "./template-versions.table";
 export * from "./templates.table";
 export * from "./webhook-status.table";

package/src/db/tables/settings.table.ts

@@ -46,12 +46,4 @@ export class MailingSettings extends Table {
 
   @Field("string")
   declare webhookSecret: string;
-
-  /**
-   * JSON-serialized fingerprint of each category `DeclareTemplateCategory`
-   * applied, by its id: what tells a category untouched since from one a
-   * user relabelled or removed.
-   */
-  @Field("string")
-  declare json_declared_categories?: string;
 }

package/src/db/tables/templates.table.ts

@@ -4,18 +4,21 @@ import {
   CreationTime,
   Field,
   Index,
+  LocalizationModifier,
+  Localized,
   Modifier,
   RegisterTable,
   Table,
   UpdateTime,
 } from "@antelopejs/interface-database-decorators";
 import { TENANT_SCHEMA_NAME } from "@antelopejs/interface-dms/constants";
+import { LOCALIZED_TEXT_FALLBACK_LOCALE } from "@antelopejs/interface-dms-mailing";
 import type { TemplateStatus } from "../../types";
 
 export const MAILING_TEMPLATES_TABLE_NAME = "mailing_templates";
 
 @RegisterTable(MAILING_TEMPLATES_TABLE_NAME, TENANT_SCHEMA_NAME)
-export class MailingTemplate extends Table {
+export class MailingTemplate extends Table.with(LocalizationModifier) {
   @Field("string")
   declare _id: string;
 
@@ -28,10 +31,17 @@ export class MailingTemplate extends Table {
   @Field("date")
   declare updatedAt: Date;
 
-  @Index()
+  /** What sends name the template by: one template per slug in a tenant. */
+  @Index({ unique: true })
   @Field("string")
   declare slug: string;
 
+  /**
+   * One name per language (`{ en: "Welcome", fr: "Bienvenue" }`): read it
+   * after `template.localize(locale, ["name"])`, write every language at
+   * once through `localize("*")`.
+   */
+  @Localized({ fallbackLocale: LOCALIZED_TEXT_FALLBACK_LOCALE })
   @Field("string")
   declare name: string;
 
@@ -132,25 +142,10 @@ export class MailingTemplate extends Table {
   @Field("date")
   declare unpublishedAt?: Date;
 
-  /**
-   * Fingerprint of the last declaration `DeclareTemplate` applied; blank for
-   * a template made in the dashboard. A template still matching it is
-   * untouched since, and the next declaration may refresh it.
-   */
-  @Field("string")
-  declare declaredHash?: string;
-
   /** Every semantic edit invalidates a publication's optimistic snapshot. */
   @Field("string")
   declare revision?: string;
 
-  /** An unmodified declaration seed can be completed after a crashed creator. */
-  @Field("string")
-  declare declarationSeedRevision?: string;
-
-  @Field("string")
-  declare pendingDeclaredHash?: string;
-
   /**
    * Complete latest version row, committed atomically with its content. Its
    * history row can be recovered after an interrupted publication.

package/src/engine/formats.ts

@@ -0,0 +1,124 @@
+import type { VariableDefinition } from "../types";
+
+/**
+ * An amount in the minor unit of its currency (cents for `EUR`), like the
+ * DMS's composed-text `money` parameter: `{ value: 987420, currency: "EUR" }`
+ * reads "€9,874.20" in English, "9 874,20 €" in French.
+ */
+export interface MoneyValue {
+  value: number;
+  /** ISO 4217 code. An unknown code writes the amount as a plain number. */
+  currency: string;
+}
+
+/** How a send writes its typed values: its locale, and the paths typed `date`. */
+export interface ValueFormat {
+  locale: string;
+  datePaths: Set<string>;
+}
+
+const FALLBACK_LOCALE = "en";
+const DATE_STYLE: Intl.DateTimeFormatOptions = { dateStyle: "long" };
+const UTC_DATE_STYLE: Intl.DateTimeFormatOptions = {
+  ...DATE_STYLE,
+  timeZone: "UTC",
+};
+/** A calendar day: written as that day, whatever the server's time zone. */
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+/** A moment: written as its day in the server's time zone. */
+const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+const DECIMAL_BASE = 10;
+const DATE_TYPE = "date";
+
+/** `locale` when the runtime can format for it, English otherwise. */
+export function formattingLocale(locale: string): string {
+  try {
+    return Intl.NumberFormat.supportedLocalesOf(locale)[0] ?? FALLBACK_LOCALE;
+  } catch {
+    return FALLBACK_LOCALE;
+  }
+}
+
+/** The paths a template declares `date`: their ISO strings are written as dates. */
+export function valueFormatOf(
+  locale: string,
+  variables: VariableDefinition[] = [],
+): ValueFormat {
+  return {
+    locale: formattingLocale(locale),
+    datePaths: new Set(
+      variables
+        .filter((variable) => variable.type === DATE_TYPE)
+        .map((variable) => variable.path),
+    ),
+  };
+}
+
+export function isMoneyValue(value: unknown): value is MoneyValue {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<MoneyValue>;
+  return (
+    typeof candidate.value === "number" &&
+    Number.isFinite(candidate.value) &&
+    typeof candidate.currency === "string"
+  );
+}
+
+function formatMoney(money: MoneyValue, locale: string): string {
+  try {
+    const currency = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: money.currency,
+    });
+    const digits = currency.resolvedOptions().maximumFractionDigits ?? 0;
+    return currency.format(money.value / DECIMAL_BASE ** digits);
+  } catch {
+    return new Intl.NumberFormat(locale).format(money.value);
+  }
+}
+
+function formatDate(
+  date: Date,
+  options: Intl.DateTimeFormatOptions,
+  locale: string,
+): string {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+
+function isoDateOptions(value: string): Intl.DateTimeFormatOptions | null {
+  if (ISO_DAY.test(value)) return UTC_DATE_STYLE;
+  if (ISO_DATE_TIME.test(value)) return DATE_STYLE;
+  return null;
+}
+
+/** An ISO string at a `date` path as the date it names; `null` otherwise. */
+function formatIsoDate(value: string, locale: string): string | null {
+  const options = isoDateOptions(value);
+  if (!options) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime())
+    ? null
+    : formatDate(date, options, locale);
+}
+
+/**
+ * A value as a recipient reads it. A money value and a `Date` format
+ * themselves in the send's locale wherever they appear; an ISO string is
+ * written as a date only at a path the template declares `date`; anything
+ * else, a string already formatted by the caller among them, as given.
+ */
+export function formatValue(
+  value: unknown,
+  path = "",
+  format?: ValueFormat,
+): string {
+  const locale = format?.locale ?? FALLBACK_LOCALE;
+  if (isMoneyValue(value)) return formatMoney(value, locale);
+  if (value instanceof Date)
+    return Number.isNaN(value.getTime())
+      ? String(value)
+      : formatDate(value, DATE_STYLE, locale);
+  if (typeof value === "string" && format?.datePaths.has(path))
+    return formatIsoDate(value, locale) ?? value;
+  return String(value);
+}

package/src/engine/index.ts

@@ -2,6 +2,7 @@ export * from "./changes";
 export * from "./conditions";
 export * from "./coverage";
 export * from "./fallback-html";
+export * from "./formats";
 export * from "./paths";
 export * from "./plain-text";
 export * from "./resolve";