@kirchdev/duxt 0.3.4 → 0.3.5-dev-main.44-5337cc1

package/i18n/locales/fr/duxt/page.json

@@ -13,6 +13,15 @@
         "no": "Non",
         "thanks": "Merci."
       },
+      "image": {
+        "close": "Fermer la visionneuse d’image",
+        "original": "Ouvrir l’original dans un nouvel onglet",
+        "resetZoom": "Réinitialiser le zoom",
+        "zoom": "Agrandir l'image",
+        "zoomIn": "Zoom avant",
+        "zoomNamed": "Agrandir l'image : {alt}",
+        "zoomOut": "Zoom arrière"
+      },
       "tabs": "Options",
       "since": "Nouveau dans {version}",
       "copy": {

package/i18n/locales/fr/duxt/shortcuts.json

@@ -2,6 +2,7 @@
   "duxt": {
     "shortcuts": {
       "title": "Raccourcis clavier",
+      "open": "Afficher les raccourcis clavier",
       "search": "Rechercher dans la documentation",
       "help": "Afficher cette liste",
       "previous": "Page précédente",

package/i18n/locales/fr/duxt/theme.json

@@ -1,7 +1,8 @@
 {
   "duxt": {
     "theme": {
-      "toggle": "Changer de thème"
+      "toLight": "Passer au thème clair",
+      "toDark": "Passer au thème sombre"
     }
   }
 }

package/i18n/locales/pt/duxt/announcement.json

@@ -0,0 +1,7 @@
+{
+  "duxt": {
+    "announcement": {
+      "dismiss": "Dispensar este anúncio"
+    }
+  }
+}

package/i18n/locales/pt/duxt/bruno.json

@@ -0,0 +1,25 @@
+{
+  "duxt": {
+    "bruno": {
+      "auth": "Autenticação",
+      "body": "Corpo",
+      "download": "Transferir a coleção",
+      "downloadHint": "A coleção exatamente como esta versão e este idioma a descrevem.",
+      "environments": "Ambientes",
+      "fetch": "Abrir no Bruno",
+      "fetchHint": "Clona o repositório no Bruno. Segue o ramo predefinido e não está fixado nesta versão.",
+      "folders": "Pastas",
+      "format": "Formato",
+      "getIt": "Obter a coleção",
+      "hasCode": "Este pedido também tem scripts ou testes. Aqui não são mostrados nem executados; estão na transferência.",
+      "headers": "Cabeçalhos",
+      "name": "Nome",
+      "notPublished": "Ambientes, credenciais, scripts e testes nunca são publicados neste site nem executados no seu navegador.",
+      "parameters": "Parâmetros",
+      "requests": "Pedidos",
+      "shared": "Comum a todos os pedidos",
+      "value": "Valor",
+      "withheld": "retido"
+    }
+  }
+}

package/i18n/locales/pt/duxt/changelog.json

@@ -5,7 +5,7 @@
       "filter": "Filtrar por tipo de alteração",
       "latest": "Mais recente",
       "changes": "Alterações",
-      "kinds": "Tipos de alteração",
+      "contributors": "Colaboradores",
       "last": "Última versão",
       "more": "e mais {count}",
       "kind": "Tipo de alteração",

package/i18n/locales/pt/duxt/code.json

@@ -7,7 +7,8 @@
       "preview": "Pré-visualização",
       "source": "Código",
       "previewTabs": "Exemplo e código-fonte",
-      "copiedToast": "Copiado para a área de transferência"
+      "copiedToast": "Copiado para a área de transferência",
+      "copyFailed": "Não foi possível copiar para a área de transferência."
     }
   }
 }

package/i18n/locales/pt/duxt/page.json

@@ -13,6 +13,15 @@
         "no": "Não",
         "thanks": "Obrigado."
       },
