@emeryld/rrroutes-export 1.0.12 → 1.0.14

package/README.md

@@ -9,6 +9,8 @@ Export helpers and CLI for RRRoutes finalized leaves.
   - `writeFinalizedLeavesExport`
   - `exportFinalizedLeavesChangelog`
   - `writeFinalizedLeavesChangelogExport`
+  - `buildFinalizedLeavesViewerBundle`
+  - `writeFinalizedLeavesViewerBundle`
 - CLI:
   - `rrroutes-export-finalized-leaves`
   - `rrroutes-export-changelog`
@@ -134,6 +136,8 @@ Per run, it writes a timestamped directory:
 - `finalized-leaves.viewer.html`
 - `finalized-leaves.changelog.json`
 - `finalized-leaves.changelog.viewer.html`
+- `finalized-leaves.bundle.json`
+- `finalized-leaves.bundle.viewer.html`
 - `summary.json`
 
 This is the recommended CI/release flow because outputs are immutable per run and easy to archive.
@@ -142,8 +146,10 @@ This is the recommended CI/release flow because outputs are immutable per run an
 
 ```ts
 import {
+  buildFinalizedLeavesViewerBundle,
   exportFinalizedLeaves,
   exportFinalizedLeavesChangelog,
+  writeFinalizedLeavesViewerBundle,
 } from '@emeryld/rrroutes-export'
 
 const snapshot = await exportFinalizedLeaves(leaves, {
@@ -165,4 +171,14 @@ const changelog = await exportFinalizedLeavesChangelog({
   htmlFile: './finalized-leaves.changelog.viewer.html',
   log: (message) => console.log(message),
 })
+
+const unified = buildFinalizedLeavesViewerBundle({
+  leavesPayload: snapshot,
+  changelogPayload: changelog,
+})
+
+await writeFinalizedLeavesViewerBundle(unified, {
+  outFile: './finalized-leaves.bundle.json',
+  htmlFile: './finalized-leaves.bundle.viewer.html',
+})
 ```

package/dist/exportFinalizedLeaves.bundle.d.ts

@@ -0,0 +1,21 @@
+import type { FinalizedLeavesExport, WriteFinalizedLeavesExportOptions } from './exportFinalizedLeaves';
+import type { FinalizedLeavesChangelogExport } from './exportFinalizedLeaves.changelog';
+export type FinalizedLeavesViewerBundleMeta = {
+    generatedAt: string;
+    description: string;
+};
+export type FinalizedLeavesViewerBundle = {
+    kind: 'finalized-leaves-bundle';
+    _meta: FinalizedLeavesViewerBundleMeta;
+    leavesPayload: FinalizedLeavesExport;
+    changelogPayload: FinalizedLeavesChangelogExport;
+};
+export type BuildFinalizedLeavesViewerBundleInput = {
+    leavesPayload: FinalizedLeavesExport;
+    changelogPayload: FinalizedLeavesChangelogExport;
+};
+export declare function buildFinalizedLeavesViewerBundle(input: BuildFinalizedLeavesViewerBundleInput): FinalizedLeavesViewerBundle;
+export declare function writeFinalizedLeavesViewerBundle(payload: FinalizedLeavesViewerBundle, outFileOrOptions: string | WriteFinalizedLeavesExportOptions): Promise<{
+    outFile?: string;
+    htmlFile?: string;
+}>;

package/dist/exportFinalizedLeaves.changelog.d.ts

