@jant/core 0.6.16 → 0.7.0

package/src/ui/dash/settings/__tests__/GeneralContent.test.tsx

@@ -11,8 +11,9 @@ async function loadGeneralContent() {
 
 function renderGeneralContent(
   props: Parameters<Awaited<ReturnType<typeof loadGeneralContent>>>[0],
+  locale: Parameters<typeof createI18n>[0] = "en",
 ) {
-  const i18n = createI18n("en");
+  const i18n = createI18n(locale);
   const c = {
     get(key: string) {
       if (key === "i18n") return i18n;
@@ -36,9 +37,6 @@ function createProps(
   return {
     siteName: "My Blog",
     siteDescription: "A test blog",
-    siteLanguage: "en",
-    dashboardLanguage: "en",
-    cjkSerifFont: "off",
     siteNameFallback: "Fallback Name",
     siteDescriptionFallback: "Fallback Description",
     mainRssFeed: "featured" as const,
@@ -50,6 +48,30 @@ function createProps(
     siteFooter: "Footer text",
     showJantBrandingOnHome: false,
     noindex: false,
+    discover: "",
+    // The deployment has no answer of its own; a self-hosted site opts in.
+    discoverDefault: "" as const,
+    discoverPages: {
+      home: "https://jant.me/discover",
+      links: "https://jant.me/links",
+      quotes: "https://jant.me/quotes",
+      rules: "https://jant.me/discover/about",
+    },
+    discoverStatus: {
+      announced: true,
+      announceError: null,
+      announceAt: STALE_ANNOUNCE_AT,
+      hasDirectory: true,
+      managedByHost: false,
+      submitUrl: "https://jant.me/discover/submit",
+      declaredMode: "latest" as const,
+      publicPostCount: 5,
+      featuredPostCount: 2,
+      established: true,
+      minPublicPosts: 1,
+      firstReadMaxHours: 6,
+    },
+    rssFeedsEnabled: true,
     demoMode,
     aboutPage: {
       state: "missing" as const,
@@ -69,6 +91,12 @@ function createProps(
   };
 }
 
+// The first-read line is the one status sentence that expires, so the fixtures
+// place the announcement relative to the clock rather than on a fixed date that
+// drifts in and out of the window as time passes.
+const STALE_ANNOUNCE_AT = Math.floor(Date.now() / 1000) - 7 * 24 * 3600;
+const FRESH_ANNOUNCE_AT = Math.floor(Date.now() / 1000) - 60;
+
 describe("GeneralContent", () => {
   it("omits the demo-mode attribute when demo mode is disabled", async () => {
     const html = await renderGeneralContent(createProps(false));
@@ -81,4 +109,296 @@ describe("GeneralContent", () => {
 
     expect(html).toMatch(/<jant-settings-general[^>]*demo-mode(?:=|\s|>)/);
   });
+
+  // The client turns the name and the rules into links by finding them in the
+  // help line, so the labels have to agree with the sentence character for
+  // character. A translation that reworded one and not the other would only
+  // lose that link, but this catches it here rather than in a screenshot.
+  it("carries every linked term verbatim inside the help line", async () => {
+    const html = await renderGeneralContent(createProps(false));
+
+    expect(html).toContain(
+      "Jant Discover is a directory of Jant blogs, curated by hand by the Jant community",
+    );
+    expect(html).toContain(
+      "appear on the Links and Quotes lists 24 hours after they are published",
+    );
+    expect(html).toContain("See the Discover community rules.");
+    expect(html).toContain(
+      "&quot;discoverName&quot;:&quot;Jant Discover&quot;",
+    );
+    expect(html).toContain(
+      "&quot;discoverRules&quot;:&quot;Discover community rules&quot;",
+    );
+  });
+
+  // Translations are written by hand or by a model, and one that rewords a
+  // placeholder's value, or drops the placeholder, loses that link without a
+  // word. Every catalog has to keep all four runs verbatim.
+  it.each(["en", "zh-Hans", "zh-Hant"] as const)(
+    "keeps every linked term inside the %s help line",
+    async (locale) => {
+      const html = await renderGeneralContent(createProps(false), locale);
+      const attribute = /<jant-settings-general[^>]*\slabels="([^"]*)"/.exec(
+        html,
+      )?.[1];
+      const labels = JSON.parse(
+        (attribute ?? "{}").replaceAll("&quot;", '"').replaceAll("&amp;", "&"),
+      ) as Record<string, string>;
+      const intro = labels["discoverIntro"] ?? "";
+
+      for (const term of [
+        labels["discoverName"],
+        "Links",
+        "Quotes",
+        labels["discoverRules"],
+      ]) {
+        expect(term).toBeTruthy();
+        expect(intro).toContain(term);
+      }
+      // And the delay, so an author knows how long they have to edit.
+      expect(intro).toContain("24");
+    },
+  );
+
+  it("hands the browser every page the help line links to", async () => {
+    const html = await renderGeneralContent(createProps(false));
+
+    expect(html).toContain(
+      'discover-pages="{&quot;home&quot;:&quot;https://jant.me/discover&quot;,&quot;links&quot;:&quot;https://jant.me/links&quot;,&quot;quotes&quot;:&quot;https://jant.me/quotes&quot;,&quot;rules&quot;:&quot;https://jant.me/discover/about&quot;}"',
+    );
+  });
+
+  // No directory, no addresses: the help line then renders as plain text.
+  it("omits the directory's pages when none is configured", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, { discoverPages: null }),
+    );
+
+    expect(html).not.toContain("discover-pages");
+  });
+
+  // The browser decides what the site declares, because two of the inputs are
+  // controls on this page. Resolving `noindex` into the default here would put
+  // that decision back on the server and freeze it at page load — the checkbox
+  // would then go on claiming a listing the feed had already dropped.
+  it("hands the browser the deployment default with noindex unresolved", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, { discoverDefault: "latest", noindex: true }),
+    );
+
+    expect(html).toContain('discover-default="latest"');
+  });
+
+  // The controls above the block already say that the site is listed and what
+  // its feed declares, and a site past the directory's threshold has nothing
+  // to do about being past it. A site in that state is told nothing at all.
+  it("says nothing when the setting is already doing what it says", async () => {
+    const html = await renderGeneralContent(createProps(false));
+
+    expect(html).toContain('discover-status="{&quot;lines&quot;:[]');
+    // Nothing failed, so neither the retry nor the manual form is offered.
+    expect(html).toContain("&quot;showAnnounce&quot;:false");
+    expect(html).toContain("&quot;submitUrl&quot;:null");
+  });
+
+  // The status sentences carry runtime numbers, so they are translated on the
+  // server rather than in the browser. What reaches the component is finished
+  // text — and this one only for as long as the answer is outstanding.
+  it("confirms an announcement while its first read is still due", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          ...createProps(false).discoverStatus,
+          announceAt: FRESH_ANNOUNCE_AT,
+        },
+      }),
+    );
+
+    expect(html).toContain(
+      "Feed address sent. A directory reads a newly announced feed within 6 hours.",
+    );
+  });
+
+  // An opt-in that cannot take effect is worth saying, because the ticked box
+  // above claims the opposite.
+  it("says the opt-in is not yet effective without a public post", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          ...createProps(false).discoverStatus,
+          publicPostCount: 0,
+          featuredPostCount: 0,
+          established: false,
+        },
+      }),
+    );
+
+    expect(html).toContain(
+      "Nothing published yet. jant.me lists a blog once it has one public post.",
+    );
+  });
+
+  it("says a featured-only feed has nothing to carry", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          ...createProps(false).discoverStatus,
+          declaredMode: "featured" as const,
+          featuredPostCount: 0,
+        },
+      }),
+    );
+
+    expect(html).toContain("no post is marked Featured");
+  });
+
+  it("offers the manual form only when the announcement failed", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          announced: false,
+          announceError: "The directory answered 503.",
+          announceAt: STALE_ANNOUNCE_AT,
+          hasDirectory: true,
+          managedByHost: false,
+          submitUrl: "https://jant.me/discover/submit",
+          declaredMode: "latest",
+          publicPostCount: 5,
+          featuredPostCount: 2,
+          established: true,
+          minPublicPosts: 1,
+          firstReadMaxHours: 6,
+        },
+      }),
+    );
+
+    expect(html).toContain(
+      "The directory could not be reached: The directory answered 503.",
+    );
+    expect(html).toContain("&quot;showAnnounce&quot;:true");
+    expect(html).toContain("https://jant.me/discover/submit");
+  });
+
+  // A site whose mode came from the deployment's own default declares itself
+  // without ever having announced. Nothing else on the page sends the address
+  // now that the section saves on change, so the button has to.
+  it("offers the announcement to a site that has never made one", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          announced: null,
+          announceError: null,
+          announceAt: null,
+          hasDirectory: true,
+          managedByHost: false,
+          submitUrl: "https://jant.me/discover/submit",
+          declaredMode: "latest",
+          publicPostCount: 5,
+          featuredPostCount: 2,
+          established: true,
+          minPublicPosts: 1,
+          firstReadMaxHours: 6,
+        },
+      }),
+    );
+
+    expect(html).toContain(
+      "Not announced yet. No directory has been told this site exists.",
+    );
+    expect(html).toContain("&quot;showAnnounce&quot;:true");
+    // The manual form stays with the failure it belongs to.
+    expect(html).toContain("&quot;submitUrl&quot;:null");
+  });
+
+  it("reports nothing at all when the feed declares none", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          announced: null,
+          announceError: null,
+          announceAt: null,
+          hasDirectory: true,
+          managedByHost: false,
+          submitUrl: "https://jant.me/discover/submit",
+          declaredMode: "none",
+          publicPostCount: 5,
+          featuredPostCount: 2,
+          established: true,
+          minPublicPosts: 1,
+          firstReadMaxHours: 6,
+        },
+      }),
+    );
+
+    // A site that is not listed is told nothing: not that it is not listed —
+    // the unticked checkbox says that — not how close it is to a threshold it
+    // has opted out of, and not whether an announcement it never made got
+    // through. With no lines the component drops the whole block.
+    expect(html).toContain('discover-status="{&quot;lines&quot;:[]');
+    expect(html).not.toContain("Not announced yet");
+    expect(html).not.toContain("jant.me lists a blog once");
+    expect(html).toContain("&quot;showAnnounce&quot;:false");
+  });
+
+  // The announcement answers "does the directory know my address". A blog on
+  // a hosted platform never has to ask: the control plane enrols its whole
+  // fleet, so an owner who has never touched this control is already listed,
+  // and telling them otherwise sends them after a task that does not exist.
+  it("says nothing about announcing on a hosted blog", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          announced: null,
+          announceError: null,
+          announceAt: null,
+          hasDirectory: true,
+          managedByHost: true,
+          submitUrl: "https://jant.me/discover/submit",
+          declaredMode: "latest",
+          publicPostCount: 5,
+          featuredPostCount: 2,
+          established: true,
+          minPublicPosts: 1,
+          firstReadMaxHours: 6,
+        },
+      }),
+    );
+
+    expect(html).not.toContain("Not announced yet");
+    expect(html).not.toContain("https://jant.me/discover/submit");
+    expect(html).toContain("&quot;showAnnounce&quot;:false");
+    expect(html).toContain("&quot;submitUrl&quot;:null");
+    // Nothing is left: the announcement was the only part of this block a
+    // hosted owner could ever have acted on.
+    expect(html).toContain('discover-status="{&quot;lines&quot;:[]');
+  });
+
+  // A failed announcement is the one case that used to leave a hosted owner
+  // reading an error about their own host's plumbing, with a Retry and a
+  // manual submission form for a directory that already has them.
+  it("hides the retry and the manual form on a hosted blog", async () => {
+    const html = await renderGeneralContent(
+      createProps(false, {
+        discoverStatus: {
+          announced: false,
+          announceError: "The directory answered 503.",
+          announceAt: STALE_ANNOUNCE_AT,
+          hasDirectory: true,
+          managedByHost: true,
+          submitUrl: "https://jant.me/discover/submit",
+          declaredMode: "latest",
+          publicPostCount: 5,
+          featuredPostCount: 2,
+          established: true,
+          minPublicPosts: 1,
+          firstReadMaxHours: 6,
+        },
+      }),
+    );
+
+    expect(html).not.toContain("The directory could not be reached");
+    expect(html).toContain("&quot;showAnnounce&quot;:false");
+    expect(html).toContain("&quot;submitUrl&quot;:null");
+  });
 });

