@antelopejs/dms-mailing 0.7.1 → 0.9.0

package/src/services/templates.ts

@@ -27,6 +27,7 @@ import type {
   VariableDefinition,
 } from "../types";
 import { DEFAULT_FALLBACK_LOCALE } from "../types";
+import type { JsonObject } from "../types/json";
 
 export interface TemplateAuthor {
   name?: string;
@@ -73,6 +74,7 @@ export async function refuseTakenSlug<T>(write: Promise<T>): Promise<T> {
 
 /** The content customers receive: the last published version. */
 export function parseContent(template: MailingTemplate): TemplateContent {
+  // SAFETY: json_content is written only as JSON.stringify of a TemplateContent that saveContentSchema validated or the module built.
   return JSON.parse(template.json_content || EMPTY_CONTENT) as TemplateContent;
 }
 
@@ -83,6 +85,7 @@ export function hasDraft(template: MailingTemplate): boolean {
 /** The content the editor works on: the draft, or the published content. */
 export function workingContent(template: MailingTemplate): TemplateContent {
   if (!template.json_draft) return parseContent(template);
+  // SAFETY: json_draft is written only as JSON.stringify of a TemplateContent that saveContentSchema validated or the module built.
   return JSON.parse(template.json_draft) as TemplateContent;
 }
 
@@ -102,6 +105,7 @@ export function isPublished(template: MailingTemplate): boolean {
 export function parseVariables(
   template: MailingTemplate,
 ): VariableDefinition[] {
+  // SAFETY: json_variables is written only as JSON.stringify of a VariableDefinition[] that variableListSchema validated or the module built.
   return JSON.parse(template.json_variables) as VariableDefinition[];
 }
 
@@ -114,6 +118,7 @@ export function workingVariables(
 ): VariableDefinition[] {
   if (!hasDraft(template) || !template.json_variables_draft)
     return parseVariables(template);
+  // SAFETY: json_variables_draft is written only as JSON.stringify of a VariableDefinition[] that variableListSchema validated or the module built.
   return JSON.parse(template.json_variables_draft) as VariableDefinition[];
 }
 
@@ -169,10 +174,9 @@ export function pendingChanges(template: MailingTemplate): TemplateChange[] {
   });
 }
 
-export function parseTestData(
-  template: MailingTemplate,
-): Record<string, unknown> {
-  return JSON.parse(template.json_test_data) as Record<string, unknown>;
+export function parseTestData(template: MailingTemplate): JsonObject {
+  // SAFETY: json_test_data is written only as JSON.stringify of an object that its route or declaration schema validated, or the module built.
+  return JSON.parse(template.json_test_data) as JsonObject;
 }
 
 interface FooterLabels {
@@ -180,21 +184,26 @@ interface FooterLabels {
   preferences: string;
 }
 
+const ENGLISH_FOOTER_LABELS: FooterLabels = {
+  unsubscribe: "Unsubscribe",
+  preferences: "Preferences",
+};
+
 /**
  * The one piece of content the module still writes for a new template. An
  * e-mail without an unsubscribe link is a legal problem, so a blank template
  * ships a footer — and nothing else: no invented subject, prose or address.
  */
-const FOOTER_LABELS: Record<string, FooterLabels> = {
-  en: { unsubscribe: "Unsubscribe", preferences: "Preferences" },
-  fr: { unsubscribe: "Se désinscrire", preferences: "Préférences" },
-};
+const FOOTER_LABELS = new Map<string, FooterLabels>([
+  ["en", ENGLISH_FOOTER_LABELS],
+  ["fr", { unsubscribe: "Se désinscrire", preferences: "Préférences" }],
+]);
 
 const FOOTER_BLOCK_ID = "footer";
 
 /** A footer in `locale`: its legal line and the labels of its two links. */
 export function footerBlock(locale: string, text = ""): Block {
-  const labels = FOOTER_LABELS[locale] ?? (FOOTER_LABELS.en as FooterLabels);
+  const labels = FOOTER_LABELS.get(locale) ?? ENGLISH_FOOTER_LABELS;
   return {
     id: FOOTER_BLOCK_ID,
     type: "footer",
@@ -226,16 +235,13 @@ export function isStaleRevision(
   return revision !== undefined && revision !== template.draftRevision;
 }
 
-function draftWriteFields(
-  template: MailingTemplate,
-  author: string,
-): TemplateFields {
+function draftWriteFields(template: MailingTemplate, author: string) {
   return {
     draftRevision: template.draftRevision + 1,
     draftUpdatedAt: new Date(),
     draftUpdatedBy: author,
     updatedBy: author,
-  };
+  } satisfies TemplateFields;
 }
 
 /** Whether `draft` is exactly what customers and callers already have. */
@@ -271,7 +277,7 @@ export async function saveDraft(
     ...locales,
   });
   await refreshAttentionIfFlagged(tenantId, template, STALE_DRAFT);
-  return fields.draftRevision as number;
+  return fields.draftRevision;
 }
 
 export async function discardDraft(
@@ -291,6 +297,7 @@ export async function discardDraft(
 export function parseVersionChanges(
   row: MailingTemplateVersion,
 ): TemplateChange[] {
+  // SAFETY: json_changes is written only as JSON.stringify of the TemplateChange[] from diffContents and diffVariables.
   return JSON.parse(row.json_changes) as TemplateChange[];
 }
 
@@ -298,6 +305,7 @@ export function parseVersionChanges(
 export function parseVersionVariables(
   row: MailingTemplateVersion,
 ): VariableDefinition[] {
+  // SAFETY: a version row's json_variables is written only as JSON.stringify of a VariableDefinition[] that variableListSchema validated or the module built.
   return JSON.parse(row.json_variables) as VariableDefinition[];
 }
 
@@ -453,6 +461,7 @@ export async function contentOfVersion(
 export function parseVersionContent(
   row: MailingTemplateVersion,
 ): TemplateContent {
+  // SAFETY: a version row's json_content is written only as JSON.stringify of a TemplateContent that saveContentSchema validated.
   return JSON.parse(row.json_content) as TemplateContent;
 }
 

package/src/services/webhook-status.ts

@@ -7,6 +7,7 @@ import type {
   WebhookRefusal,
   WebhookStatus,
 } from "../types";
+import { isObject, isText } from "../validation/guards";
 import { webhookSecretMatches } from "./events";
 import { WEBHOOK_SECRET_HEADER } from "../constants";
 
@@ -28,11 +29,11 @@ export const WEBHOOK_REFUSAL_MESSAGES: Record<WebhookRefusal, string> = {
 };
 
 /** The body of a refused webhook call. */
-export interface WebhookRefusalBody {
+export type WebhookRefusalBody = {
   error: "webhook_refused";
   reason: WebhookRefusal;
   message: string;
-}
+};
 
 /** What "Send a test event" found when it called the webhook URL. */
 export interface WebhookTestOutcome {
@@ -143,15 +144,13 @@ export async function readWebhookStatus(
   );
 }
 
-const describeError = (error: unknown): string =>
-  error instanceof Error
-    ? String((error.cause as Error | undefined)?.message ?? error.message)
-    : String(error);
-
 async function refusalOf(
   response: Response,
 ): Promise<WebhookRefusal | undefined> {
   try {
+    // SAFETY: Response.json() answers any, and the URL under test is this module's own webhook route, which refuses
+    // with refusalBody(reason); another endpoint can answer any JSON, which is read the same way, and a non-object
+    // reads as no refusal (only null throws, into the catch below).
     const body = (await response.json()) as Partial<WebhookRefusalBody>;
     return body.reason;
   } catch {
@@ -192,11 +191,17 @@ export async function sendWebhookTest(
       refusal: response.ok ? undefined : await refusalOf(response),
     };
   } catch (error) {
+    const cause = error instanceof Error ? error.cause : undefined;
+    const causeMessage =
+      isObject(cause) && isText(cause.message) ? cause.message : undefined;
     return {
       isReceived: false,
       url,
       durationMs: elapsed(),
-      networkError: describeError(error),
+      networkError:
+        error instanceof Error
+          ? (causeMessage ?? error.message)
+          : String(error),
     };
   }
 }

package/src/types/json.ts

@@ -0,0 +1 @@
+export type { JsonObject, JsonValue } from "@antelopejs/interface-dms-mailing";

package/src/types/settings.ts

@@ -1,11 +1,11 @@
 import type { LocalizedText } from "@antelopejs/interface-dms-mailing";
 
 /** A template category as stored: its label written once per language. */
-export interface TemplateCategory {
+export type TemplateCategory = {
   id: string;
   label: LocalizedText;
   icon: string;
-}
+};
 
 /** A template category as one reader sees it: the label in their language. */
 export interface CategoryInLocale {

package/src/validation/declarations.schema.ts

@@ -1,13 +1,14 @@
 import { LOCALIZED_TEXT_FALLBACK_LOCALE } from "@antelopejs/interface-dms-mailing";
 import { z } from "zod";
 import { MAX_NAME_LENGTH } from "../constants";
-import { SEND_EVENT_TYPES } from "../types";
+import { sendEventTypeSchema } from "./send-event-type.schema";
 import { categorySchema, settingsSchema } from "./settings.schema";
 import {
   slugSchema,
   templateContentSchema,
   variableListSchema,
 } from "./templates.schema";
+import { jsonObjectSchema } from "./json.schema";
 
 const MAX_AUTHOR_LENGTH = MAX_NAME_LENGTH;
 const MAX_IMPORT_ID_LENGTH = 200;
@@ -36,7 +37,7 @@ export const templateDeclarationSchema = z.object({
   category: z.string().trim().default(""),
   content: templateContentSchema,
   variables: variableListSchema.default([]),
-  testData: z.record(z.unknown()).default({}),
+  testData: jsonObjectSchema.default({}),
   author: z.string().trim().min(1).max(MAX_AUTHOR_LENGTH).optional(),
 });
 
@@ -76,9 +77,9 @@ const recipientSchema = z.union([
 ]);
 
 const importedEventSchema = z.object({
-  type: z.enum(SEND_EVENT_TYPES as [string, ...string[]]),
+  type: sendEventTypeSchema,
   at: z.coerce.date(),
-  details: z.record(z.unknown()).optional(),
+  details: jsonObjectSchema.optional(),
 });
 
 const importedSendSchema = z.object({
@@ -87,7 +88,7 @@ const importedSendSchema = z.object({
   to: recipientSchema,
   sentAt: z.coerce.date(),
   locale: z.string().trim().min(1).optional(),
-  variables: z.record(z.unknown()).default({}),
+  variables: jsonObjectSchema.default({}),
   provider: z.string().optional(),
   providerMessageId: z.string().optional(),
   source: z.string().optional(),

package/src/validation/guards.ts

@@ -0,0 +1,17 @@
+/** Whether `value` is a string. */
+export function isText(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+/**
+ * Whether `value` is an object, arrays included, and not `null`: reading any
+ * key of it yields a value of unknown type.
+ */
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+/** Whether `value` is a number. */
+export function isNumber(value: unknown): value is number {
+  return typeof value === "number";
+}

package/src/validation/json.schema.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { isJsonObject } from "./json";
+
+/** A JSON object whose every value is JSON data, such as a request body carries. */
+export const jsonObjectSchema = z
+  .unknown()
+  .refine(isJsonObject, "expected a JSON object");

package/src/validation/json.ts

@@ -0,0 +1,66 @@
+import type { JsonObject, JsonValue } from "../types/json";
+import { isNumber, isObject, isText } from "./guards";
+
+/** A step of the walk in {@link isJsonValue}: visit a node, or leave one. */
+type JsonWalkStep = { visit: unknown } | { leave: object };
+
+/**
+ * Whether `value` is wholly JSON data: strings, numbers, booleans, null, and
+ * arrays and plain objects of the same, none of them reached through itself.
+ * Walked with a stack, so a deeply nested value cannot overflow it.
+ */
+export function isJsonValue(value: unknown): value is JsonValue {
+  const stack: JsonWalkStep[] = [{ visit: value }];
+  const ancestors = new Set<object>();
+  for (let step = stack.pop(); step; step = stack.pop()) {
+    if ("leave" in step) {
+      ancestors.delete(step.leave);
+      continue;
+    }
+    const item = step.visit;
+    if (
+      item === null ||
+      isText(item) ||
+      isNumber(item) ||
+      typeof item === "boolean"
+    )
+      continue;
+    if (typeof item !== "object" || ancestors.has(item)) return false;
+    const prototype: unknown = Object.getPrototypeOf(item);
+    if (
+      !Array.isArray(item) &&
+      prototype !== Object.prototype &&
+      prototype !== null
+    )
+      return false;
+    ancestors.add(item);
+    stack.push({ leave: item });
+    for (const child of Object.values(item)) stack.push({ visit: child });
+  }
+  return true;
+}
+
+/** Whether `value` is wholly JSON data and an object: neither `null` nor an array. */
+export function isJsonObject(value: unknown): value is JsonObject {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    isJsonValue(value)
+  );
+}
+
+/** `text` parsed as JSON; a `SyntaxError` when it is not. */
+export function parseJson(text: string): JsonValue {
+  const parsed: unknown = JSON.parse(text);
+  if (!isJsonValue(parsed)) throw new TypeError("expected JSON data");
+  return parsed;
+}
+
+/** `text` parsed as a JSON object. */
+export function parseJsonObject(text: string): JsonObject {
+  const parsed = parseJson(text);
+  if (!isObject(parsed) || Array.isArray(parsed))
+    throw new TypeError("expected a JSON object");
+  return parsed;
+}

package/src/validation/send-event-type.schema.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { SEND_EVENT_TYPES } from "../types";
+
+const [FIRST_EVENT_TYPE, ...OTHER_EVENT_TYPES] = SEND_EVENT_TYPES;
+
+/** A send event's type: one of {@link SEND_EVENT_TYPES}. */
+export const sendEventTypeSchema = z.enum([
+  FIRST_EVENT_TYPE,
+  ...OTHER_EVENT_TYPES,
+]);

package/src/validation/settings.schema.ts

@@ -123,12 +123,18 @@ function moveIssues(
   kept: Set<string>,
 ): CategoryIssue[] {
   return entries.flatMap((entry, index) =>
-    isKept(entry) || kept.has(entry.moveTo as string)
+    entry.moveTo === undefined || kept.has(entry.moveTo)
       ? []
       : [{ message: UNKNOWN_MOVE_TARGET, path: [index, "moveTo"] }],
   );
 }
 
+/**
+ * Adds the issues of the category rows: blank labels and duplicates in each
+ * language, a removed marketing category, a move to a category that is not
+ * kept. Each issue is reported once per row and part, whichever language
+ * shows it first.
+ */
 function refineCategoryEntries(
   entries: CategoryEntry[],
   context: z.RefinementCtx,
@@ -147,7 +153,6 @@ function refineCategoryEntries(
     ...moveIssues(entriesIn(entries, LOCALIZED_TEXT_FALLBACK_LOCALE), kept),
   ]
     .filter((issue) => {
-      // One issue per row and part, whichever language shows it first.
       const id = JSON.stringify(issue);
       if (seen.has(id)) return false;
       seen.add(id);

package/src/validation/templates.schema.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
 import { MAX_NAME_LENGTH, MAX_SLUG_LENGTH, SLUG_PATTERN } from "../constants";
+import type { Block } from "../types";
+import { jsonObjectSchema } from "./json.schema";
 
 const MIN_HEADING_SIZE = 12;
 const MAX_HEADING_SIZE = 48;
@@ -31,7 +33,7 @@ export const conditionSchema = z.object({
 const alignSchema = z.enum(["left", "center", "right"]);
 const base = { id: z.string().min(1), visibleIf: conditionSchema.nullable() };
 
-export const blockSchema: z.ZodType<unknown> = z.lazy(() =>
+export const blockSchema: z.ZodType<Block, z.ZodTypeDef, unknown> = z.lazy(() =>
   z.discriminatedUnion("type", [
     z.object({
       ...base,
@@ -148,7 +150,7 @@ export const saveContentSchema = z.object({
   revision: draftRevisionSchema,
 });
 
-export const testDataSchema = z.object({ data: z.record(z.unknown()) });
+export const testDataSchema = z.object({ data: jsonObjectSchema });
 
 /**
  * Which content a preview renders when it carries none: the working draft
@@ -165,7 +167,7 @@ export const previewSchema = z.object({
   locale: z.string().min(1).optional(),
   version: previewVersionSchema.optional(),
   content: templateContentSchema.optional(),
-  data: z.record(z.unknown()).optional(),
+  data: jsonObjectSchema.optional(),
 });
 
 /**
@@ -175,7 +177,7 @@ export const previewSchema = z.object({
 export const realSendSchema = z.object({
   to: z.array(z.string().email()).min(1).max(MAX_TEST_RECIPIENT_COUNT),
   locale: z.string().min(1).optional(),
-  data: z.record(z.unknown()).optional(),
+  data: jsonObjectSchema.optional(),
 });
 
 export const testSendSchema = previewSchema.extend({
@@ -192,6 +194,9 @@ export const templateDetailsSchema = z.object({
   category: z.string().nullable().optional(),
 });
 
+/** The details a template's drawer or the editor saves, validated. */
+export type TemplateDetails = z.infer<typeof templateDetailsSchema>;
+
 export const duplicateSchema = z.object({
   slug: slugSchema,
   name: z.string().trim().min(1).max(MAX_NAME_LENGTH),

package/frontend-vue/tests/i18n-editor.test.ts

@@ -1,50 +0,0 @@
-import { readFileSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import en from '../i18n/locales/mailing-en-GB.json'
-
-const APP = join(__dirname, '..', 'app')
-const EDITOR_SOURCES = [
-	join(APP, 'components', 'Editor.vue'),
-	join(APP, 'composables', 'useEditorActions.ts'),
-	join(APP, 'composables', 'useEditorShortcuts.ts'),
-	...readdirSync(join(APP, 'components', 'editor')).map((file) =>
-		join(APP, 'components', 'editor', file),
-	),
-]
-const LITERAL_KEY =
-	/'(dms_mailing\.(?:editor|blocks|templates\.status)\.[a-z_.]+)'/g
-const PREFIX_CONSTANT = /const (\w*KEY) = '(dms_mailing[a-z_.]*)'/g
-const PREFIXED_KEY = /\$\{(\w*KEY)\}\.([a-z_.]+)`/g
-
-function keysUsedIn(source: string): string[] {
-	const prefixes = new Map(
-		[...source.matchAll(PREFIX_CONSTANT)].map((match) => [match[1], match[2]]),
-	)
-	const prefixValues = new Set(prefixes.values())
-	const literal = [...source.matchAll(LITERAL_KEY)]
-		.map((match) => match[1] as string)
-		.filter((key) => !prefixValues.has(key))
-	const prefixed = [...source.matchAll(PREFIXED_KEY)]
-		.filter((match) => prefixes.has(match[1]))
-		.map((match) => `${prefixes.get(match[1])}.${match[2]}`)
-	return [...literal, ...prefixed]
-}
-
-function keysOf(value: unknown, prefix = ''): string[] {
-	if (typeof value !== 'object' || value === null) return [prefix]
-	return Object.entries(value).flatMap(([key, child]) =>
-		keysOf(child, prefix ? `${prefix}.${key}` : key),
-	)
-}
-
-describe('editor locales', () => {
-	it('define every literal key the editor components use', () => {
-		const known = new Set(keysOf(en))
-		const used = EDITOR_SOURCES.flatMap((file) =>
-			keysUsedIn(readFileSync(file, 'utf8')),
-		)
-		expect(used.length).toBeGreaterThan(0)
-		expect(used.filter((key) => !known.has(key))).toEqual([])
-	})
-})

package/frontend-vue/tests/i18n.test.ts

@@ -1,138 +0,0 @@
-import { readFileSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import en from '../i18n/locales/mailing-en-GB.json'
-import fr from '../i18n/locales/mailing-fr-FR.json'
-
-// vitest runs with the layer as its root; the backend sits one level above it.
-const BACKEND_SOURCE_DIR = join(process.cwd(), '..', 'src')
-
-// `$dms_mailing.a.b` as the backend writes it. A literal that stops on a dot is
-// the prefix of a key completed by a template expression (`${status}`); those
-// are resolved at runtime and cannot be checked here.
-const KEY_LITERAL = /\$dms_mailing\.[\w.]+/g
-const DYNAMIC_KEY_SUFFIX = '.'
-
-function keysOf(value: unknown, prefix = ''): string[] {
-	if (typeof value !== 'object' || value === null) return [prefix]
-	return Object.entries(value).flatMap(([key, child]) =>
-		keysOf(child, prefix ? `${prefix}.${key}` : key),
-	)
-}
-
-function typescriptFiles(directory: string): string[] {
-	return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
-		const path = join(directory, entry.name)
-		if (entry.isDirectory()) return typescriptFiles(path)
-		return entry.isFile() && path.endsWith('.ts') ? [path] : []
-	})
-}
-
-function backendKeys(): string[] {
-	const found = new Set<string>()
-	for (const file of typescriptFiles(BACKEND_SOURCE_DIR)) {
-		for (const literal of readFileSync(file, 'utf8').match(KEY_LITERAL) ?? []) {
-			const key = literal.slice(1)
-			if (!key.endsWith(DYNAMIC_KEY_SUFFIX)) found.add(key)
-		}
-	}
-	return [...found].sort()
-}
-
-function messagesOf(value: unknown, prefix = ''): [string, string][] {
-	if (typeof value === 'string') return [[prefix, value]]
-	if (typeof value !== 'object' || value === null) return []
-	return Object.entries(value).flatMap(([key, child]) =>
-		messagesOf(child, prefix ? `${prefix}.${key}` : key),
-	)
-}
-
-// `{name}` placeholders and `{'…'}` literals, the only braces a message holds.
-const BRACED = /\{'[^']*'\}|\{\w+\}/g
-const PLACEHOLDER = /\{(\w+)\}/g
-const PLURAL_SEPARATOR = '|'
-// vue-i18n's default rule picks, for three forms, the first at 0 and the
-// second at 1: French says « 0 envoi », so every French plural needs all three.
-const FRENCH_PLURAL_FORMS = 3
-
-function placeholdersOf(message: string): string[] {
-	return [
-		...new Set([...message.matchAll(PLACEHOLDER)].map((match) => match[1])),
-	].sort()
-}
-
-function resolve(root: unknown, key: string): unknown {
-	return key
-		.split('.')
-		.reduce<unknown>(
-			(node, part) =>
-				typeof node === 'object' && node !== null
-					? (node as Record<string, unknown>)[part]
-					: undefined,
-			root,
-		)
-}
-
-describe('locales', () => {
-	it('carry the same key set', () => {
-		expect(keysOf(fr).sort()).toEqual(keysOf(en).sort())
-	})
-	it('cover every namespace the pages use', () => {
-		for (const namespace of [
-			'overview',
-			'templates',
-			'editor',
-			'sends',
-			'settings',
-			'metrics',
-			'funnel',
-			'errors',
-			'blocks',
-		]) {
-			expect(en.dms_mailing).toHaveProperty(namespace)
-		}
-	})
-	it('resolve every static key the backend emits', () => {
-		const keys = backendKeys()
-		expect(keys.length).toBeGreaterThan(0)
-		expect(keys.filter((key) => typeof resolve(en, key) !== 'string')).toEqual(
-			[],
-		)
-		expect(keys.filter((key) => typeof resolve(fr, key) !== 'string')).toEqual(
-			[],
-		)
-	})
-	it('compile: no stray brace or unescaped @ outside placeholders', () => {
-		const broken = [...messagesOf(en), ...messagesOf(fr)].filter(
-			([, message]) => /[{}@]/.test(message.replace(BRACED, '')),
-		)
-		expect(broken).toEqual([])
-	})
-	it('give each message the same placeholders in both languages', () => {
-		const french = new Map(messagesOf(fr))
-		const mismatched = messagesOf(en)
-			.filter(
-				([key, message]) =>
-					placeholdersOf(message).join() !==
-					placeholdersOf(french.get(key) ?? '').join(),
-			)
-			.map(([key]) => key)
-		expect(mismatched).toEqual([])
-	})
-	it('say « modèle », never « template », in French', () => {
-		const anglicisms = messagesOf(fr)
-			.filter(([, message]) => /\btemplates?\b/i.test(message))
-			.map(([key]) => key)
-		expect(anglicisms).toEqual([])
-	})
-	it('write every French plural with three forms, 0 in the singular', () => {
-		const incomplete = messagesOf(fr)
-			.filter(
-				([, message]) =>
-					message.includes(PLURAL_SEPARATOR) &&
-					message.split(PLURAL_SEPARATOR).length !== FRENCH_PLURAL_FORMS,
-			)
-			.map(([key]) => key)
-		expect(incomplete).toEqual([])
-	})
-})