@simmalugnt-se/payload-content-health 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.4.0
+
+- New check `content.untranslated`, turned on per collection with `translations: true`: localized
+  text, textarea and rich text fields that are filled in the default language and empty in
+  another. One finding per document and language, at the first such field, with how many there are
+  (`untranslated: { count, source }`). "Fix with the assistant" asks it to translate the empty
+  fields from the default language ("Översätt de tomma fälten från engelska.").
+
+## 0.3.0
+
+- "Fix with the assistant" on a missing meta title or description says how long to write it
+  ("Write a meta title for this page, 50–60 characters."), from the same range as the length check.
+  Without it the assistant wrote titles well under the range. Findings for a missing meta title or
+  description carry that range as `range`.
+
 ## 0.2.1
 
 - The work list at `/admin/content-health` requires Admin access. Payload leaves custom Admin views

package/README.md

@@ -50,6 +50,7 @@ Requires Payload `>=3.90.2 <4`, Next 16 and React 19. The widget uses Payload's
 | `content.h1-multiple`     | `content.headings`  | More than one H1                               |
 | `content.heading-skip`    | `content.headings`  | A heading level skipped, e.g. H2 → H4          |
 | `content.thin`            | `content`           | Fewer than 300 words on the page               |
+| `content.untranslated`    | `translations`      | Localized text empty here, filled in default   |
 
 `seo: true` reads the fields `@payloadcms/plugin-seo` adds (`meta.title`, `meta.description`,
 `meta.image`) with its default lengths. Point them elsewhere or turn single checks off:
@@ -87,6 +88,19 @@ pages: {
 
 Each page gets at most one finding per check: the first skipped level, the second H1.
 
+### Translations
+
+`translations: true` compares every language with the default one (Payload's
+`localization.defaultLocale`): a localized text, textarea or rich text field that is filled there
+and empty here is not translated. Each document gets one finding per language, at the first such
+field, saying how many there are ("5 fields not translated"). With the editor assistant, "Fix with
+the assistant" asks it to translate the empty fields from the default language. Fields that are not
+localized, and blocks whose type differs between the languages, are left out.
+
+```ts
+pages: { seo: true, translations: true },
+```
+
 Checks read the latest version of each document, drafts included, with the signed-in user's access.
 Localized fields are checked in every locale without fallback, so a missing Swedish alt text is
 reported even when the English one exists.
@@ -115,9 +129,10 @@ or block the unsaved form no longer has opens the nearest enclosing field instea
 
 With `@simmalugnt-se/payload-editor-assistant` (0.5.0 or later), rows in the collections the
 assistant works in also get "Fix with the assistant": the same link with a ready prompt that the
-assistant puts in its message box. The editor sends it. To write a missing alt text, the assistant
-needs to see the image: allow `media.view` on the media collection (0.6.0 or later). The packages
-do not import each other; they share these names:
+assistant puts in its message box, with the length to aim for when a meta title or description is
+missing or off. The editor sends it. To write a missing alt text, the assistant needs to see the
+image: allow `media.view` on the media collection (0.6.0 or later). The packages do not import each
+other; they share these names:
 
 | Name                                         | Direction               | Meaning                                  |
 | -------------------------------------------- | ----------------------- | ---------------------------------------- |
@@ -137,6 +152,8 @@ import { scanContentHealth } from "@simmalugnt-se/payload-content-health";
 const { findings, problems } = await scanContentHealth({ payload, user: req.user });
 ```
 
-Each finding is `{ check, collection, id, title, path, locale?, length?, heading?, words?, status? }`,
-where `path` is the form path with row indexes (`layout.1.items.0.title`). `problems`
-lists configured checks that could not run, such as a field path that does not exist.
+Each finding is
+`{ check, collection, id, title, path, locale?, length?, range?, heading?, words?, status? }`, where
+`path` is the form path with row indexes (`layout.1.items.0.title`) and `range` is the length a
+missing meta title or description should have. `problems` lists configured checks that could not
+run, such as a field path that does not exist.

package/dist/checks.d.ts

@@ -19,6 +19,7 @@ export type FieldRule = {
     kind: "required";
     path: string;
     imagesOnly?: boolean;
+    range?: LengthRange;
 } | {
     check: CheckId;
     kind: "length";

package/dist/checks.js

@@ -25,13 +25,23 @@ export function rulesFor(options) {
         const titleLength = seo.titleLength ?? SEO_DEFAULTS.titleLength;
         const descriptionLength = seo.descriptionLength ?? SEO_DEFAULTS.descriptionLength;
         if (title) {
-            rules.push({ check: "seo.title-missing", kind: "required", path: title });
+            rules.push({
+                check: "seo.title-missing",
+                kind: "required",
+                path: title,
+                ...(titleLength ? { range: titleLength } : {}),
+            });
             if (titleLength) {
                 rules.push({ check: "seo.title-length", kind: "length", path: title, range: titleLength });
             }
         }
         if (description) {
-            rules.push({ check: "seo.description-missing", kind: "required", path: description });
+            rules.push({
+                check: "seo.description-missing",
+                kind: "required",
+                path: description,
+                ...(descriptionLength ? { range: descriptionLength } : {}),
+            });
             if (descriptionLength) {
                 rules.push({
                     check: "seo.description-length",
@@ -105,7 +115,8 @@ export function checkDocument(input) {
             }
             checked.push(rule.check);
             if (isEmpty(value)) {
-                findings.push(base);
+                // The assistant writes to the length the length check will expect.
+                findings.push(rule.range ? { ...base, range: rule.range } : base);
             }
             continue;
         }

package/dist/copy.d.ts

@@ -22,6 +22,7 @@ export declare const COPY: {
         readonly length: (actual: number, min: number, max: number) => string;
         readonly headingSkip: (previous: number, level: number) => string;
         readonly h1Count: (count: number) => string;
+        readonly untranslated: (count: number) => string;
         readonly words: (actual: number, min: number) => string;
         readonly problems: "Some checks could not run:";
     };
@@ -38,6 +39,7 @@ export declare const COPY: {
         readonly length: (actual: number, min: number, max: number) => string;
         readonly headingSkip: (previous: number, level: number) => string;
         readonly h1Count: (count: number) => string;
+        readonly untranslated: (count: number) => string;
         readonly words: (actual: number, min: number) => string;
         readonly problems: "Några kontroller kunde inte köras:";
     };
@@ -85,6 +87,8 @@ export declare const LIST_COPY: {
     };
 };
 export type ListCopy = (typeof LIST_COPY)[UiLanguage];
-/** A finding's detail: its length, word count or heading levels, when it has one. */
+/** A finding's detail: its length, word count, heading levels or untranslated fields, if any. */
 export declare function findingDetail(language: UiLanguage, finding: Finding): string | undefined;
+/** A locale code as a language name in Admin's language: "engelska", "English". */
+export declare function languageName(language: UiLanguage, code: string): string;
 export {};

package/dist/copy.js

@@ -13,6 +13,7 @@ export const CHECK_LABELS = {
         "content.h1-multiple": "More than one H1",
         "content.heading-skip": "Skipped heading levels",
         "content.thin": "Thin content",
+        "content.untranslated": "Not translated",
     },
     sv: {
         "media.alt-missing": "Alt-text saknas",
@@ -25,6 +26,7 @@ export const CHECK_LABELS = {
         "content.h1-multiple": "Fler än en H1",
         "content.heading-skip": "Överhoppade rubriknivåer",
         "content.thin": "Tunt innehåll",
+        "content.untranslated": "Saknar översättning",
     },
 };
 /** Tile headings: what is measured, so "0 of 4 filled in" reads without a double negative. */
@@ -40,6 +42,7 @@ export const TILE_LABELS = {
         "content.h1-multiple": "Single main heading",
         "content.heading-skip": "Heading order",
         "content.thin": "Page length",
+        "content.untranslated": "Translations",
     },
     sv: {
         "media.alt-missing": "Alt-texter",
@@ -52,6 +55,7 @@ export const TILE_LABELS = {
         "content.h1-multiple": "En huvudrubrik",
         "content.heading-skip": "Rubrikordning",
         "content.thin": "Sidlängd",
+        "content.untranslated": "Översättningar",
     },
 };
 /** A tile's "x of y" line, phrased as what is in order for that check. */
@@ -67,6 +71,7 @@ export const STATUS = {
         "content.h1-multiple": (ok, total) => `${ok} of ${total} pages have at most one`,
         "content.heading-skip": (ok, total) => `${ok} of ${total} pages in order`,
         "content.thin": (ok, total) => `${ok} of ${total} pages long enough`,
+        "content.untranslated": (ok, total) => `${ok} of ${total} translated`,
     },
     sv: {
         "media.alt-missing": (ok, total) => `${ok} av ${total} ifyllda`,
@@ -79,6 +84,7 @@ export const STATUS = {
         "content.h1-multiple": (ok, total) => `${ok} av ${total} sidor har högst en`,
         "content.heading-skip": (ok, total) => `${ok} av ${total} sidor i ordning`,
         "content.thin": (ok, total) => `${ok} av ${total} sidor tillräckligt långa`,
+        "content.untranslated": (ok, total) => `${ok} av ${total} översatta`,
     },
 };
 export const COPY = {
@@ -95,6 +101,7 @@ export const COPY = {
         length: (actual, min, max) => `${actual} characters, aim for ${min}–${max}`,
         headingSkip: (previous, level) => `H${previous} → H${level}`,
         h1Count: (count) => `${count} H1s`,
+        untranslated: (count) => `${count} ${count === 1 ? "field" : "fields"} not translated`,
         words: (actual, min) => `${actual} ${actual === 1 ? "word" : "words"}, aim for ${min}+`,
         problems: "Some checks could not run:",
     },
@@ -111,6 +118,7 @@ export const COPY = {
         length: (actual, min, max) => `${actual} tecken, sikta på ${min}–${max}`,
         headingSkip: (previous, level) => `H${previous} → H${level}`,
         h1Count: (count) => `${count} H1:or`,
+        untranslated: (count) => `${count} fält saknar översättning`,
         words: (actual, min) => `${actual} ord, sikta på minst ${min}`,
         problems: "Några kontroller kunde inte köras:",
     },
@@ -122,11 +130,15 @@ export const COPY = {
 export const ASK = {
     en: {
         "media.alt-missing": () => "Write an alt text for this image.",
-        "seo.title-missing": () => "Write a meta title for this page.",
+        "seo.title-missing": ({ range }) => range
+            ? `Write a meta title for this page, ${range.min}–${range.max} characters.`
+            : "Write a meta title for this page.",
         "seo.title-length": ({ length }) => length
             ? `The meta title is ${length.actual} characters. Rewrite it to ${length.min}–${length.max} characters.`
             : "Rewrite the meta title to a better length.",
-        "seo.description-missing": () => "Write a meta description for this page.",
+        "seo.description-missing": ({ range }) => range
+            ? `Write a meta description for this page, ${range.min}–${range.max} characters.`
+            : "Write a meta description for this page.",
         "seo.description-length": ({ length }) => length
             ? `The meta description is ${length.actual} characters. Rewrite it to ${length.min}–${length.max} characters.`
             : "Rewrite the meta description to a better length.",
@@ -139,14 +151,21 @@ export const ASK = {
         "content.thin": ({ words }) => words
             ? `This page has ${words.actual} words. Suggest how to expand the text to at least ${words.min} words.`
             : "This page has little text. Suggest how to expand it.",
+        "content.untranslated": ({ untranslated }) => untranslated
+            ? `Translate the empty fields from ${languageName("en", untranslated.source)}.`
+            : "Translate the empty fields.",
     },
     sv: {
         "media.alt-missing": () => "Skriv en alt-text för den här bilden.",
-        "seo.title-missing": () => "Skriv en metatitel för den här sidan.",
+        "seo.title-missing": ({ range }) => range
+            ? `Skriv en metatitel för den här sidan, ${range.min}–${range.max} tecken.`
+            : "Skriv en metatitel för den här sidan.",
         "seo.title-length": ({ length }) => length
             ? `Metatiteln är ${length.actual} tecken. Skriv om den till ${length.min}–${length.max} tecken.`
             : "Skriv om metatiteln till en bättre längd.",
-        "seo.description-missing": () => "Skriv en metabeskrivning för den här sidan.",
+        "seo.description-missing": ({ range }) => range
+            ? `Skriv en metabeskrivning för den här sidan, ${range.min}–${range.max} tecken.`
+            : "Skriv en metabeskrivning för den här sidan.",
         "seo.description-length": ({ length }) => length
             ? `Metabeskrivningen är ${length.actual} tecken. Skriv om den till ${length.min}–${length.max} tecken.`
             : "Skriv om metabeskrivningen till en bättre längd.",
@@ -159,6 +178,9 @@ export const ASK = {
         "content.thin": ({ words }) => words
             ? `Sidan har ${words.actual} ord. Föreslå hur jag bygger ut texten till minst ${words.min} ord.`
             : "Sidan har lite text. Föreslå hur jag bygger ut den.",
+        "content.untranslated": ({ untranslated }) => untranslated
+            ? `Översätt de tomma fälten från ${languageName("sv", untranslated.source)}.`
+            : "Översätt de tomma fälten.",
     },
 };
 export const LIST_COPY = {
@@ -197,10 +219,13 @@ export const LIST_COPY = {
         noneFiltered: "Inga problem matchar filtren.",
     },
 };
-/** A finding's detail: its length, word count or heading levels, when it has one. */
+/** A finding's detail: its length, word count, heading levels or untranslated fields, if any. */
 export function findingDetail(language, finding) {
     const copy = COPY[language];
-    const { heading, length, words } = finding;
+    const { heading, length, untranslated, words } = finding;
+    if (untranslated) {
+        return copy.untranslated(untranslated.count);
+    }
     return length
         ? copy.length(length.actual, length.min, length.max)
         : words
@@ -211,3 +236,12 @@ export function findingDetail(language, finding) {
                     ? copy.h1Count(heading.count)
                     : undefined;
 }
+/** A locale code as a language name in Admin's language: "engelska", "English". */
+export function languageName(language, code) {
+    try {
+        return new Intl.DisplayNames([language], { type: "language" }).of(code) ?? code;
+    }
+    catch {
+        return code;
+    }
+}

package/dist/scan.js

@@ -1,5 +1,6 @@
 import { checkDocument, documentTitle, rulesFor } from "./checks.js";
 import { contentSchema, lookupPath, mergeSelect, } from "./fields.js";
+import { checkTranslation } from "./translations.js";
 import { CHECK_IDS } from "./types.js";
 /** Where the plugin keeps its options in the (server-only) `config.custom`. */
 export const CUSTOM_KEY = "contentHealth";
@@ -66,7 +67,10 @@ export async function scanContentHealth({ payload, user, checks }) {
             });
             mergeSelect(select, info.select);
         }
-        if (!rules.length) {
+        const translate = Boolean(collectionOptions.translations) &&
+            locales.length > 1 &&
+            (!checks?.length || checks.includes("content.untranslated"));
+        if (!rules.length && !translate) {
             continue;
         }
         const useAsTitle = collection.admin?.useAsTitle;
@@ -82,7 +86,7 @@ export async function scanContentHealth({ payload, user, checks }) {
         }
         const anyLocalized = rules.some((rule) => rule.localized);
         for (const [index, locale] of locales.entries()) {
-            if (index > 0 && !anyLocalized) {
+            if (!rules.length || (index > 0 && !anyLocalized)) {
                 break;
             }
             try {
@@ -118,7 +122,75 @@ export async function scanContentHealth({ payload, user, checks }) {
                 break;
             }
         }
+        if (translate) {
+            ran.add("content.untranslated");
+            try {
+                await scanTranslations({
+                    payload,
+                    user,
+                    slug,
+                    fields,
+                    resolveBlock,
+                    drafts,
+                    useAsTitle,
+                    locales: locales,
+                    result,
+                });
+            }
+            catch (error) {
+                result.problems.push(`${slug}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
     }
     result.checks = CHECK_IDS.filter((check) => ran.has(check));
     return result;
 }