package/src/ui/dash/settings/__tests__/LanguageContent.test.tsx

@@ -0,0 +1,144 @@
+import type { Context } from "hono";
+import { renderToString } from "hono/jsx/dom/server";
+import { describe, expect, it } from "vitest";
+import { I18nProvider } from "../../../../i18n/context.js";
+import { createI18n } from "../../../../i18n/i18n.js";
+
+async function loadLanguageContent() {
+  const { LanguageContent } = await import("../LanguageContent.js");
+  return LanguageContent;
+}
+
+type LanguageContentProps = Parameters<
+  Awaited<ReturnType<typeof loadLanguageContent>>
+>[0];
+
+function renderLanguageContent(overrides: Partial<LanguageContentProps> = {}) {
+  const i18n = createI18n("en");
+  const c = {
+    get(key: string) {
+      if (key === "i18n") return i18n;
+      return undefined;
+    },
+  } as unknown as Context;
+
+  I18nProvider({ c, children: "" });
+
+  return loadLanguageContent().then((LanguageContent) =>
+    renderToString(
+      LanguageContent({
+        contentLanguage: "zh-Hans",
+        dashboardLanguage: "en",
+        multilingualEnabled: false,
+        additionalLanguages: [],
+        unmarkedPostCount: 0,
+        sitePathPrefix: "",
+        ...overrides,
+      }),
+    ),
+  );
+}
+
+/** Pull the JSON blob the component reads its translated copy from. */
+function readLabels(html: string): Record<string, string> {
+  const match = /labels="([^"]*)"/.exec(html);
+  if (!match?.[1]) throw new Error("expected a labels attribute");
+  const decoded = match[1]
+    .replace(/&quot;/g, '"')
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&#39;/g, "'");
+  return JSON.parse(decoded) as Record<string, string>;
+}
+
+describe("LanguageContent", () => {
+  it("mounts the Lit element with an initial-state payload", async () => {
+    const html = await renderLanguageContent({
+      multilingualEnabled: true,
+      additionalLanguages: ["en", "ja"],
+      unmarkedPostCount: 3,
+      sitePathPrefix: "/blog",
+    });
+
+    expect(html).toContain("<jant-settings-language");
+    const state = /id="language-settings-initial-data">(.*?)<\/script>/s.exec(
+      html,
+    );
+    expect(state?.[1]).toBeDefined();
+    expect(JSON.parse(state?.[1] ?? "{}")).toEqual({
+      contentLanguage: "zh-Hans",
+      dashboardLanguage: "en",
+      multilingualEnabled: true,
+      additionalLanguages: ["en", "ja"],
+      unmarkedPostCount: 3,
+      sitePathPrefix: "/blog",
+      // The browser bundle cannot resolve the docs host, so the server sends it.
+      multilingualDocsUrl: "https://jant.me/docs/multilingual",
+    });
+  });
+
+  // Lingui resolves an ICU message completely at `i18n._()` time, so any
+  // plural has to be formatted here — a template shipped to the browser would
+  // be formatted against an undefined count and render "NaN".
+  describe("copy that carries runtime values", () => {
+    it("resolves the plural against the real post count", async () => {
+      const labels = readLabels(
+        await renderLanguageContent({
+          unmarkedPostCount: 347,
+        }),
+      );
+
+      expect(labels.enableMarkWarning).toContain("347 existing posts");
+      expect(labels.enableMarkWarning).not.toContain("NaN");
+      expect(labels.enableMarkWarning).not.toContain("plural");
+    });
+
+    it("uses the singular form for a single post", async () => {
+      const labels = readLabels(
+        await renderLanguageContent({
+          unmarkedPostCount: 1,
+        }),
+      );
+
+      expect(labels.enableMarkWarning).toContain("1 existing post with");
+      expect(labels.enableMarkWarning).not.toContain("posts");
+    });
+
+    it("leaves the language slot for the component to fill", async () => {
+      const labels = readLabels(
+        await renderLanguageContent({
+          unmarkedPostCount: 5,
+        }),
+      );
+
+      // Chosen inside the dialog, so it cannot be resolved here.
+      expect(labels.enableMarkWarning).toContain("{language}");
+      expect(labels.removeLanguage).toContain("{language}");
+    });
+
+    it("leaves every slot of the change-primary and disable copy", async () => {
+      const labels = readLabels(await renderLanguageContent());
+
+      expect(labels.changePrimaryBody).toContain("{next}");
+      expect(labels.changePrimaryBody).toContain("{previous}");
+      expect(labels.changePrimaryBody).toContain("{prefix}");
+      expect(labels.disableBody).toContain("{prefix}");
+      expect(labels.removeLastBody).toContain("{language}");
+      expect(labels.removeLastBody).toContain("{prefix}");
+    });
+
+    it("never leaks an unresolved ICU construct into a label", async () => {
+      const labels = readLabels(
+        await renderLanguageContent({
+          unmarkedPostCount: 12,
+        }),
+      );
+
+      for (const [key, value] of Object.entries(labels)) {
+        expect(value, key).not.toContain("plural,");
+        expect(value, key).not.toContain("NaN");
+      }
+    });
+  });
+});