@@ -58,6 +58,7 @@ export type SourceSchemaPathDelta = {
 export type ChangelogCommit = {
     sha: string;
     authorDate: string;
+    authorName: string;
     subject: string;
 };
 export type RouteChangeType = 'route_added' | 'route_removed' | 'schema_changed' | 'cfg_changed';

package/dist/index.cjs

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   DEFAULT_VIEWER_TEMPLATE: () => DEFAULT_VIEWER_TEMPLATE,
   __private: () => __private,
+  buildFinalizedLeavesViewerBundle: () => buildFinalizedLeavesViewerBundle,
   clearSchemaIntrospectionHandlers: () => clearSchemaIntrospectionHandlers,
   createSchemaIntrospector: () => createSchemaIntrospector,
   exportFinalizedLeaves: () => exportFinalizedLeaves,
@@ -50,7 +51,8 @@ __export(index_exports, {
   serializeLeafContract: () => serializeLeafContract,
   serializeLeavesContract: () => serializeLeavesContract,
   writeFinalizedLeavesChangelogExport: () => writeFinalizedLeavesChangelogExport,
-  writeFinalizedLeavesExport: () => writeFinalizedLeavesExport
+  writeFinalizedLeavesExport: () => writeFinalizedLeavesExport,
+  writeFinalizedLeavesViewerBundle: () => writeFinalizedLeavesViewerBundle
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -350,46 +352,46 @@ function normalizeType(schema) {
       return "unknown";
   }
 }
-function isNonEmptyPath(path6) {
-  return typeof path6 === "string" && path6.length > 0;
+function isNonEmptyPath(path7) {
+  return typeof path7 === "string" && path7.length > 0;
 }
-function setNode(out, path6, schema, inherited) {
-  if (!isNonEmptyPath(path6)) return;
-  out[path6] = {
+function setNode(out, path7, schema, inherited) {
+  if (!isNonEmptyPath(path7)) return;
+  out[path7] = {
     type: normalizeType(schema),
     nullable: inherited.nullable || Boolean(schema.nullable),
     optional: inherited.optional || Boolean(schema.optional),
     literal: schema.kind === "literal" ? schema.literal : void 0
   };
 }
-function flattenInto(out, schema, path6, inherited) {
-  if (!schema || !isNonEmptyPath(path6)) return;
+function flattenInto(out, schema, path7, inherited) {
+  if (!schema || !isNonEmptyPath(path7)) return;
   const nextInherited = {
     optional: inherited.optional || Boolean(schema.optional),
     nullable: inherited.nullable || Boolean(schema.nullable)
   };
   if (schema.kind === "union" && Array.isArray(schema.union) && schema.union.length > 0) {
     schema.union.forEach((option, index) => {
-      const optionPath = `${path6}-${index + 1}`;
+      const optionPath = `${path7}-${index + 1}`;
       flattenInto(out, option, optionPath, inherited);
     });
     return;
   }
-  setNode(out, path6, schema, inherited);
+  setNode(out, path7, schema, inherited);
   if (schema.kind === "object" && schema.properties) {
     for (const [key, child] of Object.entries(schema.properties)) {
-      const childPath = `${path6}.${key}`;
+      const childPath = `${path7}.${key}`;
       flattenInto(out, child, childPath, nextInherited);
     }
     return;
   }
   if (schema.kind === "array" && schema.element) {
-    flattenInto(out, schema.element, `${path6}[]`, nextInherited);
+    flattenInto(out, schema.element, `${path7}[]`, nextInherited);
   }
 }
-function flattenSerializableSchema(schema, path6) {
+function flattenSerializableSchema(schema, path7) {
   const out = {};
-  flattenInto(out, schema, path6, { optional: false, nullable: false });
+  flattenInto(out, schema, path7, { optional: false, nullable: false });
   return out;
 }
 function isSerializedLeaf(value) {
@@ -1661,14 +1663,15 @@ async function filterCommits(cwd, commits, moduleCandidates, tsconfigRel) {
   return keep;
 }
 async function getCommitMetadata(cwd, commit) {
-  const out = await runGit(cwd, ["show", "-s", "--format=%H%x1f%aI%x1f%s", commit]);
-  const [sha, authorDate, subject] = out.split("");
-  if (!sha || !authorDate) {
+  const out = await runGit(cwd, ["show", "-s", "--format=%H%x1f%aI%x1f%an%x1f%s", commit]);
+  const [sha, authorDate, authorName, subject] = out.split("");
+  if (!sha || !authorDate || !authorName) {
     throw new Error(`Unable to read commit metadata for ${commit}`);
   }
   return {
     sha,
     authorDate,
+    authorName,
     subject: subject ?? ""
   };
 }
@@ -2619,10 +2622,124 @@ async function runExportFinalizedLeavesChangelogCli(argv) {
     htmlFile: args.htmlFile ? import_node_path5.default.resolve(args.htmlFile) : void 0
   };
 }
+
+// src/exportFinalizedLeaves.bundle.ts
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_child_process3 = require("child_process");
+var BAKED_PAYLOAD_MARKER3 = "<!--__FINALIZED_LEAVES_BAKED_PAYLOAD__-->";
+function escapePayloadForInlineScript3(payload) {
+  return JSON.stringify(payload).replace(/<\//g, "<\\/").replace(/<!--/g, "<\\!--");
+}
+function injectPayloadIntoViewerHtml3(htmlTemplate, payload) {
+  const payloadScript = `${BAKED_PAYLOAD_MARKER3}
+<script id="finalized-leaves-baked-payload">window.__FINALIZED_LEAVES_PAYLOAD = ${escapePayloadForInlineScript3(
+    payload
+  )};</script>`;
+  if (htmlTemplate.includes(BAKED_PAYLOAD_MARKER3)) {
+    return htmlTemplate.replace(BAKED_PAYLOAD_MARKER3, payloadScript);
+  }
+  if (htmlTemplate.includes("</body>")) {
+    return htmlTemplate.replace("</body>", `${payloadScript}
+</body>`);
+  }
+  return `${payloadScript}
+${htmlTemplate}`;
+}
+async function resolveViewerTemplatePath3(viewerTemplateFile) {
+  if (viewerTemplateFile) {
+    const resolved = import_node_path6.default.resolve(viewerTemplateFile);
+    await import_promises3.default.access(resolved);
+    return resolved;
+  }
+  const candidates = [
+    import_node_path6.default.resolve(
+      process.cwd(),
+      "node_modules/@emeryld/rrroutes-export/tools/finalized-leaves-viewer.html"
+    ),
+    import_node_path6.default.resolve(process.cwd(), "tools/finalized-leaves-viewer.html"),
+    import_node_path6.default.resolve(process.cwd(), "packages/export/tools/finalized-leaves-viewer.html")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await import_promises3.default.access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function writeJsonExport3(payload, outFile) {
+  const resolved = import_node_path6.default.resolve(outFile);
+  await import_promises3.default.mkdir(import_node_path6.default.dirname(resolved), { recursive: true });
+  await import_promises3.default.writeFile(resolved, `${JSON.stringify(payload, null, 2)}
+`, "utf8");
+  return resolved;
+}
+async function writeBakedHtmlExport3(payload, htmlFile, viewerTemplateFile) {
+  const templatePath = await resolveViewerTemplatePath3(viewerTemplateFile);
+  const template = templatePath ? await import_promises3.default.readFile(templatePath, "utf8") : DEFAULT_VIEWER_TEMPLATE;
+  const baked = injectPayloadIntoViewerHtml3(template, payload);
+  const resolved = import_node_path6.default.resolve(htmlFile);
+  await import_promises3.default.mkdir(import_node_path6.default.dirname(resolved), { recursive: true });
+  await import_promises3.default.writeFile(resolved, baked, "utf8");
+  return resolved;
+}
+async function openHtmlInBrowser3(filePath) {
+  const resolved = import_node_path6.default.resolve(filePath);
+  const platform = process.platform;
+  if (platform === "darwin") {
+    (0, import_node_child_process3.spawn)("open", [resolved], { detached: true, stdio: "ignore" }).unref();
+    return;
+  }
+  if (platform === "win32") {
+    (0, import_node_child_process3.spawn)("cmd", ["/c", "start", "", resolved], {
+      detached: true,
+      stdio: "ignore"
+    }).unref();
+    return;
+  }
+  (0, import_node_child_process3.spawn)("xdg-open", [resolved], { detached: true, stdio: "ignore" }).unref();
+}
+function buildFinalizedLeavesViewerBundle(input) {
+  return {
+    kind: "finalized-leaves-bundle",
+    _meta: {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      description: "Unified viewer bundle including finalized leaves snapshot and changelog timeline payloads."
+    },
+    leavesPayload: input.leavesPayload,
+    changelogPayload: input.changelogPayload
+  };
+}
+async function writeFinalizedLeavesViewerBundle(payload, outFileOrOptions) {
+  const options = typeof outFileOrOptions === "string" ? { outFile: outFileOrOptions } : outFileOrOptions;
+  const written = {};
+  if (options.outFile) {
+    written.outFile = await writeJsonExport3(payload, options.outFile);
+  }
+  if (options.htmlFile) {
+    written.htmlFile = await writeBakedHtmlExport3(
+      payload,
+      options.htmlFile,
+      options.viewerTemplateFile
+    );
+  }
+  if (options.openOnFinish) {
+    if (!written.htmlFile) {
+      throw new Error(
+        "openOnFinish requires htmlFile. Provide htmlFile to open the baked viewer."
+      );
+    }
+    await openHtmlInBrowser3(written.htmlFile);
+  }
+  return written;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_VIEWER_TEMPLATE,
   __private,
+  buildFinalizedLeavesViewerBundle,
   clearSchemaIntrospectionHandlers,
   createSchemaIntrospector,
   exportFinalizedLeaves,
@@ -2641,6 +2758,7 @@ async function runExportFinalizedLeavesChangelogCli(argv) {
   serializeLeafContract,
   serializeLeavesContract,
   writeFinalizedLeavesChangelogExport,
-  writeFinalizedLeavesExport
+  writeFinalizedLeavesExport,
+  writeFinalizedLeavesViewerBundle
 });
 //# sourceMappingURL=index.cjs.map