@riebeckite/core 0.0.28 → 0.0.30

package/dist/index.d.ts

@@ -32,6 +32,8 @@ export { buildGraphEdges, layoutForceGraph, layoutRadialGraph, } from "./src/con
 export { IMAGE_EXTENSIONS } from "./src/content/image_extensions.js";
 export type { OutputChangeSet, OutputDescriptor, OutputKind, } from "./src/content/output_dependency.js";
 export { buildOutputInventory, determineOutputChanges, htmlOutputPath, } from "./src/content/output_dependency.js";
+export type { OutputPlan, OutputPlanAction, OutputPlanComparison, OutputPlanConflict, OutputPlanEntry, OutputPlanInput, OutputPlanKind, OutputPlanOwner, } from "./src/content/output_plan.js";
+export { buildOutputPlan, compareOutputPlan, } from "./src/content/output_plan.js";
 export { createPublicContentView, type PublicContentEntry, type PublicContentView, } from "./src/content/public_content_view.js";
 export type { PublishingResolutionOptions, PublishingVisibility, ResolvedPublishingState, } from "./src/content/publishing.js";
 export { resolvePublishingBuildTime, resolvePublishingState, } from "./src/content/publishing.js";

package/dist/index.js

@@ -6515,6 +6515,120 @@ function clampFinite(value, min, max) {
   return clamp(value, min, max);
 }
 