package/src/ui/dash/settings/__tests__/discover-copy.test.ts

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { createI18n } from "../../../../i18n/i18n.js";
+import { getDiscoverCopy } from "../discover-copy.js";
+
+const CORE_ROOT = resolve(import.meta.dirname, "../../../../..");
+
+/**
+ * Every msgid in a .po file, mapped to its msgstr. Joins the continuation
+ * lines a long entry may be wrapped onto.
+ */
+function readCatalog(locale: string): Map<string, string> {
+  const po = readFileSync(
+    resolve(CORE_ROOT, `src/i18n/locales/settings/${locale}.po`),
+    "utf8",
+  );
+  const entries = new Map<string, string>();
+  for (const block of po.split(/\n{2,}/)) {
+    const field = (keyword: string) => {
+      const match = new RegExp(
+        `^${keyword} ("(?:[^"\\\\]|\\\\.)*"(?:\\n"(?:[^"\\\\]|\\\\.)*")*)`,
+        "m",
+      ).exec(block);
+      if (!match?.[1]) return null;
+      return match[1]
+        .split("\n")
+        .map((line) => JSON.parse(line) as string)
+        .join("");
+    };
+    const id = field("msgid");
+    const str = field("msgstr");
+    if (id !== null && str !== null) entries.set(id, str);
+  }
+  return entries;
+}
+
+describe("getDiscoverCopy", () => {
+  // Setup shows `about` alone; Settings shows it and goes on. The opening is
+  // one message, so the two can only differ in length, never in wording.
+  it("opens the settings line with the sentence setup shows", () => {
+    const copy = getDiscoverCopy(createI18n("en"));
+
+    expect(copy.about).toBe(
+      "Jant Discover is a directory of Jant blogs, curated by hand by the Jant community to help people find new Jant blogs and posts.",
+    );
+    expect(copy.intro.startsWith(`${copy.about} `)).toBe(true);
+  });
+
+  // Tests render through a macro stub that never reaches a translation, so the
+  // catalogs are read directly. A translation that drops `{about}` would leave
+  // the settings line without its first sentence in that language only.
+  it.each(["zh-Hans", "zh-Hant"])(
+    "keeps the opening sentence in the %s settings line",
+    (locale) => {
+      const catalog = readCatalog(locale);
+      const intro = [...catalog].find(([id]) => id.startsWith("{about} "));
+      const about = catalog.get(
+        "{name} is a directory of Jant blogs, curated by hand by the Jant community to help people find new Jant blogs and posts.",
+      );
+
+      expect(intro?.[1]).toContain("{about}");
+      expect(about).toContain("{name}");
+    },
+  );
+});

