@riebeckite/plugin-taxonomy 0.0.22 → 0.0.24

package/dist/index.js

@@ -499,7 +499,6 @@ function buildDescription(term) {
 var TAXONOMY_PLUGIN_NAME = "taxonomy";
 function taxonomy(options = {}) {
   const resolved = resolveTaxonomyOptions(options);
-  const emittedFeeds = /* @__PURE__ */ new Set();
   return definePlugin({
     name: TAXONOMY_PLUGIN_NAME,
     options,
@@ -509,7 +508,14 @@ function taxonomy(options = {}) {
       {
         id: "taxonomy-term",
         paths: ({ manifest }) => taxonomyPagePaths(manifest.discoverableEntries, resolved),
-        outputDependencies: [{ type: "global" }],
+        outputDependencies: ({ manifest, pathname }) => {
+          const term = findTaxonomyTerm(
+            manifest.discoverableEntries,
+            resolved,
+            pathname
+          );
+          return term ? taxonomyPageOutputDependencies(term, resolved.related) : [{ type: "unknown" }];
+        },
         resolve: ({ manifest, pathname }) => {
           const term = findTaxonomyTerm(
             manifest.discoverableEntries,
@@ -530,7 +536,14 @@ function taxonomy(options = {}) {
       {
         id: "taxonomy-index",
         paths: () => taxonomyIndexPagePaths(resolved),
-        outputDependencies: [{ type: "global" }],
+        outputDependencies: ({ pathname }) => {
+          const kind = resolveTaxonomyIndexPath(pathname, resolved);
+          const dependency = kind === "tag" ? { type: "projection", projection: "taxonomy-tags" } : kind === "folder" ? {
+            type: "projection",
+            projection: "taxonomy-folders"
+          } : void 0;
+          return dependency ? [...pageProjectionDependencies, dependency] : [{ type: "unknown" }];
+        },
         resolve: ({ manifest, pathname }) => {
           const kind = resolveTaxonomyIndexPath(pathname, resolved);
           if (!kind) return null;
@@ -552,24 +565,36 @@ function taxonomy(options = {}) {
         }
       }
     ],
-    buildEnd(context) {
-      const { config, manifest } = context;
-      if (!config) return;
-      const index = buildTaxonomyIndex(manifest.discoverableEntries, resolved);
+    planGeneratedOutputs(context) {
+      if (!context.site) return [];
+      const index = buildTaxonomyIndex(
+        context.manifest.discoverableEntries,
+        resolved
+      );
+      const outputs = [];
       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({
+          outputs.push({
             path,
-            content: renderTermFeed(config, term, format, resolved.feedLimit),
-            dependencies: [{ type: "global" }]
+            content: renderTermFeed(
+              { site: context.site },
+              term,
+              format,
+              resolved.feedLimit
+            ),
+            dependencies: taxonomyOutputDependencies(term)
           });
         }
       }
+      return outputs;
     },
-    assets: [createStyleAsset(TAXONOMY_PLUGIN_NAME)]
+    assets: [
+      createStyleAsset(
+        TAXONOMY_PLUGIN_NAME,
+        "@riebeckite/plugin-taxonomy/style.css"
+      )
+    ]
   });
 }
 var taxonomyPlugin = taxonomy;
@@ -577,6 +602,23 @@ function taxonomyPagePaths(entries, options) {
   const index = buildTaxonomyIndex(entries, options);
   return [...index.tags, ...index.folders].map((term) => term.path);
 }
+function taxonomyOutputDependencies(term) {
+  return [
+    term.kind === "tag" ? { type: "tag", tag: term.value } : { type: "folder", folder: term.value }
+  ];
+}
+function taxonomyPageOutputDependencies(term, related) {
+  const relatedDependencies = related && term.kind === "tag" ? [{ type: "projection", projection: "taxonomy-tags" }] : [];
+  return [
+    ...pageProjectionDependencies,
+    ...taxonomyOutputDependencies(term),
+    ...relatedDependencies
+  ];
+}
+var pageProjectionDependencies = [
+  { type: "projection", projection: "navigation" },
+  { type: "projection", projection: "recent-posts" }
+];
 function findTaxonomyTerm(entries, options, pathname) {
   const index = buildTaxonomyIndex(entries, options);
   return [...index.tags, ...index.folders].find(

package/dist/src/feeds.d.ts

@@ -5,6 +5,6 @@ import type { TaxonomyFeedFormat, TaxonomyHeadTag, TaxonomyTerm } from "./types.
  * 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;
+export declare function renderTermFeed(config: Pick<ResolvedRiebeckiteConfig, "site">, term: TaxonomyTerm, format: TaxonomyFeedFormat, limit?: number): string;
 /** Builds the `<link rel="alternate">` discovery tags for a term. */
 export declare function buildFeedHeadTags(term: TaxonomyTerm): TaxonomyHeadTag[];

package/dist/src/url.d.ts

@@ -4,4 +4,4 @@ import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
  * SEO plugin's absolute-URL convention so taxonomy feeds and metadata match the
  * rest of the site without depending on the SEO package.
  */
-export declare function buildTaxonomyAbsoluteUrl(config: ResolvedRiebeckiteConfig, pathOrUrl: string): string;
+export declare function buildTaxonomyAbsoluteUrl(config: Pick<ResolvedRiebeckiteConfig, "site">, pathOrUrl: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/plugin-taxonomy",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,7 +15,7 @@
     "./style.css": "./style.css"
   },
   "dependencies": {
-    "@riebeckite/core": "0.0.22"
+    "@riebeckite/core": "0.0.24"
   },
   "devDependencies": {
     "tsx": "^4.22.4"