@riebeckite/plugin-taxonomy 0.0.6

package/dist/index.js

@@ -0,0 +1,675 @@
+// index.ts
+import {
+  createStyleAsset,
+  defineEndpoint,
+  definePlugin,
+  resolvePlugins as resolvePlugins2
+} from "@riebeckite/core";
+
+// src/collections.ts
+import {
+  buildContentCollections,
+  stripHtml
+} from "@riebeckite/core";
+
+// src/slug.ts
+function slugifyTaxonomyValue(value) {
+  return value.split("/").map(slugifyTaxonomySegment).filter((segment) => segment.length > 0).join("/");
+}
+function slugifyTaxonomySegment(segment) {
+  const slug = segment.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (slug) return slug;
+  const raw = segment.trim();
+  return raw === "" ? "" : encodeURIComponent(raw);
+}
+
+// src/collections.ts
+function buildTaxonomyIndex(entries, options) {
+  const tags = options.tags ? buildTerms(entries, {
+    kind: "tag",
+    basePath: options.tagsBasePath,
+    groupBy: { by: "tags" },
+    options
+  }) : [];
+  const folders = options.folders ? buildTerms(entries, {
+    kind: "folder",
+    basePath: options.foldersBasePath,
+    groupBy: options.folderDepth > 0 ? { by: "folder", depth: options.folderDepth } : { by: "folder" },
+    options
+  }) : [];
+  if (options.related && tags.length > 0) {
+    attachRelatedTerms(tags, entries, options);
+  }
+  return { tags, folders };
+}
+function serializeTaxonomyTerm(term) {
+  return {
+    kind: term.kind,
+    value: term.value,
+    title: term.title,
+    path: term.path,
+    permalink: term.path,
+    count: term.entries.length,
+    entries: term.entries.map(toEntryReference),
+    related: term.related,
+    feeds: term.feeds
+  };
+}
+function serializeTaxonomyIndex(index) {
+  return {
+    tags: index.tags.map(serializeTaxonomyTerm),
+    folders: index.folders.map(serializeTaxonomyTerm)
+  };
+}
+function toEntryReference(entry) {
+  return {
+    slug: entry.slug,
+    permalink: entry.permalink,
+    title: entry.title,
+    updated: getEntryUpdatedTime(entry),
+    summary: getEntrySummary(entry)
+  };
+}
+function buildTerms(entries, input) {
+  const { kind, basePath, groupBy, options } = input;
+  const definition = {
+    kind,
+    basePath,
+    groupBy,
+    resolveTitle: (context) => resolveTermTitle(context, options),
+    resolvePath: ({ value }) => `${basePath}/${slugifyTaxonomyValue(value)}`.replace(/\/{2,}/g, "/")
+  };
+  const collections = buildContentCollections(entries, [definition]);
+  const terms = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const collection of collections) {
+    if (collection.value.trim() === "") continue;
+    if (collection.entries.length < options.minEntries) continue;
+    const path = normalizeTermPath(collection.path, basePath);
+    if (seen.has(path)) continue;
+    seen.add(path);
+    terms.push({
+      kind,
+      value: collection.value,
+      title: collection.title,
+      path,
+      entries: collection.entries,
+      related: [],
+      feeds: buildFeedLinks(path, options),
+      feedFiles: buildFeedFiles(path, options)
+    });
+  }
+  return terms;
+}
+function resolveTermTitle(context, options) {
+  const kind = context.kind === "tag" ? "tag" : "folder";
+  const custom = options.resolveTitle?.({
+    kind,
+    value: context.value,
+    basePath: context.basePath
+  });
+  if (typeof custom === "string" && custom.trim() !== "") return custom.trim();
+  return context.kind === "tag" ? `#${context.value}` : context.value;
+}
+function attachRelatedTerms(tags, entries, options) {
+  const byValue = new Map(tags.map((term) => [term.value, term]));
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const tag of entry.tags) {
+      if (!byValue.has(tag)) continue;
+      let coOccurrence = counts.get(tag);
+      if (!coOccurrence) {
+        coOccurrence = /* @__PURE__ */ new Map();
+        counts.set(tag, coOccurrence);
+      }
+      for (const other of entry.tags) {
+        if (other === tag) continue;
+        coOccurrence.set(other, (coOccurrence.get(other) ?? 0) + 1);
+      }
+    }
+  }
+  for (const term of tags) {
+    const coOccurrence = counts.get(term.value);
+    if (!coOccurrence) continue;
+    term.related = [...coOccurrence.entries()].map(([value, count]) => ({ term: byValue.get(value), count })).filter(
+      (candidate) => candidate.term !== void 0
+    ).sort(
+      (left, right) => right.count - left.count || left.term.value.localeCompare(right.term.value, "en")
+    ).slice(0, options.relatedLimit).map(({ term: related, count }) => ({
+      kind: related.kind,
+      value: related.value,
+      title: related.title,
+      path: related.path,
+      permalink: related.path,
+      count
+    }));
+  }
+}
+function buildFeedLinks(path, options) {
+  const links = {};
+  if (options.feeds.rss) links.rss = `${path}/feed.xml`;
+  if (options.feeds.atom) links.atom = `${path}/atom.xml`;
+  if (options.feeds.json) links.json = `${path}/feed.json`;
+  return links;
+}
+function buildFeedFiles(path, options) {
+  const base = path.replace(/^\/+/, "");
+  const files = [];
+  if (options.feeds.rss) files.push(`${base}/feed.xml`);
+  if (options.feeds.atom) files.push(`${base}/atom.xml`);
+  if (options.feeds.json) files.push(`${base}/feed.json`);
+  return files;
+}
+function normalizeTermPath(path, basePath) {
+  const normalized = path.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+  if (normalized !== "") return normalized;
+  return basePath || "/";
+}
+function getEntrySummary(entry) {
+  const description = entry.frontmatter.description;
+  if (typeof description === "string" && description.trim() !== "") {
+    return description.trim();
+  }
+  return stripHtml(entry.html).replace(/\s+/g, " ").trim().slice(0, 200);
+}
+function getEntryUpdatedTime(entry) {
+  const value = entry.frontmatter.updated ?? entry.frontmatter.published ?? entry.frontmatter.date ?? entry.frontmatter.created;
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+// src/url.ts
+function buildTaxonomyAbsoluteUrl(config, pathOrUrl) {
+  if (!pathOrUrl) return config.site.baseUrl;
+  if (/^https?:\/\//.test(pathOrUrl)) return pathOrUrl;
+  return new URL(
+    pathOrUrl,
+    config.site.baseUrl || "https://example.com"
+  ).toString();
+}
+
+// src/xml.ts
+function escapeTaxonomyXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/feeds.ts
+function renderTermFeed(config, term, format, limit = 0) {
+  const entries = limit > 0 ? term.entries.slice(0, limit) : term.entries;
+  const title = `${term.title} | ${config.site.title}`;
+  const feedUrl = buildTaxonomyAbsoluteUrl(config, term.path);
+  switch (format) {
+    case "rss":
+      return renderRss(config, term, entries, title, feedUrl);
+    case "atom":
+      return renderAtom(config, term, entries, title, feedUrl);
+    case "json":
+      return renderJson(config, term, entries, title);
+    default:
+      return "";
+  }
+}
+function buildFeedHeadTags(term) {
+  const tags = [];
+  if (term.feeds.rss) {
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "alternate",
+        type: "application/rss+xml",
+        title: term.title,
+        href: term.feeds.rss
+      }
+    });
+  }
+  if (term.feeds.atom) {
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "alternate",
+        type: "application/atom+xml",
+        title: term.title,
+        href: term.feeds.atom
+      }
+    });
+  }
+  if (term.feeds.json) {
+    tags.push({
+      tag: "link",
+      attrs: {
+        rel: "alternate",
+        type: "application/feed+json",
+        title: term.title,
+        href: term.feeds.json
+      }
+    });
+  }
+  return tags;
+}
+function renderRss(config, term, entries, title, feedUrl) {
+  const feed = getResolvedFeedMetadata(config);
+  const self = buildTaxonomyAbsoluteUrl(config, `${term.path}/feed.xml`);
+  const items = entries.map((entry) => {
+    const url = buildTaxonomyAbsoluteUrl(config, entry.permalink);
+    const pubDate = getPublishedTime(entry);
+    return `<item><title>${escapeTaxonomyXml(entry.title)}</title><link>${escapeTaxonomyXml(url)}</link><guid>${escapeTaxonomyXml(url)}</guid><description>${escapeTaxonomyXml(getDescription(entry))}</description>${pubDate ? `<pubDate>${new Date(pubDate).toUTCString()}</pubDate>` : ""}</item>`;
+  }).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>${escapeTaxonomyXml(title)}</title><link>${escapeTaxonomyXml(feedUrl)}</link><description>${escapeTaxonomyXml(feed.description)}</description><language>${escapeTaxonomyXml(feed.language)}</language><atom:link href="${escapeTaxonomyXml(self)}" rel="self" type="application/rss+xml"/>${items}</channel></rss>`;
+}
+function renderAtom(config, term, entries, title, feedUrl) {
+  const self = buildTaxonomyAbsoluteUrl(config, `${term.path}/atom.xml`);
+  const updated = entries.map(getUpdatedTime).find(Boolean) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+  const items = entries.map((entry) => {
+    const url = buildTaxonomyAbsoluteUrl(config, entry.permalink);
+    return `<entry><title>${escapeTaxonomyXml(entry.title)}</title><link href="${escapeTaxonomyXml(url)}"/><id>${escapeTaxonomyXml(url)}</id><updated>${escapeTaxonomyXml(getUpdatedTime(entry) ?? updated)}</updated><summary>${escapeTaxonomyXml(getDescription(entry))}</summary></entry>`;
+  }).join("");
+  return `<?xml version="1.0" encoding="UTF-8"?><feed xmlns="http://www.w3.org/2005/Atom"><title>${escapeTaxonomyXml(title)}</title><link href="${escapeTaxonomyXml(feedUrl)}"/><link rel="self" href="${escapeTaxonomyXml(self)}"/><id>${escapeTaxonomyXml(feedUrl)}</id><updated>${escapeTaxonomyXml(updated)}</updated>${items}</feed>`;
+}
+function renderJson(config, term, entries, title) {
+  const feed = getResolvedFeedMetadata(config);
+  const self = buildTaxonomyAbsoluteUrl(config, `${term.path}/feed.json`);
+  return JSON.stringify({
+    version: "https://jsonfeed.org/version/1.1",
+    title,
+    home_page_url: buildTaxonomyAbsoluteUrl(config, ""),
+    feed_url: self,
+    description: feed.description,
+    language: feed.language,
+    items: entries.map((entry) => {
+      const url = buildTaxonomyAbsoluteUrl(config, entry.permalink);
+      return {
+        id: url,
+        url,
+        title: entry.title,
+        content_html: entry.html,
+        summary: getDescription(entry),
+        date_published: getPublishedTime(entry) ?? void 0,
+        date_modified: getUpdatedTime(entry) ?? void 0,
+        tags: entry.tags
+      };
+    })
+  });
+}
+function getResolvedFeedMetadata(config) {
+  return {
+    description: config.site.feed.description ?? config.site.description,
+    language: config.site.feed.language ?? config.site.locale.replace("_", "-")
+  };
+}
+function getDescription(entry) {
+  const description = entry.frontmatter.description;
+  if (typeof description === "string" && description.trim() !== "") {
+    return description.trim();
+  }
+  return entry.title;
+}
+function getPublishedTime(entry) {
+  return toIso(
+    entry.frontmatter.published ?? entry.frontmatter.date ?? entry.frontmatter.created
+  );
+}
+function getUpdatedTime(entry) {
+  return toIso(entry.frontmatter.updated) ?? getPublishedTime(entry);
+}
+function toIso(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) {
+    return value.toISOString();
+  }
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+
+// src/locations.ts
+import {
+  resolveDefaultContentLocation
+} from "@riebeckite/core";
+var PLUGIN_NAME = "taxonomy";
+function resolveFolderIndexLocations(entries, options, diagnostics) {
+  if (!options.folderIndexes) return [];
+  const permalinkOwners = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const location = resolveDefaultContentLocation(entry);
+    if (!permalinkOwners.has(location.permalink)) {
+      permalinkOwners.set(location.permalink, entry.slug);
+    }
+  }
+  const locations = [];
+  for (const entry of entries) {
+    const suffix = "/index";
+    if (!entry.slug.endsWith(suffix)) continue;
+    const folder = entry.slug.slice(0, -suffix.length);
+    if (folder === "") continue;
+    const target = `/${folder}`;
+    const owner = permalinkOwners.get(target);
+    if (owner && owner !== entry.slug) {
+      diagnostics.push({
+        code: "taxonomy-folder-index-collision",
+        severity: "warning",
+        pluginName: PLUGIN_NAME,
+        message: `Folder index "${entry.path}" already maps to a note at "${target}"; keeping the default location.`,
+        slug: entry.slug,
+        target
+      });
+      continue;
+    }
+    locations.push({
+      slug: entry.slug,
+      permalink: target,
+      metadata: { "taxonomy.folder": folder }
+    });
+  }
+  return locations;
+}
+
+// src/options.ts
+var DEFAULT_TAXONOMY_TAGS_BASE_PATH = "/tags";
+var DEFAULT_TAXONOMY_FOLDERS_BASE_PATH = "/folders";
+var DEFAULT_TAXONOMY_MIN_ENTRIES = 1;
+var DEFAULT_TAXONOMY_RELATED_LIMIT = 8;
+var DEFAULT_TAXONOMY_FEED_LIMIT = 50;
+var DEFAULT_TAXONOMY_CLASS_NAME = "rr-taxonomy";
+var DEFAULT_TAXONOMY_DATA_ENDPOINT = "/taxonomy/index.json";
+function resolveTaxonomyOptions(options = {}) {
+  return {
+    tags: options.tags ?? true,
+    folders: options.folders ?? true,
+    tagsBasePath: normalizeBasePath(
+      options.tagsBasePath,
+      DEFAULT_TAXONOMY_TAGS_BASE_PATH
+    ),
+    foldersBasePath: normalizeBasePath(
+      options.foldersBasePath,
+      DEFAULT_TAXONOMY_FOLDERS_BASE_PATH
+    ),
+    folderDepth: normalizeCount(options.folderDepth, 0),
+    minEntries: normalizeMinEntries(options.minEntries),
+    related: options.related ?? true,
+    relatedLimit: normalizeCount(
+      options.relatedLimit,
+      DEFAULT_TAXONOMY_RELATED_LIMIT
+    ),
+    folderIndexes: options.folderIndexes ?? false,
+    feeds: {
+      rss: options.feeds?.rss ?? true,
+      atom: options.feeds?.atom ?? true,
+      json: options.feeds?.json ?? true
+    },
+    feedLimit: normalizeCount(options.feedLimit, DEFAULT_TAXONOMY_FEED_LIMIT),
+    className: normalizeClassName(options.className),
+    dataEndpoint: normalizeDataEndpoint(options.dataEndpoint),
+    resolveTitle: options.resolveTitle
+  };
+}
+function normalizeBasePath(value, fallback) {
+  if (typeof value !== "string") return fallback;
+  const trimmed = value.trim().replace(/\/+$/, "");
+  if (trimmed === "") return "";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function normalizeCount(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+function normalizeMinEntries(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : DEFAULT_TAXONOMY_MIN_ENTRIES;
+}
+function normalizeClassName(value) {
+  if (typeof value !== "string") return DEFAULT_TAXONOMY_CLASS_NAME;
+  const trimmed = value.trim();
+  return trimmed === "" ? DEFAULT_TAXONOMY_CLASS_NAME : trimmed;
+}
+function normalizeDataEndpoint(value) {
+  if (typeof value !== "string") return DEFAULT_TAXONOMY_DATA_ENDPOINT;
+  const trimmed = value.trim();
+  if (trimmed === "" || !trimmed.startsWith("/")) {
+    return DEFAULT_TAXONOMY_DATA_ENDPOINT;
+  }
+  return trimmed;
+}
+
+// src/pages.ts
+import { escapeHtml, escapeHtmlAttribute } from "@riebeckite/core";
+function renderTaxonomyPage(term, options) {
+  const className = escapeHtmlAttribute(options.className);
+  const entries = term.entries.map(
+    (entry) => `<li class="${className}__item"><a class="${className}__link" href="${escapeHtmlAttribute(
+      entry.permalink
+    )}">${escapeHtml(entry.title)}</a></li>`
+  ).join("");
+  const feeds = renderFeedLinks(term, className);
+  const related = renderRelatedTerms(term, options);
+  const html = `<section class="${className}" data-rr-taxonomy="${term.kind}" data-rr-taxonomy-value="${escapeHtmlAttribute(
+    term.value
+  )}"><h1 class="${className}__title">${escapeHtml(term.title)}</h1><p class="${className}__count" data-rr-taxonomy-count="${term.entries.length}">${term.entries.length}</p>${feeds}<ul class="${className}__list">${entries}</ul>${related}</section>`;
+  return {
+    title: term.title,
+    frontmatter: { title: term.title },
+    html,
+    headTags: buildFeedHeadTags(term)
+  };
+}
+function renderRelatedTerms(term, options) {
+  if (!options.related || term.kind !== "tag" || term.related.length === 0) {
+    return "";
+  }
+  const className = escapeHtmlAttribute(options.className);
+  const items = term.related.map(
+    (related) => `<li class="${className}__related-item"><a class="${className}__related-link" href="${escapeHtmlAttribute(
+      related.path
+    )}" data-rr-taxonomy-related-count="${related.count}">${escapeHtml(related.title)}</a></li>`
+  ).join("");
+  return `<nav class="${className}__related" aria-label="Related tags" data-rr-taxonomy-related><ul>${items}</ul></nav>`;
+}
+function renderFeedLinks(term, className) {
+  const links = [];
+  if (term.feeds.rss) {
+    links.push(
+      `<a class="${className}__feed" type="application/rss+xml" href="${escapeHtmlAttribute(term.feeds.rss)}">RSS</a>`
+    );
+  }
+  if (term.feeds.atom) {
+    links.push(
+      `<a class="${className}__feed" type="application/atom+xml" href="${escapeHtmlAttribute(term.feeds.atom)}">Atom</a>`
+    );
+  }
+  if (term.feeds.json) {
+    links.push(
+      `<a class="${className}__feed" type="application/feed+json" href="${escapeHtmlAttribute(term.feeds.json)}">JSON</a>`
+    );
+  }
+  if (links.length === 0) return "";
+  return `<nav class="${className}__feeds" aria-label="Feeds" data-rr-taxonomy-feeds>${links.join("")}</nav>`;
+}
+
+// src/seo.ts
+import { resolvePlugins } from "@riebeckite/core";
+function buildTaxonomySeo(config, term) {
+  const description = buildDescription(term);
+  const provider = resolvePlugins(config.plugins).find(
+    (plugin) => plugin.seo !== void 0
+  )?.seo;
+  if (provider) {
+    return provider.buildWebsiteSeo(config, {
+      title: term.title,
+      description,
+      path: term.path,
+      kind: term.kind === "tag" ? "tag" : "website"
+    });
+  }
+  const image = config.site.defaultOgImage;
+  return {
+    title: config.site.title && config.site.title !== term.title ? `${term.title} | ${config.site.title}` : term.title,
+    description,
+    canonicalUrl: buildTaxonomyAbsoluteUrl(config, term.path),
+    imageUrl: image ? buildTaxonomyAbsoluteUrl(config, image) : "",
+    type: "website",
+    noindex: false,
+    tags: term.kind === "tag" ? [term.value] : []
+  };
+}
+function buildDescription(term) {
+  if (term.kind === "tag") {
+    return `Notes tagged with ${term.title}.`;
+  }
+  return `Notes filed under ${term.title}.`;
+}
+
+// index.ts
+var TAXONOMY_PLUGIN_NAME = "taxonomy";
+function taxonomy(options = {}) {
+  const resolved = resolveTaxonomyOptions(options);
+  const emittedFeeds = /* @__PURE__ */ new Set();
+  return definePlugin({
+    name: TAXONOMY_PLUGIN_NAME,
+    options,
+    validateOptions: validateTaxonomyOptions,
+    resolveContentLocations: ({ entries, diagnostics }) => resolveFolderIndexLocations(entries, resolved, diagnostics),
+    endpoints: createTaxonomyEndpoints(resolved),
+    buildEnd(context) {
+      const { config, manifest } = context;
+      if (!config) return;
+      const index = buildTaxonomyIndex(manifest.publicEntries, resolved);
+      for (const term of [...index.tags, ...index.folders]) {
+        for (const format of enabledFormats(resolved)) {
+          const path = feedFilePath(term.path, format);
+          if (emittedFeeds.has(path)) continue;
+          emittedFeeds.add(path);
+          context.output.emit({
+            path,
+            content: renderTermFeed(config, term, format, resolved.feedLimit)
+          });
+        }
+      }
+    },
+    assets: [createStyleAsset(TAXONOMY_PLUGIN_NAME)]
+  });
+}
+var taxonomyPlugin = taxonomy;
+function resolveTaxonomyOptionsFromConfig(config) {
+  const plugin = resolvePlugins2(config.plugins).find(
+    (candidate) => candidate.name === TAXONOMY_PLUGIN_NAME
+  );
+  return resolveTaxonomyOptions(
+    plugin?.options ?? {}
+  );
+}
+function createTaxonomyEndpoints(resolved) {
+  if (!resolved.tags && !resolved.folders) return [];
+  return [
+    defineEndpoint(
+      resolved.dataEndpoint,
+      ({ manifest }) => ({
+        json: serializeTaxonomyIndex(
+          buildTaxonomyIndex(manifest.publicEntries, resolved)
+        )
+      }),
+      { cacheControl: "public, max-age=300" }
+    )
+  ];
+}
+function enabledFormats(resolved) {
+  const formats = [];
+  if (resolved.feeds.rss) formats.push("rss");
+  if (resolved.feeds.atom) formats.push("atom");
+  if (resolved.feeds.json) formats.push("json");
+  return formats;
+}
+function feedFilePath(path, format) {
+  const base = path.replace(/^\/+/, "");
+  if (format === "rss") return `${base}/feed.xml`;
+  if (format === "atom") return `${base}/atom.xml`;
+  return `${base}/feed.json`;
+}
+function validateTaxonomyOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  const assertBoolean = (key) => {
+    const value = options[key];
+    if (value !== void 0 && typeof value !== "boolean") {
+      issues.push({ path: key, message: "Expected a boolean." });
+    }
+  };
+  const assertNonEmptyString = (key) => {
+    const value = options[key];
+    if (value !== void 0 && (typeof value !== "string" || value.trim() === "")) {
+      issues.push({ path: key, message: "Expected a non-empty string." });
+    }
+  };
+  const assertNonNegativeInteger = (key) => {
+    const value = options[key];
+    if (value !== void 0 && (typeof value !== "number" || !Number.isInteger(value) || value < 0)) {
+      issues.push({
+        path: key,
+        message: "Expected a non-negative integer."
+      });
+    }
+  };
+  for (const key of ["tags", "folders", "related", "folderIndexes"]) {
+    assertBoolean(key);
+  }
+  for (const key of [
+    "tagsBasePath",
+    "foldersBasePath",
+    "className",
+    "dataEndpoint"
+  ]) {
+    assertNonEmptyString(key);
+  }
+  for (const key of [
+    "folderDepth",
+    "minEntries",
+    "relatedLimit",
+    "feedLimit"
+  ]) {
+    assertNonNegativeInteger(key);
+  }
+  if (options.feeds !== void 0) {
+    if (typeof options.feeds !== "object" || options.feeds === null) {
+      issues.push({ path: "feeds", message: "Expected an object." });
+    } else {
+      for (const key of ["rss", "atom", "json"]) {
+        const value = options.feeds[key];
+        if (value !== void 0 && typeof value !== "boolean") {
+          issues.push({
+            path: `feeds.${key}`,
+            message: "Expected a boolean."
+          });
+        }
+      }
+    }
+  }
+  if (options.resolveTitle !== void 0 && typeof options.resolveTitle !== "function") {
+    issues.push({ path: "resolveTitle", message: "Expected a function." });
+  }
+  return issues;
+}
+export {
+  DEFAULT_TAXONOMY_CLASS_NAME,
+  DEFAULT_TAXONOMY_DATA_ENDPOINT,
+  DEFAULT_TAXONOMY_FEED_LIMIT,
+  DEFAULT_TAXONOMY_FOLDERS_BASE_PATH,
+  DEFAULT_TAXONOMY_MIN_ENTRIES,
+  DEFAULT_TAXONOMY_RELATED_LIMIT,
+  DEFAULT_TAXONOMY_TAGS_BASE_PATH,
+  TAXONOMY_PLUGIN_NAME,
+  buildFeedHeadTags,
+  buildTaxonomyAbsoluteUrl,
+  buildTaxonomyIndex,
+  buildTaxonomySeo,
+  renderRelatedTerms,
+  renderTaxonomyPage,
+  renderTermFeed,
+  resolveFolderIndexLocations,
+  resolveTaxonomyOptions,
+  resolveTaxonomyOptionsFromConfig,
+  serializeTaxonomyIndex,
+  serializeTaxonomyTerm,
+  slugifyTaxonomyValue,
+  taxonomy,
+  taxonomyPlugin,
+  toEntryReference
+};