package/src/ui/dash/settings/discover-copy.ts

@@ -0,0 +1,116 @@
+/**
+ * What the Jant Discover checkbox says, wherever it appears.
+ *
+ * The checkbox is on the settings page, and it is asked once more on the
+ * first-run setup screen. One control appearing twice should not describe
+ * itself two ways, so both surfaces take their words from here rather than
+ * each keeping a wording of its own that drifts when the other is edited.
+ *
+ * The two help lines differ in length, not in wording. Setup shows only the
+ * sentence saying what the directory is: the delay, the lists and the rules
+ * matter to an author with posts to show, and setup comes before the first
+ * one — anyone curious follows the name to the directory itself. The settings
+ * line carries that same sentence as its `{about}` placeholder and goes on
+ * from there, so the opening can only ever be edited in one place, in every
+ * locale.
+ *
+ * Lives under `ui/dash/` because that is what puts it in the translated
+ * catalog: `lingui.config` splits by path, and only `routes/dash/**`,
+ * `ui/dash/**` and the setup page are translated.
+ */
+
+import { msg } from "@lingui/core/macro";
+import type { I18n } from "../../../i18n/i18n.js";
+import {
+  DISCOVER_LIST_NAMES,
+  DISCOVER_PUBLIC_DELAY_HOURS,
+} from "../../../lib/discover.js";
+
+type Translator = Pick<I18n, "_">;
+
+/** The Discover checkbox's words, translated. */
+export interface DiscoverCopy {
+  /** The directory's name, as `label`, `about` and `intro` carry it. */
+  name: string;
+  /** The rules page's name, as the end of `intro` carries it. */
+  rules: string;
+  /** The checkbox label, on both surfaces. */
+  label: string;
+  /** What the directory is, in one sentence: setup's whole help line. */
+  about: string;
+  /** The settings page's help line, which opens with `about`. */
+  intro: string;
+}
+
+/**
+ * Translate the Discover checkbox's label and help lines.
+ *
+ * The directory's name and the rules page's name are split out so the label
+ * and the help lines can carry them as placeholders, leaving word order free
+ * per locale; they are returned too, because `discoverIntroRuns` finds each
+ * one in the translated line to make it a link.
+ *
+ * @param i18n - The request's i18n instance
+ * @returns The five strings, in the i18n instance's locale
+ * @example
+ * ```ts
+ * const copy = getDiscoverCopy(i18n);
+ * copy.label; // "Allow Jant Discover to list my site"
+ * copy.intro.startsWith(copy.about); // true
+ * ```
+ */
+export function getDiscoverCopy(i18n: Translator): DiscoverCopy {
+  const name = i18n._(
+    msg({
+      message: "Jant Discover",
+      comment:
+        "@context: Name of the Jant blog directory. Appears inside the Discover checkbox label, and in the help line under it as the link to the directory.",
+    }),
+  );
+
+  // The run of text the rules link sits on, at the end of the help line.
+  const rules = i18n._(
+    msg({
+      message: "Discover community rules",
+      comment:
+        "@context: Link text at the end of the help line under the Discover checkbox, leading to the directory's page on how blogs are listed: joining, review, and what takes a blog off. This run of text is rendered as the link, so translate it as it should read inside that sentence.",
+    }),
+  );
+
+  const label = i18n._(
+    msg({
+      message: "Allow {name} to list my site",
+      comment:
+        "@context: Checkbox for joining the Jant Discover directory, on the settings page and once on the first-run setup screen. {name} is the directory's name, kept as one run of text.",
+    }),
+    { name },
+  );
+
+  const about = i18n._(
+    msg({
+      message:
+        "{name} is a directory of Jant blogs, curated by hand by the Jant community to help people find new Jant blogs and posts.",
+      comment:
+        "@context: What the Jant Discover directory is, in one sentence. The whole help line under the Discover checkbox on the first-run setup screen, and the opening of the settings page's longer one. {name} is the directory's name and is rendered as the link to it, so keep it as one run of text.",
+    }),
+    { name },
+  );
+
+  const intro = i18n._(
+    msg({
+      message:
+        "{about} A post you mark Featured appears on the Discover home page {hours} hours later, and link and quote posts appear on the {links} and {quotes} lists {hours} hours after they are published. You can keep editing them in the meantime. See the {rules}.",
+      comment:
+        "@context: Help text under the Jant Discover checkbox on the settings page. {about} is the sentence saying what the directory is, translated on its own and shown alone on the setup screen; keep it, and join it to what follows as your language joins two sentences. {links} and {quotes} are the directory's two list names, which stay in English, and {rules} is the name of its rules page; each is rendered as a link, so keep every placeholder as one run of text. {hours} is how long the directory waits before showing a post, which is the time left to edit it. 'Featured' is the mark on a post, as this site's own UI spells it; the lowercase 'link and quote' are the post formats, not the lists.",
+    }),
+    {
+      about,
+      hours: DISCOVER_PUBLIC_DELAY_HOURS,
+      links: DISCOVER_LIST_NAMES.links,
+      quotes: DISCOVER_LIST_NAMES.quotes,
+      rules,
+    },
+  );
+
+  return { name, rules, label, about, intro };
+}