+      "image": {
+        "close": "Fechar o visualizador de imagens",
+        "original": "Abrir o original num novo separador",
+        "resetZoom": "Repor o zoom",
+        "zoom": "Ampliar imagem",
+        "zoomIn": "Aumentar o zoom",
+        "zoomNamed": "Ampliar imagem: {alt}",
+        "zoomOut": "Diminuir o zoom"
+      },
       "tabs": "Opções",
       "since": "Novo em {version}",
       "copy": {

package/i18n/locales/pt/duxt/shortcuts.json

@@ -2,6 +2,7 @@
   "duxt": {
     "shortcuts": {
       "title": "Atalhos de teclado",
+      "open": "Mostrar os atalhos de teclado",
       "search": "Pesquisar na documentação",
       "help": "Mostrar esta lista",
       "previous": "Página anterior",

package/i18n/locales/pt/duxt/theme.json

@@ -1,7 +1,8 @@
 {
   "duxt": {
     "theme": {
-      "toggle": "Mudar o tema"
+      "toLight": "Mudar para o tema claro",
+      "toDark": "Mudar para o tema escuro"
     }
   }
 }

package/modules/bruno.ts

@@ -0,0 +1,118 @@
+/**
+ * The downloadable archive of every Bruno collection the site publishes.
+ *
+ * WHY A MODULE AND NOT A ROUTE. The `.bru` files exist at BUILD TIME and
+ * nowhere else: a site deployed to a Worker has no filesystem, and one deployed
+ * anywhere at all has prerendered its pages long before a reader clicks the
+ * download. So the archive is written during the build and registered as a
+ * public asset — a real file under `.output/public`, served by the assets
+ * binding without the server being invoked, which is what every other
+ * prerendered thing on these sites already is.
+ *
+ * LOCAL COLLECTIONS ONLY, and the limit is the one `section-reports.ts` already
+ * states for the same reason: a remote artefact lives wherever Content's
+ * hash-cached checkout put it, which is a directory known only inside the
+ * collection that declared it, and recomputing it here is exactly the second
+ * implementation `remoteCollection` refuses to write. `sections-bruno.ts` knows
+ * this — a remote section's overview links no archive at all, so there is no
+ * dead link rather than a link to a file this module never wrote.
+ *
+ * The page's link and this file's name are composed from the same two halves —
+ * `DUXT_BRUNO_ASSETS` and `brunoZipName` — so they cannot drift: two agreeing by
+ * coincidence is how a download 404s after somebody renames one.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Nuxt } from '@nuxt/schema';
+import {
+  DUXT_BRUNO_ASSETS,
+  brunoZipEntries,
+  brunoZipName,
+  zipStore
+} from '../bruno-zip';
+import { readDuxtBuildConfig } from '../duxt-app-config';
+import { duxtManifest, duxtSectionTypes } from '../sections-resolve';
+import { diskSectionInput, sectionArtefactExists } from '../section-input';
+import { repositoryRoot } from '../repository-root';
+import { resolveLatestRefs } from '../sources-git';
+
+export default function duxtBruno(_options: unknown, nuxt: Nuxt) {
+  const dirs = nuxt.options._layers
+    .flatMap((entry) => [entry.config.rootDir, entry.config.srcDir])
+    .filter(Boolean) as string[];
+
+  const config = readDuxtBuildConfig(dirs);
+  const types = duxtSectionTypes(config?.sectionTypes);
+
+  const entries = duxtManifest(
+    resolveLatestRefs(config?.sources ?? [{ path: 'docs' }]),
+    config?.sourceOptions ?? {},
+    types
+  ).filter(
+    (entry) => entry.generated?.type === 'bruno' && !entry.generated.remote
+  );
+
+  if (!entries.length) return;
+
+  // BUILT ONCE, HELD AS BYTES. Both writes below come from this array rather
+  // than one of them reading the other's directory back: `buildDir` is not the
+  // same path at module setup and at the end of the Nitro build, and a hook
+  // that re-read it found nothing there — an empty asset directory and a 404
+  // behind the one control the overview is built around.
+  const archives = entries.flatMap((entry) => {
+    const source = join(repositoryRoot(), entry.path);
+
+    // Silently skipped rather than thrown on: a declared path that is not there
+    // already fails the build where the collection is declared, with a message
+    // naming the section. Throwing a second, worse one from here would only
+    // decide which of the two a reader sees.
+    if (!sectionArtefactExists(source, 'directory')) return [];
+
+    return [
+      {
+        name: brunoZipName(entry.collection),
+        data: zipStore(
+          brunoZipEntries(diskSectionInput(source, entry.path, 'directory'))
+        )
+      }
+    ];
+  });
+
+  if (!archives.length) return;
+
+  const dir = join(nuxt.options.buildDir, 'duxt-bruno');
+
+  write(dir, archives);
+
+  // TWO REGISTRATIONS, because dev and build ask different questions.
+  //
+  // `publicAssets` is what the DEV server reads: it serves the directory off
+  // disk, and it is also what teaches Nitro that `/_duxt/bruno/` is a public
+  // URL rather than a route.
+  nuxt.hook('nitro:config', (nitro) => {
+    nitro.publicAssets ??= [];
+    nitro.publicAssets.push({ dir, baseURL: DUXT_BRUNO_ASSETS, maxAge: 0 });
+  });
+
+  // The BUILD is the other half, and it is not the same thing said twice:
+  // Nitro's own copy pass does not carry a directory inside `.nuxt` into
+  // `.output/public`, so registering alone produced a site that knew the URL
+  // was an asset and had no file behind it — a 404 on the one control the
+  // overview is built around. Copied here, after that pass has run, which is
+  // what this hook exists for.
+  nuxt.hook('nitro:build:public-assets', (nitro) => {
+    write(
+      join(nitro.options.output.publicDir, ...DUXT_BRUNO_ASSETS.split('/')),
+      archives
+    );
+  });
+}
+
+/** The archives, into one directory. */
+function write(dir: string, archives: { name: string; data: Uint8Array }[]) {
+  mkdirSync(dir, { recursive: true });
+
+  for (const archive of archives) {
+    writeFileSync(join(dir, archive.name), archive.data);
+  }
+}

package/modules/config.ts

@@ -2,6 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { Nuxt } from '@nuxt/schema';
+import { bundledLanguagesInfo } from 'shiki/langs';
 import { enableWriteAheadLog } from '../content-cache';
 import type { DuxtBuildConfig } from '../duxt-app-config';
 import { readDuxtBuildConfig } from '../duxt-app-config';
@@ -170,6 +171,12 @@ function checkSourceLocales(
  * The three at the bottom are not samples: the package-manager block, the
  * response body and the example bodies are highlighted at runtime too, and they
  * are the same three whatever a site configures.
+ *
+ * THE LANDING DEMOS TOO. A `code` demo in `landing.showcase` goes through the
+ * same highlighter, and a file whose language was not in this map rendered as
+ * flat text — `openapi.yaml` and `widget.md` beside a coloured `nuxt.config.ts`
+ * read as the highlighter being off. So the languages the showcase names are
+ * added, and a site pays for them only if its landing page uses them.
  */
 function writeGrammars(nuxt: Nuxt, config?: DuxtBuildConfig): void {
   const shipped = new Map(
@@ -192,6 +199,25 @@ function writeGrammars(nuxt: Nuxt, config?: DuxtBuildConfig): void {
     if (language) languages.add(language);
   }
 
+  // Aliases resolve to the grammar's id: `yml` is a name Shiki answers to, not
+  // a module under `shiki/langs/`.
+  const grammarIds = new Map(
+    bundledLanguagesInfo.flatMap((info) =>
+      [info.id, ...(info.aliases ?? [])].map((name) => [name, info.id] as const)
+    )
+  );
+
+  for (const band of config?.landing?.showcase ?? []) {
+    for (const file of band?.demo?.files ?? []) {
+      // Only names with a module behind them: `text` and anything Shiki does
+      // not ship would be an `import()` Vite cannot resolve, and that fails
+      // the build rather than degrading one block.
+      const id = grammarIds.get(file?.language?.toLowerCase() ?? '');
+
+      if (id) languages.add(id);
+    }
+  }
+
   const loaders = [...languages]
     .sort()
     .map(

package/modules/devtools.ts

@@ -2,6 +2,7 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { Nuxt } from '@nuxt/schema';
+import { localeCodesOf } from '../app/utils/locale-path';
 
 /**
  * A window into the layer that has been hardest to debug.
@@ -120,7 +121,5 @@ function localeCodes(nuxt: Nuxt): string[] {
     }
   ).i18n?.locales;
 
-  return (locales ?? []).map((locale) =>
-    typeof locale === 'string' ? locale : locale.code
-  );
+  return localeCodesOf(locales);
 }

package/modules/git-meta.ts

@@ -2,9 +2,12 @@ import { execFileSync } from 'node:child_process';
 import { dirname, relative, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { Nuxt } from '@nuxt/schema';
+import type { DuxtContributor } from '../git-contributors';
+import { contributorsOf } from '../git-contributors';
 import { readDuxtBuildConfig } from '../duxt-app-config';
 import { duxtManifest, duxtSectionTypes } from '../sections-resolve';
 import { resolveLatestRefs } from '../sources-git';
+import { normaliseTfplugindocsPage } from '../tfplugindocs';
 
 /**
  * "Last updated" and the contributor list, from the git history the file
@@ -30,11 +33,7 @@ interface AfterParseContext {
   file?: { path?: string; id?: string };
 }
 
-export interface DuxtContributor {
-  name: string;
-  commits: number;
-  username?: string;
-}
+export type { DuxtContributor };
 
 export default function duxtGitMeta(_options: unknown, nuxt: Nuxt) {
   const layerDir = fileURLToPath(new URL('..', import.meta.url));
@@ -54,8 +53,8 @@ export default function duxtGitMeta(_options: unknown, nuxt: Nuxt) {
     duxtSectionTypes(config?.sectionTypes)
   );
 
-  const wanted = new Map(
-    sources.map((source) => [source.collection, source.history])
+  const sourceByCollection = new Map(
+    sources.map((source) => [source.collection, source])
   );
 
   nuxt.hook(
@@ -65,10 +64,19 @@ export default function duxtGitMeta(_options: unknown, nuxt: Nuxt) {
       const content = ctx.content;
       if (!file || !content) return;
 
+      const source = sourceByCollection.get(ctx.collection?.name ?? '');
+      if (!source) return;
+
+      // Source flavours alter metadata only. Their Markdown remains portable to
+      // the generator's own publisher, so the body is never rewritten here.
+      if (source.flavor === 'tfplugindocs') {
+        normaliseTfplugindocsPage(content, ctx.file?.id ?? file);
+      }
+
       // A source that has not asked for its history is left alone — for a
       // downloaded one that would otherwise answer out of a single-commit
       // clone, which is wrong data rather than missing data.
-      if (!wanted.get(ctx.collection?.name ?? '')) return;
+      if (!source.history) return;
 
       if (file.includes('/.data/content/')) unshallow(dirname(file));
 
@@ -308,42 +316,3 @@ function gitLog(file: string): Commit[] {
 
   return historyOf(root).get(path) ?? [];
 }
-
-/**
- * One entry per person, most commits first.
- *
- * Identity is the email, not the name — the same person commits as "Titus
- * Kirch" and as "titus" and would otherwise appear twice. The GitHub username
- * is read out of a noreply address, which is the only place git actually
- * carries one; without it there is a name and no avatar, which is the truth.
- */
-export function contributorsOf(commits: Commit[]): DuxtContributor[] {
-  const people = new Map<string, DuxtContributor>();
-
-  for (const commit of commits) {
-    const key = commit.email.toLowerCase();
-    const existing = people.get(key);
-
-    if (existing) {
-      existing.commits += 1;
-      continue;
-    }
-
-    people.set(key, {
-      name: commit.name,
-      commits: 1,
-      username: githubUsername(commit.email)
-    });
-  }
-
-  return [...people.values()].sort((a, b) => b.commits - a.commits);
-}
-
-/** `1234567+octocat@users.noreply.github.com` becomes `octocat`. */
-export function githubUsername(email: string): string | undefined {
-  const match = /^(?:\d+\+)?([^@]+)@users\.noreply\.github\.com$/i.exec(
-    email.trim()
-  );
-
-  return match?.[1];
-}

package/modules/search-records.ts

@@ -0,0 +1,132 @@
+import type { Nuxt } from '@nuxt/schema';
+import { readContentCache } from '../content-cache';
+import { duxtSearchRecords } from '../search-records';
+import type { DuxtSearchRecordOptions } from '../search-records';
+import type { DuxtResolvedSource } from '../sources-resolve';
+
+/**
+ * duxt's one build-time extension point, and the whole of it.
+ *
+ * Why there is exactly one hook rather than a registry of them, and why a
+ * `duxt.plugins` API is not coming, is written where the contract is:
+ * `search-records.ts`. This half only decides WHEN the payload is built and
+ * makes sure it is built for nobody as rarely as possible.
+ *
+ * `build:done`, and the timing is the whole reason the hook can promise
+ * anything:
+ *
+ *  - Content fills its parse cache from a `modules:done` listener, so at
+ *    `build:done` every source, version, locale and generated section has been
+ *    parsed — including the repositories Content downloaded into `.data/`,
+ *    which nothing else on disk describes. Same seam `modules/validate.ts`
+ *    reads, and for the same reason: `content:file:afterParse` fires only for
+ *    files whose checksum CHANGED, so a listener built on it reports an empty
+ *    site on every second build.
+ *  - `@nuxt/nitro-server` runs the entire Nitro build — prerender and rollup —
+ *    from a `build:done` listener it registers while bundling, which is long
+ *    after every module has registered its own. Hooks run in registration
+ *    order, so this one fires BEFORE Nitro produces anything, and a listener
+ *    may still write a file into `public/` and have it copied into the output.
+ */
+const HOOK = 'duxt:search:records';
+
+export default function duxtSearchRecordsModule(_options: unknown, nuxt: Nuxt) {
+  nuxt.hook('build:done', async () => {
+    if (!listening(nuxt)) return;
+
+    // The manifest `modules/config.ts` already resolved, rather than a second
+    // pass of its own: resolving it means `git ls-remote` for every source that
+    // tracks a moving ref, and asking twice is both a second network round trip
+    // and a second chance for the two answers to differ.
+    const sources =
+      (
+        nuxt.options.appConfig.duxt as
+          | { resolvedSources?: DuxtResolvedSource[] }
+          | undefined
+      )?.resolvedSources ?? [];
+
+    if (!sources.length) return;
+
+    const cached = readContentCache(
+      nuxt,
+      sources.map((source) => source.collection)
+    );
+
+    // No cache at all is not "an empty site": it is a run that parsed nothing.
+    // Handing a provider zero records there would tell it to empty its index.
+    if (!cached) return;
+
+    await nuxt.callHook(
+      HOOK,
+      duxtSearchRecords(sources, cached, routing(nuxt))
+    );
+  });
+}
+
+/**
+ * Is anybody listening?
+ *
+ * The payload is a pass over every parsed page of every language, and on a site
+ * with no provider layer — which is every site until one is installed — nobody
+ * ever reads it. Building it anyway would be the cost this layer charges for a
+ * feature nobody turned on.
+ *
+ * Hookable keeps its registry private, so this reads a field it is not offered.
+ * FAILING OPEN is the point of the shape: a registry that cannot be read costs
+ * one wasted pass, while a wrong `false` means the hook silently never fires —
+ * and a hook that never fires is a bug with no symptom, which is the failure
+ * mode this layer spends most of its comments avoiding.
+ */
+function listening(nuxt: Nuxt): boolean {
+  const registry = (
+    nuxt.hooks as unknown as {
+      _hooks?: Record<string, unknown[] | undefined>;
+    }
+  )._hooks;
+
+  return !registry || Boolean(registry[HOOK]?.length);
+}
+
+/**
+ * What the site's routing does to a path, read where it is actually true.
+ *
+ * `nuxt.options.i18n.locales` is the WRONG list and looks like the right one.
+ * @nuxtjs/i18n collects `i18n.locales` from every layer itself and never reads
+ * the merged copy, which is why `restrictLocales` in `modules/config.ts`
+ * filters the per-layer configs instead — and therefore why a site that narrowed
+ * itself to two languages still has seven in `nuxt.options.i18n`. Reading that
+ * would index every translation the layer ships at URLs the site does not route.
+ */
+function routing(nuxt: Nuxt): DuxtSearchRecordOptions {
+  const codeOf = (locale: unknown) =>
+    typeof locale === 'string'
+      ? locale
+      : (locale as { code?: string } | null)?.code;
+
+  const locales = [
+    ...new Set(
+      nuxt.options._layers
+        .flatMap(
+          (entry) =>
+            (entry.config as { i18n?: { locales?: unknown[] } }).i18n
+              ?.locales ?? []
+        )
+        .map(codeOf)
+        .filter(Boolean) as string[]
+    )
+  ];
+
+  const i18n = nuxt.options.i18n as
+    | { defaultLocale?: string; strategy?: string }
+    | undefined;
+
+  // A consumer may have dropped i18n entirely. One language, no segment, and
+  // the content is whatever language it was written in.
+  const defaultLocale = i18n?.defaultLocale ?? locales[0] ?? 'en';
+
+  return {
+    locales: locales.length ? locales : [defaultLocale],
+    defaultLocale,
+    strategy: i18n?.strategy as DuxtSearchRecordOptions['strategy']
+  };
+}