+/** Compares every other language with the default one, document by document. */
+async function scanTranslations(input) {
+    const { payload, slug, result } = input;
+    const localization = payload.config.localization;
+    const sourceLocale = localization ? localization.defaultLocale : undefined;
+    if (!sourceLocale) {
+        return;
+    }
+    // Without fallback, so a field nobody translated reads as empty.
+    const read = async (locale) => (await payload.find({
+        collection: slug,
+        depth: 0,
+        draft: input.drafts,
+        fallbackLocale: false,
+        locale,
+        overrideAccess: false,
+        pagination: false,
+        user: input.user,
+    })).docs;
+    const sources = new Map((await read(sourceLocale)).map((doc) => [String(doc.id), doc]));
+    for (const locale of input.locales) {
+        if (locale === sourceLocale) {
+            continue;
+        }
+        for (const target of await read(locale)) {
+            const source = sources.get(String(target.id));
+            if (!source) {
+                continue;
+            }
+            const title = documentTitle(target, input.useAsTitle) === String(target.id)
+                ? documentTitle(source, input.useAsTitle)
+                : documentTitle(target, input.useAsTitle);
+            const { findings, checked } = checkTranslation({
+                collection: slug,
+                title,
+                locale,
+                sourceLocale,
+                fields: input.fields,
+                resolveBlock: input.resolveBlock,
+                source,
+                target,
+            });
+            result.findings.push(...findings);
+            for (const check of checked) {
+                result.checked[check] = (result.checked[check] ?? 0) + 1;
+            }
+        }
+    }
+}

