@simmalugnt-se/payload-content-health 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.1.0
+
+- First release: `contentHealthPlugin` with checks for missing alt text on images and for meta
+  titles, descriptions and share images (defaults follow `@payloadcms/plugin-seo`), per locale for
+  localized fields.
+- Page body checks with `content`: missing H1, more than one H1, skipped heading levels (block
+  heading levels from a per-block map, rich text headings by their tag) and thin content (default
+  under 300 words).
+- Dashboard widget `content-health` listing findings per check, linking to each document in the
+  right locale.
+- `scanContentHealth` runs the configured checks with a user's access.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simmalugnt AB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# @simmalugnt-se/payload-content-health
+
+Deterministic content checks for Payload, shown as a dashboard widget: images without alt text,
+missing or badly sized meta titles and descriptions, and pages without a share image. No AI; every
+finding points at one field of one document, in one locale when the field is localized.
+
+Requires Payload `>=3.90.2 <4` and React 19. The widget uses Payload's modular dashboard
+(`admin.dashboard.widgets`), which Payload still marks as experimental.
+
+## Setup
+
+1. Install:
+
+   ```bash
+   pnpm add @simmalugnt-se/payload-content-health
+   ```
+
+2. Choose the checks per collection, then regenerate the import map:
+
+   ```ts
+   import { contentHealthPlugin } from "@simmalugnt-se/payload-content-health";
+
+   plugins: [
+     seoPlugin({ collections: ["pages"], uploadsCollection: "media" }),
+     contentHealthPlugin({
+       collections: {
+         pages: { seo: true },
+         media: { altText: true },
+       },
+     }),
+   ];
+   ```
+
+   ```bash
+   pnpm payload generate:importmap
+   ```
+
+## Checks
+
+| Check                     | Option              | Finds                                          |
+| ------------------------- | ------------------- | ---------------------------------------------- |
+| `media.alt-missing`       | `altText`           | Images (`image/*`) with an empty alt field     |
+| `seo.title-missing`       | `seo`               | Empty meta title                               |
+| `seo.title-length`        | `seo`               | Meta title outside 50–60 characters            |
+| `seo.description-missing` | `seo`               | Empty meta description                         |
+| `seo.description-length`  | `seo`               | Meta description outside 100–150 characters    |
+| `seo.image-missing`       | `seo`               | No share image                                 |
+| `content.h1-missing`      | `content.headings`  | No H1 on the page                              |
+| `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               |
+
+`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:
+
+```ts
+pages: {
+  seo: {
+    description: "seo.summary",
+    descriptionLength: { min: 80, max: 160 },
+    image: false,
+  },
+},
+media: { altText: { field: "altText" } },
+```
+
+### Page body
+
+`content` points at the blocks or rich text field holding the page body. Word counts cover every
+text, textarea and rich text field in it. Only the frontend knows which block field it renders as
+which heading, so the heading checks need a map of levels per block; headings inside rich text count
+by their own tag. Array fields fan out, so `"items.title": 3` makes every item's title an H3:
+
+```ts
+pages: {
+  content: {
+    field: "layout",
+    headings: {
+      hero: { headline: 1 },
+      cards: { heading: 2, "items.title": 3 },
+    },
+    minWords: 300, // or false
+  },
+},
+```
+
+Each page gets at most one finding per check: the first skipped level, the second H1.
+
+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.
+
+## Dashboard widget
+
+The plugin registers the widget `content-health`. When the project sets no
+`admin.dashboard.defaultLayout`, the plugin sets one with Payload's collection cards followed by the
+widget. Payload keeps each editor's own layout as a preference once they edit the dashboard; they add
+the widget from the dashboard's edit mode, and can limit it to some checks in its settings.
+
+Pass `addToDefaultLayout: false` to only register the widget.
+
+## Running the checks yourself
+
+```ts
+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?, status? }`. `problems`
+lists configured checks that could not run, such as a field path that does not exist.

package/dist/checks.d.ts