+// src/content/output_plan.ts
+function buildOutputPlan(input) {
+  const candidates = [
+    ...input.inventory.map((output) => inventoryEntry(output, input)),
+    ...(input.removed ?? []).map(removedEntry),
+    ...entriesForPaths(
+      input.honoStaticRoutePaths,
+      "hono-static-route",
+      "hono-static-route",
+      "route"
+    ),
+    ...entriesForPaths(
+      input.viteClientAssetPaths,
+      "vite-client-asset",
+      "asset",
+      "client"
+    ),
+    ...entriesForPaths(
+      input.sitePublicAssetPaths,
+      "site-public-asset",
+      "asset",
+      "public"
+    )
+  ];
+  const byPath = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const existing = byPath.get(candidate.path) ?? [];
+    existing.push(candidate);
+    byPath.set(candidate.path, existing);
+  }
+  const conflicts = [...byPath.entries()].filter(
+    ([, entries2]) => new Set(entries2.map((entry) => entry.owner)).size > 1
+  ).map(([path6, entries2]) => ({
+    path: path6,
+    owners: [...new Set(entries2.map((entry) => entry.owner))].sort()
+  })).sort((left, right) => left.path.localeCompare(right.path));
+  const entries = [...byPath.values()].map((samePathEntries) => samePathEntries[0]).sort((left, right) => left.path.localeCompare(right.path));
+  return {
+    entries,
+    conflicts,
+    unknownPaths: entries.filter((entry) => entry.owner === "unknown").map((entry) => entry.path)
+  };
+}
+function compareOutputPlan(plan, actualPaths) {
+  const actual = new Set(actualPaths);
+  const entries = new Map(plan.entries.map((entry) => [entry.path, entry]));
+  const missingInPlan = [...actual].filter((path6) => {
+    const entry = entries.get(path6);
+    return entry === void 0 || entry.owner === "unknown";
+  }).sort();
+  const missingInDist = plan.entries.filter((entry) => entry.expectedToExist && !actual.has(entry.path)).map((entry) => entry.path).sort();
+  const publicationViolations = plan.entries.filter(
+    (entry) => entry.owner !== "unknown" && !entry.publicationEligible && actual.has(entry.path)
+  ).map((entry) => entry.path).sort();
+  const unknown = [
+    .../* @__PURE__ */ new Set([
+      ...plan.entries.filter((entry) => entry.owner === "unknown").map((entry) => entry.path),
+      ...missingInPlan
+    ])
+  ].sort();
+  const matched = plan.entries.filter(
+    (entry) => entry.owner !== "unknown" && entry.expectedToExist && actual.has(entry.path)
+  ).map((entry) => entry.path);
+  return {
+    matched,
+    missingInPlan,
+    missingInDist,
+    ownerConflicts: plan.conflicts,
+    unknown,
+    publicationViolations
+  };
+}
+function inventoryEntry(output, input) {
+  const affected = input.affectedPaths?.has(output.path) ?? true;
+  const cacheAvailable = input.cacheAvailable ?? false;
+  return {
+    path: output.path,
+    owner: output.producer.startsWith("content:") ? "content" : "plugin",
+    kind: output.kind,
+    source: output.producer,
+    dependencies: output.dependencies,
+    publicationEligible: true,
+    cacheEligible: true,
+    expectedToExist: true,
+    action: affected || !cacheAvailable ? "generate" : "reuse"
+  };
+}
+function removedEntry(output) {
+  return {
+    path: output.path,
+    owner: output.producer.startsWith("content:") ? "content" : "plugin",
+    kind: output.kind,
+    source: output.producer,
+    dependencies: output.dependencies,
+    publicationEligible: false,
+    cacheEligible: false,
+    expectedToExist: false,
+    action: "remove"
+  };
+}
+function entriesForPaths(paths, owner, kind, sourceKind) {
+  return [...paths ?? []].map((path6) => ({
+    path: path6,
+    owner,
+    kind,
+    source: `${sourceKind}:${path6}`,
+    dependencies: [{ type: "unknown" }],
+    publicationEligible: true,
+    cacheEligible: false,
+    expectedToExist: true,
+    action: "unknown"
+  }));
+}
+
 // src/content/public_content_view.ts
 var emptyEntries = Object.freeze([]);
 function createPublicContentView(manifest) {
@@ -6726,7 +6840,9 @@ export {
   buildContentCollections,
   buildGraphEdges,
   buildOutputInventory,
+  buildOutputPlan,
   calculateReadingTime,
+  compareOutputPlan,
   computePipelineFingerprint,
   createClientEntry,
   createContentGraph,

package/dist/src/content/output_plan.d.ts

@@ -0,0 +1,44 @@
+import type { OutputDependency } from "../types/output_dependency.js";
+import type { OutputDescriptor } from "./output_dependency.js";
+export type OutputPlanOwner = "content" | "plugin" | "hono-static-route" | "vite-client-asset" | "site-public-asset" | "unknown";
+export type OutputPlanKind = "content" | "redirect" | "plugin-page" | "generated" | "hono-static-route" | "asset" | "unknown";
+export type OutputPlanAction = "generate" | "reuse" | "remove" | "unknown";
+export type OutputPlanEntry = {
+    readonly path: string;
+    readonly owner: OutputPlanOwner;
+    readonly kind: OutputPlanKind;
+    readonly source: string;
+    readonly dependencies: readonly OutputDependency[];
+    readonly publicationEligible: boolean;
+    readonly cacheEligible: boolean;
+    readonly expectedToExist: boolean;
+    readonly action: OutputPlanAction;
+};
+export type OutputPlanConflict = {
+    readonly path: string;
+    readonly owners: readonly OutputPlanOwner[];
+};
+export type OutputPlan = {
+    readonly entries: readonly OutputPlanEntry[];
+    readonly conflicts: readonly OutputPlanConflict[];
+    readonly unknownPaths: readonly string[];
+};
+export type OutputPlanComparison = {
+    readonly matched: readonly string[];
+    readonly missingInPlan: readonly string[];
+    readonly missingInDist: readonly string[];
+    readonly ownerConflicts: readonly OutputPlanConflict[];
+    readonly unknown: readonly string[];
+    readonly publicationViolations: readonly string[];
+};
+export type OutputPlanInput = {
+    readonly inventory: readonly OutputDescriptor[];
+    readonly affectedPaths?: ReadonlySet<string>;
+    readonly removed?: readonly OutputDescriptor[];
+    readonly cacheAvailable?: boolean;
+    readonly honoStaticRoutePaths?: ReadonlySet<string>;
+    readonly viteClientAssetPaths?: ReadonlySet<string>;
+    readonly sitePublicAssetPaths?: ReadonlySet<string>;
+};
+export declare function buildOutputPlan(input: OutputPlanInput): OutputPlan;
+export declare function compareOutputPlan(plan: OutputPlan, actualPaths: Iterable<string>): OutputPlanComparison;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/core",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.28"
+    "@riebeckite/test": "0.0.30"
   },
   "repository": {
     "type": "git",