package/dist/src/collections.d.ts

@@ -0,0 +1,17 @@
+import { type ContentManifestEntry } from "@riebeckite/core";
+import type { ResolvedTaxonomyOptions, TaxonomyEntryReference, TaxonomyIndex, TaxonomyIndexData, TaxonomyTerm, TaxonomyTermData } from "./types.js";
+/**
+ * Builds the tag and folder taxonomy for the given entries. It reuses the Core
+ * collection contract (`buildContentCollections`), so entries are selected and
+ * ordered by the shared query engine and links always use the resolved
+ * `permalink`.
+ *
+ * `entries` should be the manifest's public view; unpublished notes never reach
+ * generated data or feeds.
+ */
+export declare function buildTaxonomyIndex(entries: readonly ContentManifestEntry[], options: ResolvedTaxonomyOptions): TaxonomyIndex;
+/** Projects a term into a JSON-safe shape for endpoints and client data. */
+export declare function serializeTaxonomyTerm(term: TaxonomyTerm): TaxonomyTermData;
+/** Projects the whole index into a JSON-safe shape. */
+export declare function serializeTaxonomyIndex(index: TaxonomyIndex): TaxonomyIndexData;
+export declare function toEntryReference(entry: ContentManifestEntry): TaxonomyEntryReference;

package/dist/src/feeds.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import type { TaxonomyFeedFormat, TaxonomyHeadTag, TaxonomyTerm } from "./types.js";
+/**
+ * Renders a per-term feed. Term feeds carry their own channel title and self
+ * link so a tag subscription is distinguishable from the site-wide feed that
+ * `@riebeckite/plugin-seo` owns.
+ */
+export declare function renderTermFeed(config: ResolvedRiebeckiteConfig, term: TaxonomyTerm, format: TaxonomyFeedFormat, limit?: number): string;
+/** Builds the `<link rel="alternate">` discovery tags for a term. */
+export declare function buildFeedHeadTags(term: TaxonomyTerm): TaxonomyHeadTag[];