@@ -0,0 +1,73 @@
+import type { ContentSchema } from "./fields.ts";
+import type { CheckId, CollectionHealthOptions, Finding, HeadingLevels, LengthRange } from "./types.ts";
+export declare const SEO_DEFAULTS: {
+    readonly title: "meta.title";
+    readonly description: "meta.description";
+    readonly image: "meta.image";
+    readonly titleLength: {
+        readonly min: 50;
+        readonly max: 60;
+    };
+    readonly descriptionLength: {
+        readonly min: 100;
+        readonly max: 150;
+    };
+};
+export declare const DEFAULT_MIN_WORDS = 300;
+export type FieldRule = {
+    check: CheckId;
+    kind: "required";
+    path: string;
+    imagesOnly?: boolean;
+} | {
+    check: CheckId;
+    kind: "length";
+    path: string;
+    range: LengthRange;
+}
+/** Heading checks on the page body at `path`: missing H1, several H1s, skipped levels. */
+ | {
+    check: CheckId;
+    kind: "outline";
+    path: string;
+    headings: HeadingLevels;
+} | {
+    check: CheckId;
+    kind: "words";
+    path: string;
+    min: number;
+};
+/**
+ * A rule with what the collection's config says about its field; page body rules also carry where
+ * the body keeps its text.
+ */
+export type ResolvedRule = FieldRule & {
+    localized: boolean;
+    content?: ContentSchema;
+};
+export declare function rulesFor(options: CollectionHealthOptions): FieldRule[];
+export type DocumentInput = {
+    collection: string;
+    doc: Record<string, unknown>;
+    rules: ResolvedRule[];
+    title: string;
+    /** The locale the document was read in; unset without localization. */
+    locale?: string;
+    /**
+     * Run the rules on fields that are not localized too. The scan reads a document once per locale,
+     * so it sets this on the first read only and those fields are reported once.
+     */
+    includeUnlocalized: boolean;
+};
+export type DocumentResult = {
+    findings: Finding[];
+    /**
+     * One entry per field value a check applied to: images only for alt text, non-empty values only
+     * for lengths. With the findings this gives each check's share of values in order.
+     */
+    checked: CheckId[];
+};
+export declare function checkDocument(input: DocumentInput): DocumentResult;
+/** What the admin shows as the document's name; an image without alt text still needs one. */
+export declare function documentTitle(doc: Record<string, unknown>, useAsTitle: string | undefined): string;
+export declare function valueAt(doc: unknown, path: string): unknown;

package/dist/checks.js