package/dist/translations.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Missing translations: localized text that is filled in the default language and empty in another.
+ * Both versions are read from the database without fallback, so an empty field reads as empty.
+ */
+import type { DocumentResult } from "./checks.ts";
+import type { BlockLike, FieldLike } from "./fields.ts";
+/** Paths, with array and block indexes, of localized text filled in `source` and empty in `target`. */
+export declare function untranslatedPaths(fields: FieldLike[], resolveBlock: (slug: string) => BlockLike | undefined, source: Record<string, unknown>, target: Record<string, unknown>): string[];
+export type TranslationInput = {
+    collection: string;
+    title: string;
+    locale: string;
+    sourceLocale: string;
+    fields: FieldLike[];
+    resolveBlock: (slug: string) => BlockLike | undefined;
+    /** The document in the default language. */
+    source: Record<string, unknown>;
+    /** The same document in `locale`. */
+    target: Record<string, unknown>;
+};
+/** One finding per document and language, pointing at the first field that is not translated. */
+export declare function checkTranslation(input: TranslationInput): DocumentResult;

package/dist/translations.js

@@ -0,0 +1,120 @@
+const TEXT_TYPES = new Set(["text", "textarea", "richText"]);
+/** Paths, with array and block indexes, of localized text filled in `source` and empty in `target`. */
+export function untranslatedPaths(fields, resolveBlock, source, target) {
+    const walk = { resolveBlock, paths: [] };
+    walkFields(fields, source, target, "", false, walk);
+    return walk.paths;
+}
+/** One finding per document and language, pointing at the first field that is not translated. */
+export function checkTranslation(input) {
+    const { target } = input;
+    const paths = untranslatedPaths(input.fields, input.resolveBlock, input.source, target);
+    const status = target._status === "draft" || target._status === "published" ? target._status : undefined;
+    const findings = paths[0]
+        ? [
+            {
+                check: "content.untranslated",
+                collection: input.collection,
+                id: target.id,
+                title: input.title,
+                path: paths[0],
+                locale: input.locale,
+                untranslated: { count: paths.length, source: input.sourceLocale },
+                ...(status ? { status } : {}),
+            },
+        ]
+        : [];
+    return { findings, checked: ["content.untranslated"] };
+}
+function walkFields(fields, source, target, prefix, localized, walk) {
+    for (const field of fields) {
+        if (field.type === "tabs") {
+            for (const tab of field.tabs ?? []) {
+                if (tab.name) {
+                    walkField({ ...tab, type: "group" }, source, target, prefix, localized, walk);
+                }
+                else {
+                    walkFields(tab.fields ?? [], source, target, prefix, localized, walk);
+                }
+            }
+            continue;
+        }
+        if (!field.name) {
+            // Rows and collapsibles add no segment.
+            walkFields(field.fields ?? [], source, target, prefix, localized, walk);
+            continue;
+        }
+        walkField(field, source, target, prefix, localized, walk);
+    }
+}
+function walkField(field, source, target, prefix, inherited, walk) {
+    const name = field.name;
+    const path = prefix ? `${prefix}.${name}` : name;
+    const localized = inherited || Boolean(field.localized);
+    const from = child(source, name);
+    const to = child(target, name);
+    if (field.type && TEXT_TYPES.has(field.type)) {
+        if (localized && hasText(from) && !hasText(to)) {
+            walk.paths.push(path);
+        }
+        return;
+    }
+    if (field.type === "group") {
+        walkFields(field.fields ?? [], from, to, path, localized, walk);
+        return;
+    }
+    if (field.type !== "array" && field.type !== "blocks") {
+        return;
+    }
+    const sourceRows = Array.isArray(from) ? from : [];
+    const targetRows = Array.isArray(to) ? to : [];
+    // A localized list that is empty here is one untranslated field; its rows do not exist yet.
+    if (field.localized && sourceRows.length > 0 && targetRows.length === 0) {
+        walk.paths.push(path);
+        return;
+    }
+    for (const [index, sourceRow] of sourceRows.entries()) {
+        const targetRow = targetRows[index];
+        if (!targetRow || typeof targetRow !== "object") {
+            continue;
+        }
+        const rowPath = `${path}.${index}`;
+        if (field.type === "array") {
+            walkFields(field.fields ?? [], sourceRow, targetRow, rowPath, localized, walk);
+            continue;
+        }
+        const type = sourceRow.blockType;
+        if (typeof type !== "string" || targetRow.blockType !== type) {
+            continue;
+        }
+        const block = blockFor(field, type, walk.resolveBlock);
+        if (block) {
+            walkFields(block.fields, sourceRow, targetRow, rowPath, localized, walk);
+        }
+    }
+}
+function blockFor(field, slug, resolveBlock) {
+    const inline = field.blocks?.find((block) => block.slug === slug);
+    if (inline) {
+        return inline;
+    }
+    const reference = field.blockReferences?.find((block) => typeof block === "string" ? block === slug : block.slug === slug);
+    return typeof reference === "string" ? resolveBlock(reference) : reference;
+}
+function child(value, name) {
+    return value && typeof value === "object" ? value[name] : undefined;
+}
+/** Text with something in it: a non-blank string, or rich text with a non-blank text node. */
+function hasText(value) {
+    if (typeof value === "string") {
+        return value.trim().length > 0;
+    }
+    const root = value?.root;
+    return root ? nodeHasText(root) : false;
+}
+function nodeHasText(node) {
+    if (typeof node.text === "string" && node.text.trim()) {
+        return true;
+    }
+    return Array.isArray(node.children) && node.children.some(nodeHasText);
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export declare const CHECK_IDS: readonly ["media.alt-missing", "seo.title-missing", "seo.title-length", "seo.description-missing", "seo.description-length", "seo.image-missing", "content.h1-missing", "content.h1-multiple", "content.heading-skip", "content.thin"];
+export declare const CHECK_IDS: readonly ["media.alt-missing", "seo.title-missing", "seo.title-length", "seo.description-missing", "seo.description-length", "seo.image-missing", "content.h1-missing", "content.h1-multiple", "content.heading-skip", "content.thin", "content.untranslated"];
 export type CheckId = (typeof CHECK_IDS)[number];
 export type LengthRange = {
     min: number;
@@ -19,6 +19,8 @@ export type Finding = {
     length?: LengthRange & {
         actual: number;
     };
+    /** For a missing meta title or description: the length its length check expects. */
+    range?: LengthRange;
     /** For heading checks: the heading's level and, for a skip, the level before it. */
     heading?: {
         level: number;
@@ -30,6 +32,11 @@ export type Finding = {
         actual: number;
         min: number;
     };
+    /** For a missing translation: how many fields are empty here, and the language they come from. */
+    untranslated?: {
+        count: number;
+        source: string;
+    };
     /** Draft status of the checked version, for collections with drafts. */
     status?: "draft" | "published";
 };
@@ -70,6 +77,11 @@ export type CollectionHealthOptions = {
     altText?: boolean | AltTextOptions;
     /** Heading structure and thin content, read from the page body. */
     content?: ContentOptions;
+    /**
+     * Localized text, textarea and rich text fields that are empty in a language but filled in the
+     * default one. One finding per document and language. Needs Payload's `localization`.
+     */
+    translations?: boolean;
 };
 export type ContentHealthPluginOptions = {
     /** Collection slugs and the checks to run on each. */

package/dist/types.js

@@ -9,4 +9,5 @@ export const CHECK_IDS = [
     "content.h1-multiple",
     "content.heading-skip",
     "content.thin",
+    "content.untranslated",
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simmalugnt-se/payload-content-health",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Content health checks and dashboard widgets for Payload Admin: alt texts, SEO fields and more",
   "keywords": [
     "payload",