@@ -0,0 +1,175 @@
+/**
+ * The check engine: plain functions over documents as the Local API returns them, read in one
+ * locale at a time. Nothing here talks to Payload, so every check is testable on its own.
+ */
+import { readContent } from "./content.js";
+export const SEO_DEFAULTS = {
+    title: "meta.title",
+    description: "meta.description",
+    image: "meta.image",
+    titleLength: { min: 50, max: 60 },
+    descriptionLength: { min: 100, max: 150 },
+};
+export const DEFAULT_MIN_WORDS = 300;
+export function rulesFor(options) {
+    const rules = [];
+    if (options.altText) {
+        const field = (options.altText === true ? undefined : options.altText.field) ?? "alt";
+        rules.push({ check: "media.alt-missing", kind: "required", path: field, imagesOnly: true });
+    }
+    if (options.seo) {
+        const seo = options.seo === true ? {} : options.seo;
+        const title = seo.title ?? SEO_DEFAULTS.title;
+        const description = seo.description ?? SEO_DEFAULTS.description;
+        const image = seo.image ?? SEO_DEFAULTS.image;
+        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 });
+            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 });
+            if (descriptionLength) {
+                rules.push({
+                    check: "seo.description-length",
+                    kind: "length",
+                    path: description,
+                    range: descriptionLength,
+                });
+            }
+        }
+        if (image) {
+            rules.push({ check: "seo.image-missing", kind: "required", path: image });
+        }
+    }
+    if (options.content) {
+        const { field, headings, minWords = DEFAULT_MIN_WORDS } = options.content;
+        if (headings) {
+            for (const check of ["content.h1-missing", "content.h1-multiple", "content.heading-skip"]) {
+                rules.push({ check: check, kind: "outline", path: field, headings });
+            }
+        }
+        if (minWords !== false) {
+            rules.push({ check: "content.thin", kind: "words", path: field, min: minWords });
+        }
+    }
+    return rules;
+}
+export function checkDocument(input) {
+    const { collection, doc, locale, title } = input;
+    const id = doc.id;
+    const status = doc._status === "draft" || doc._status === "published" ? doc._status : undefined;
+    const findings = [];
+    const checked = [];
+    const bodies = new Map();
+    // The word count and the heading checks read the same body once, with the heading levels.
+    const body = (rule) => {
+        let content = bodies.get(rule.path);
+        if (!content) {
+            const outline = input.rules.find((other) => other.kind === "outline" && other.path === rule.path);
+            content = rule.content
+                ? readContent(valueAt(doc, rule.path), rule.path, rule.content, outline?.headings)
+                : { headings: [], words: 0 };
+            bodies.set(rule.path, content);
+        }
+        return content;
+    };
+    for (const rule of input.rules) {
+        if (!rule.localized && !input.includeUnlocalized) {
+            continue;
+        }
+        const base = {
+            check: rule.check,
+            collection,
+            id,
+            title,
+            path: rule.path,
+            ...(rule.localized && locale ? { locale } : {}),
+            ...(status ? { status } : {}),
+        };
+        if (rule.kind === "outline" || rule.kind === "words") {
+            checked.push(rule.check);
+            const finding = checkBody(rule, body(rule), base);
+            if (finding) {
+                findings.push(finding);
+            }
+            continue;
+        }
+        const value = valueAt(doc, rule.path);
+        if (rule.kind === "required") {
+            if (rule.imagesOnly && !isImage(doc)) {
+                continue;
+            }
+            checked.push(rule.check);
+            if (isEmpty(value)) {
+                findings.push(base);
+            }
+            continue;
+        }
+        if (typeof value !== "string" || isEmpty(value)) {
+            continue;
+        }
+        checked.push(rule.check);
+        const actual = [...value.trim()].length;
+        if (actual < rule.range.min || actual > rule.range.max) {
+            findings.push({ ...base, length: { ...rule.range, actual } });
+        }
+    }
+    return { findings, checked };
+}
+/** At most one finding per document and check, so counts are documents, like the other checks. */
+function checkBody(rule, { headings, words }, base) {
+    if (rule.kind === "words") {
+        return words < rule.min ? { ...base, words: { actual: words, min: rule.min } } : undefined;
+    }
+    const h1s = headings.filter((heading) => heading.level === 1);
+    switch (rule.check) {
+        case "content.h1-missing":
+            return h1s.length ? undefined : base;
+        case "content.h1-multiple": {
+            const second = h1s[1];
+            return second
+                ? { ...base, path: second.path, heading: { level: 1, count: h1s.length } }
+                : undefined;
+        }
+        case "content.heading-skip": {
+            for (const [index, heading] of headings.entries()) {
+                const previous = headings[index - 1]?.level;
+                if (previous !== undefined && heading.level > previous + 1) {
+                    return { ...base, path: heading.path, heading: { level: heading.level, previous } };
+                }
+            }
+            return undefined;
+        }
+        default:
+            return undefined;
+    }
+}
+/** What the admin shows as the document's name; an image without alt text still needs one. */
+export function documentTitle(doc, useAsTitle) {
+    for (const candidate of [useAsTitle && valueAt(doc, useAsTitle), doc.filename]) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return String(doc.id);
+}
+export function valueAt(doc, path) {
+    let value = doc;
+    for (const segment of path.split(".")) {
+        if (value === null || typeof value !== "object") {
+            return undefined;
+        }
+        value = value[segment];
+    }
+    return value;
+}
+function isEmpty(value) {
+    return value === undefined || value === null || (typeof value === "string" && !value.trim());
+}
+function isImage(doc) {
+    return typeof doc.mimeType === "string" && doc.mimeType.startsWith("image/");
+}

package/dist/content.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Reads a page body as a reader sees it: its headings in order, with their levels, and its word
+ * count. Block fields get their level from the project's heading map; rich text headings carry
+ * their own tag.
+ */
+import type { ContentSchema } from "./fields.ts";
+import type { HeadingLevels } from "./types.ts";
+export type Heading = {
+    level: number;
+    text: string;
+    /** Form path of the field holding the heading, e.g. `layout.1.heading`. */
+    path: string;
+};
+export type PageContent = {
+    headings: Heading[];
+    words: number;
+};
+export declare function readContent(value: unknown, root: string, schema: ContentSchema, headingLevels?: HeadingLevels): PageContent;
+/** Values at a dot path, one per array item on the way, with their concrete paths. */
+export declare function fanOut(value: unknown, path: string): {
+    path: string;
+    value: unknown;
+}[];
+export declare function countWords(text: string): number;

package/dist/content.js

@@ -0,0 +1,91 @@
+export function readContent(value, root, schema, headingLevels = {}) {
+    const content = { headings: [], words: 0 };
+    if (schema.kind === "richText") {
+        readLexical(value, root, content);
+        return content;
+    }
+    if (!Array.isArray(value)) {
+        return content;
+    }
+    for (const [index, block] of value.entries()) {
+        const blockType = block?.blockType;
+        if (typeof blockType !== "string") {
+            continue;
+        }
+        const levels = headingLevels[blockType] ?? {};
+        for (const field of schema.blocks[blockType] ?? []) {
+            for (const { path, value: fieldValue } of fanOut(block, field.path)) {
+                const fullPath = `${root}.${index}.${path}`;
+                if (field.kind === "richText") {
+                    readLexical(fieldValue, fullPath, content);
+                    continue;
+                }
+                if (typeof fieldValue !== "string" || !fieldValue.trim()) {
+                    continue;
+                }
+                content.words += countWords(fieldValue);
+                const level = levels[field.path];
+                if (level) {
+                    content.headings.push({ level, text: fieldValue.trim(), path: fullPath });
+                }
+            }
+        }
+    }
+    return content;
+}
+/** Values at a dot path, one per array item on the way, with their concrete paths. */
+export function fanOut(value, path) {
+    let current = [{ path: "", value }];
+    for (const segment of path.split(".")) {
+        const next = [];
+        for (const entry of current) {
+            const items = Array.isArray(entry.value)
+                ? entry.value.map((item, index) => ({ path: join(entry.path, String(index)), value: item }))
+                : [entry];
+            for (const item of items) {
+                if (item.value !== null && typeof item.value === "object") {
+                    next.push({
+                        path: join(item.path, segment),
+                        value: item.value[segment],
+                    });
+                }
+            }
+        }
+        current = next;
+    }
+    return current;
+}
+function readLexical(value, path, content) {
+    const root = value?.root;
+    if (root) {
+        walk(root);
+    }
+    function walk(node) {
+        if (node.type === "text" && typeof node.text === "string") {
+            content.words += countWords(node.text);
+        }
+        if (node.type === "heading" && typeof node.tag === "string" && /^h[1-6]$/.test(node.tag)) {
+            const text = textOf(node).trim();
+            if (text) {
+                content.headings.push({ level: Number(node.tag.slice(1)), text, path });
+            }
+        }
+        if (Array.isArray(node.children)) {
+            for (const child of node.children) {
+                walk(child);
+            }
+        }
+    }
+}
+function textOf(node) {
+    if (typeof node.text === "string") {
+        return node.text;
+    }
+    return Array.isArray(node.children) ? node.children.map(textOf).join("") : "";
+}
+export function countWords(text) {
+    return text.match(/[\p{L}\p{N}]+(?:['’-][\p{L}\p{N}]+)*/gu)?.length ?? 0;
+}
+function join(base, segment) {
+    return base ? `${base}.${segment}` : segment;
+}

package/dist/copy.d.ts

@@ -0,0 +1,45 @@
+/** Everything the widget says, in Admin's language. */
+import type { CheckId } from "./types.ts";
+export type UiLanguage = "sv" | "en";
+export declare function uiLanguage(adminLanguage: string | undefined): UiLanguage;
+export declare const CHECK_LABELS: Record<UiLanguage, Record<CheckId, string>>;
+/** Tile headings: what is measured, so "0 of 4 filled in" reads without a double negative. */
+export declare const TILE_LABELS: Record<UiLanguage, Record<CheckId, string>>;
+type Status = (ok: number, total: number) => string;
+/** A tile's "x of y" line, phrased as what is in order for that check. */
+export declare const STATUS: Record<UiLanguage, Record<CheckId, Status>>;
+export declare const COPY: {
+    readonly en: {
+        readonly title: "Content health";
+        readonly summary: (withIssues: number, checked: number) => string;
+        readonly allGood: "No issues found.";
+        readonly overall: "of everything checked is in order";
+        readonly ok: (ok: number, total: number) => string;
+        readonly checkPasses: "All good";
+        readonly nothingYet: "Nothing to measure yet";
+        readonly passing: (count: number) => string;
+        readonly more: (count: number) => string;
+        readonly length: (actual: number, min: number, max: number) => string;
+        readonly headingSkip: (previous: number, level: number) => string;
+        readonly h1Count: (count: number) => string;
+        readonly words: (actual: number, min: number) => string;
+        readonly problems: "Some checks could not run:";
+    };
+    readonly sv: {
+        readonly title: "Innehållshälsa";
+        readonly summary: (withIssues: number, checked: number) => string;
+        readonly allGood: "Inga problem hittades.";
+        readonly overall: "av allt som kontrolleras är i ordning";
+        readonly ok: (ok: number, total: number) => string;
+        readonly checkPasses: "Allt i ordning";
+        readonly nothingYet: "Inget att mäta än";
+        readonly passing: (count: number) => string;
+        readonly more: (count: number) => string;
+        readonly length: (actual: number, min: number, max: number) => string;
+        readonly headingSkip: (previous: number, level: number) => string;
+        readonly h1Count: (count: number) => string;
+        readonly words: (actual: number, min: number) => string;
+        readonly problems: "Några kontroller kunde inte köras:";
+    };
+};
+export {};

package/dist/copy.js

@@ -0,0 +1,117 @@
+export function uiLanguage(adminLanguage) {
+    return adminLanguage?.startsWith("sv") ? "sv" : "en";
+}
+export const CHECK_LABELS = {
+    en: {
+        "media.alt-missing": "Missing alt text",
+        "seo.title-missing": "Missing meta title",
+        "seo.title-length": "Meta title length",
+        "seo.description-missing": "Missing meta description",
+        "seo.description-length": "Meta description length",
+        "seo.image-missing": "Missing share image",
+        "content.h1-missing": "Missing H1",
+        "content.h1-multiple": "More than one H1",
+        "content.heading-skip": "Skipped heading levels",
+        "content.thin": "Thin content",
+    },
+    sv: {
+        "media.alt-missing": "Alt-text saknas",
+        "seo.title-missing": "Metatitel saknas",
+        "seo.title-length": "Metatitelns längd",
+        "seo.description-missing": "Metabeskrivning saknas",
+        "seo.description-length": "Metabeskrivningens längd",
+        "seo.image-missing": "Delningsbild saknas",
+        "content.h1-missing": "H1 saknas",
+        "content.h1-multiple": "Fler än en H1",
+        "content.heading-skip": "Överhoppade rubriknivåer",
+        "content.thin": "Tunt innehåll",
+    },
+};
+/** Tile headings: what is measured, so "0 of 4 filled in" reads without a double negative. */
+export const TILE_LABELS = {
+    en: {
+        "media.alt-missing": "Alt texts",
+        "seo.title-missing": "Meta titles",
+        "seo.title-length": "Meta title length",
+        "seo.description-missing": "Meta descriptions",
+        "seo.description-length": "Meta description length",
+        "seo.image-missing": "Share images",
+        "content.h1-missing": "Main heading",
+        "content.h1-multiple": "Single main heading",
+        "content.heading-skip": "Heading order",
+        "content.thin": "Page length",
+    },
+    sv: {
+        "media.alt-missing": "Alt-texter",
+        "seo.title-missing": "Metatitlar",
+        "seo.title-length": "Metatitlarnas längd",
+        "seo.description-missing": "Metabeskrivningar",
+        "seo.description-length": "Metabeskrivningarnas längd",
+        "seo.image-missing": "Delningsbilder",
+        "content.h1-missing": "Huvudrubrik",
+        "content.h1-multiple": "En huvudrubrik",
+        "content.heading-skip": "Rubrikordning",
+        "content.thin": "Sidlängd",
+    },
+};
+/** A tile's "x of y" line, phrased as what is in order for that check. */
+export const STATUS = {
+    en: {
+        "media.alt-missing": (ok, total) => `${ok} of ${total} filled in`,
+        "seo.title-missing": (ok, total) => `${ok} of ${total} filled in`,
+        "seo.title-length": (ok, total) => `${ok} of ${total} the right length`,
+        "seo.description-missing": (ok, total) => `${ok} of ${total} filled in`,
+        "seo.description-length": (ok, total) => `${ok} of ${total} the right length`,
+        "seo.image-missing": (ok, total) => `${ok} of ${total} filled in`,
+        "content.h1-missing": (ok, total) => `${ok} of ${total} pages have an H1`,
+        "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`,
+    },
+    sv: {
+        "media.alt-missing": (ok, total) => `${ok} av ${total} ifyllda`,
+        "seo.title-missing": (ok, total) => `${ok} av ${total} ifyllda`,
+        "seo.title-length": (ok, total) => `${ok} av ${total} med rätt längd`,
+        "seo.description-missing": (ok, total) => `${ok} av ${total} ifyllda`,
+        "seo.description-length": (ok, total) => `${ok} av ${total} med rätt längd`,
+        "seo.image-missing": (ok, total) => `${ok} av ${total} ifyllda`,
+        "content.h1-missing": (ok, total) => `${ok} av ${total} sidor har en H1`,
+        "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`,
+    },
+};
+export const COPY = {
+    en: {
+        title: "Content health",
+        summary: (withIssues, checked) => `${withIssues} of ${checked} documents need attention`,
+        allGood: "No issues found.",
+        overall: "of everything checked is in order",
+        ok: (ok, total) => `${ok} of ${total} OK`,
+        checkPasses: "All good",
+        nothingYet: "Nothing to measure yet",
+        passing: (count) => `${count} ${count === 1 ? "check passes" : "checks pass"}`,
+        more: (count) => `${count} more`,
+        length: (actual, min, max) => `${actual} characters, aim for ${min}–${max}`,
+        headingSkip: (previous, level) => `H${previous} → H${level}`,
+        h1Count: (count) => `${count} H1s`,
+        words: (actual, min) => `${actual} ${actual === 1 ? "word" : "words"}, aim for ${min}+`,
+        problems: "Some checks could not run:",
+    },
+    sv: {
+        title: "Innehållshälsa",
+        summary: (withIssues, checked) => `${withIssues} av ${checked} dokument behöver åtgärdas`,
+        allGood: "Inga problem hittades.",
+        overall: "av allt som kontrolleras är i ordning",
+        ok: (ok, total) => `${ok} av ${total} OK`,
+        checkPasses: "Allt i ordning",
+        nothingYet: "Inget att mäta än",
+        passing: (count) => `${count} ${count === 1 ? "kontroll godkänd" : "kontroller godkända"}`,
+        more: (count) => `${count} till`,
+        length: (actual, min, max) => `${actual} tecken, sikta på ${min}–${max}`,
+        headingSkip: (previous, level) => `H${previous} → H${level}`,
+        h1Count: (count) => `${count} H1:or`,
+        words: (actual, min) => `${actual} ord, sikta på minst ${min}`,
+        problems: "Några kontroller kunde inte köras:",
+    },
+};

package/dist/exports/rsc.d.ts

@@ -0,0 +1 @@
+export { ContentHealthWidget } from "../widget/ContentHealthWidget.tsx";