@pretextbook/import 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,6 +1,7 @@
-import { d as j, r as v, a as R, f as g, b as h, w as P, s as b, e as A, c as M, p as $ } from "./import-mode-Dc8qmZP6.js";
-import { L as B, M as W, P as X, g as G, h as U, i as H, j as q, k as J, l as Q, m as V, n as Y, o as Z, q as tt, t as et, u as nt, v as at, x as st, y as ot, z as it, A as rt, B as ct, C as lt, D as pt, E as ut, F as mt, G as ft, H as dt, I as Pt, J as gt, K as ht, N as bt, O as xt, Q as Tt, R as Ft, S as St, T as Et } from "./import-mode-Dc8qmZP6.js";
-const k = {
+import { d as w, r as I, a as _, f as E, b as T, w as x, s as v, e as C, c as k, p as y, g as b, h as A } from "./upload-BBHV4rXJ.js";
+import { C as q, L as V, i as Y, M as J, j as Q, P as Z, k as ee, l as te, m as se, n as ne, o as ae, q as oe, t as re, u as ie, v as ce, x as le, y as ue, z as pe, A as fe, B as me, D as de, E as ge, F as Pe, G as he, H as xe, I as be, J as Ee, K as Te, N as ve, O as Se, Q as Le, R as Fe, S as we, T as Ie, U as _e, V as Ce, W as ke, X as ye, Y as Ae, Z as Me, _ as je, $ as Re, a0 as $e, a1 as De, a2 as Ne, a3 as Oe, a4 as Be, a5 as We } from "./upload-BBHV4rXJ.js";
+import { a as Ke, d as ze, b as Ue, c as Ge, f as He, e as qe, g as Ve, p as Ye } from "./import-mode-GqdypBfV.js";
+const M = {
   png: "image/png",
   jpg: "image/jpeg",
   jpeg: "image/jpeg",
@@ -14,103 +15,103 @@ const k = {
   webp: "image/webp",
   ico: "image/vnd.microsoft.icon"
 };
-function I(t) {
-  const e = t.split(".").pop()?.toLowerCase() ?? "";
-  return k[e] ?? "application/octet-stream";
+function j(e) {
+  const s = e.split(".").pop()?.toLowerCase() ?? "";
+  return M[s] ?? "application/octet-stream";
 }
-const f = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function w(t) {
-  const e = t.length, s = [];
-  for (let n = 0; n < e; n += 3) {
-    const a = t[n], i = n + 1 < e, c = n + 2 < e, r = i ? t[n + 1] : 0, l = c ? t[n + 2] : 0;
-    s.push(f[a >> 2]), s.push(f[(a & 3) << 4 | r >> 4]), s.push(i ? f[(r & 15) << 2 | l >> 6] : "="), s.push(c ? f[l & 63] : "=");
+const P = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function R(e) {
+  const s = e.length, o = [];
+  for (let t = 0; t < s; t += 3) {
+    const n = e[t], c = t + 1 < s, r = t + 2 < s, l = c ? e[t + 1] : 0, i = r ? e[t + 2] : 0;
+    o.push(P[n >> 2]), o.push(P[(n & 3) << 4 | l >> 4]), o.push(c ? P[(l & 15) << 2 | i >> 6] : "="), o.push(r ? P[i & 63] : "=");
   }
-  return s.join("");
+  return o.join("");
 }
-function C(t) {
+function $(e) {
   return {
-    ref: t.ref,
+    ref: e.ref,
     kind: "file",
-    title: t.fileName,
-    short_description: t.fileName,
+    title: e.fileName,
+    short_description: e.fileName,
     file: {
-      filename: t.fileName,
-      content_type: I(t.fileName),
-      data: w(t.data)
+      filename: e.fileName,
+      content_type: j(e.fileName),
+      data: R(e.data)
     }
   };
 }
-function N(t) {
+function K(e) {
   return {
-    title: t.title,
-    docinfo: t.docinfo,
-    document_type: t.documentKind,
-    divisions_attributes: t.divisions.map((e) => ({
-      ref: e.xmlId,
-      source: e.content,
-      source_format: e.sourceFormat,
-      is_root: e.isRoot
+    title: e.title,
+    docinfo: e.docinfo,
+    document_type: e.documentKind,
+    divisions_attributes: e.divisions.map((s) => ({
+      ref: s.xmlId,
+      source: s.content,
+      source_format: s.sourceFormat,
+      is_root: s.isRoot
     })),
-    assets_attributes: t.assets.map(C)
+    assets_attributes: e.assets.map($)
   };
 }
-const d = {
+const h = {
   mainSourcePath: "source/main.ptx",
   publicationPath: "publication/publication.ptx",
   projectFilePath: "project.ptx",
   docinfoPath: "source/docinfo.ptx"
 };
-function x(t) {
-  return g(t, "pretext") ? t : `<pretext>
-${t}
+function S(e) {
+  return E(e, "pretext") ? e : `<pretext>
+${e}
 </pretext>`;
 }
-function T(t, e, s) {
-  const n = /* @__PURE__ */ new Map(), a = [], i = `${e}-`;
-  return t.forEach((c, r) => {
-    const l = c.attributes["xml:id"];
-    let p;
-    if (l) {
-      const u = M(l);
-      p = u.startsWith(i) ? u : `${i}${u}`;
+function L(e, s, o) {
+  const t = /* @__PURE__ */ new Map(), n = [], c = `${s}-`;
+  return e.forEach((r, l) => {
+    const i = r.attributes["xml:id"];
+    let u;
+    if (i) {
+      const m = k(i);
+      u = m.startsWith(c) ? m : `${c}${m}`;
     } else
-      p = `${i}${$(r + 1, t.length)}`, s.push({
+      u = `${c}${y(l + 1, e.length)}`, o.push({
         action: "anomaly",
         severity: "info",
         kind: "structure",
         category: "missing_xml_id",
-        macro: c.name,
+        macro: r.name,
         occurrences: 1,
-        message: `<${c.name}> at position ${r + 1} has no xml:id; using \`${p}\` as filename.`
+        message: `<${r.name}> at position ${l + 1} has no xml:id; using \`${u}\` as filename.`
       });
-    const m = n.get(p) ?? 0;
-    n.set(p, m + 1);
-    const o = m === 0 ? p : `${p}-${m + 1}`;
-    a.push({
-      span: c,
-      slug: o,
-      filename: `${o}.ptx`
+    const p = t.get(u) ?? 0;
+    t.set(u, p + 1);
+    const a = p === 0 ? u : `${u}-${p + 1}`;
+    n.push({
+      span: r,
+      slug: a,
+      filename: `${a}.ptx`
     });
-  }), a;
+  }), n;
 }
-function y(t, e, s, n) {
-  const a = h(t, "section");
-  if (a.length === 0)
-    return t;
-  const c = T(a, "sec", n).map((r) => {
-    const l = `source/${e}/${r.filename}`;
-    return s[l] = P(r.span.outer), {
-      start: r.span.start,
-      end: r.span.end,
-      replacement: `<xi:include href="${e}/${r.filename}"/>`
+function D(e, s, o, t) {
+  const n = T(e, "section");
+  if (n.length === 0)
+    return e;
+  const r = L(n, "sec", t).map((l) => {
+    const i = `source/${s}/${l.filename}`;
+    return o[i] = x(l.span.outer), {
+      start: l.span.start,
+      end: l.span.end,
+      replacement: `<xi:include href="${s}/${l.filename}"/>`
     };
   });
-  return b(t, c);
+  return v(e, r);
 }
-function D(t, e, s) {
-  const n = g(t, "book");
-  if (!n)
-    return s.push({
+function N(e, s, o) {
+  const t = E(e, "book");
+  if (!t)
+    return o.push({
       action: "anomaly",
       severity: "warning",
       kind: "structure",
@@ -118,95 +119,200 @@ function D(t, e, s) {
       macro: "book",
       occurrences: 1,
       message: "Document was treated as a book but no <book> element found; emitting as a single file."
-    }), F(t, e);
-  const a = {}, i = h(n.inner, "chapter");
-  let c = n.inner;
-  if (e.splitChapters && i.length > 0) {
-    const m = T(i, "ch", s).map((o) => {
-      let u = o.span.outer;
-      if (e.splitSections) {
-        const E = o.span.inner, _ = y(
-          E,
-          o.slug,
-          a,
-          s
+    }), F(e, s);
+  const n = {}, c = T(t.inner, "chapter");
+  let r = t.inner;
+  if (s.splitChapters && c.length > 0) {
+    const p = L(c, "ch", o).map((a) => {
+      let m = a.span.outer;
+      if (s.splitSections) {
+        const f = a.span.inner, d = D(
+          f,
+          a.slug,
+          n,
+          o
         );
-        u = o.span.outer.slice(0, o.span.startTagEnd - o.span.start) + _ + o.span.outer.slice(o.span.contentEnd - o.span.start);
+        m = a.span.outer.slice(0, a.span.startTagEnd - a.span.start) + d + a.span.outer.slice(a.span.contentEnd - a.span.start);
       }
-      const S = `source/${o.filename}`;
-      return a[S] = P(u), {
-        start: o.span.start,
-        end: o.span.end,
-        replacement: `<xi:include href="${o.filename}"/>`
+      const g = `source/${a.filename}`;
+      return n[g] = x(m), {
+        start: a.span.start,
+        end: a.span.end,
+        replacement: `<xi:include href="${a.filename}"/>`
       };
     });
-    c = b(n.inner, m);
+    r = v(t.inner, p);
   }
-  const r = t.slice(n.start, n.startTagEnd) + c + t.slice(n.contentEnd, n.end), l = t.slice(0, n.start) + r + t.slice(n.end);
-  return a[e.mainSourcePath] = P(
-    A(x(l.trim()))
-  ), a;
-}
-function F(t, e, s) {
-  const n = {};
-  return n[e.mainSourcePath] = P(
-    x(t.trim())
+  const l = e.slice(t.start, t.startTagEnd) + r + e.slice(t.contentEnd, t.end), i = e.slice(0, t.start) + l + e.slice(t.end);
+  return n[s.mainSourcePath] = x(
+    C(S(i.trim()))
   ), n;
 }
-function O(t, e = {}) {
-  const s = [], n = e.documentKind ?? j(t), a = {
-    splitChapters: e.splitChapters ?? n === "book",
-    splitSections: e.splitSections ?? !1,
-    mainSourcePath: e.mainSourcePath ?? d.mainSourcePath,
-    publicationPath: e.publicationPath ?? d.publicationPath,
-    projectFilePath: e.projectFilePath ?? d.projectFilePath,
-    docinfoPath: e.docinfoPath ?? d.docinfoPath
-  }, i = n === "book" ? D(t, a, s) : F(t, a);
-  return i[a.projectFilePath] = v({
-    mainSource: a.mainSourcePath,
-    publication: a.publicationPath
-  }), i[a.publicationPath] = R(), { files: i, documentKind: n, warnings: s };
+function F(e, s, o) {
+  const t = {};
+  return t[s.mainSourcePath] = x(
+    S(e.trim())
+  ), t;
+}
+function z(e, s = {}) {
+  const o = [], t = s.documentKind ?? w(e), n = {
+    splitChapters: s.splitChapters ?? t === "book",
+    splitSections: s.splitSections ?? !1,
+    mainSourcePath: s.mainSourcePath ?? h.mainSourcePath,
+    publicationPath: s.publicationPath ?? h.publicationPath,
+    projectFilePath: s.projectFilePath ?? h.projectFilePath,
+    docinfoPath: s.docinfoPath ?? h.docinfoPath
+  }, c = t === "book" ? N(e, n, o) : F(e, n);
+  return c[n.projectFilePath] = I({
+    mainSource: n.mainSourcePath,
+    publication: n.publicationPath
+  }), c[n.publicationPath] = _(), { files: c, documentKind: t, warnings: o };
+}
+class O extends Error {
+  constructor() {
+    super("Import cancelled."), this.name = "ConversionCancelledError";
+  }
+}
+let B = 0;
+function W(e, s, o = {}) {
+  const t = `convert-${B++}`, n = e(), { assets: c = {}, ...r } = o;
+  let l;
+  const i = new Promise((p, a) => {
+    let m = !1;
+    const g = (f) => {
+      m || (m = !0, n.terminate(), f());
+    };
+    l = () => g(() => a(new O())), n.addEventListener("message", (f) => {
+      const d = f.data;
+      if (!(!d || d.requestId !== t)) {
+        if (d.type === "result") {
+          g(() => p(d.result));
+          return;
+        }
+        g(() => a(new Error(d.message)));
+      }
+    }), n.addEventListener("error", (f) => {
+      const d = typeof f == "object" && f && "message" in f ? String(f.message) : "The import worker failed to start.";
+      g(() => a(new Error(d)));
+    });
+  }), u = [
+    ...new Set(
+      Object.values(c).map((p) => p.buffer).filter(
+        (p) => p instanceof ArrayBuffer
+      )
+    )
+  ];
+  return n.postMessage(
+    { type: "convert", requestId: t, files: s, assets: c, options: r },
+    u
+  ), { result: i, cancel: () => l?.() };
+}
+function U(e) {
+  const {
+    createWorker: s,
+    id: o = "worker",
+    label: t = "Built-in converter",
+    description: n = "Create a new project starting with LaTeX, Markdown, or PreTeXt files.",
+    acceptExtensions: c
+  } = e;
+  let r = null;
+  const l = async (i, u) => {
+    r?.cancel(), r = W(s, i, u);
+    try {
+      return await r.result;
+    } finally {
+      r = null;
+    }
+  };
+  return {
+    id: o,
+    label: t,
+    description: n,
+    acceptExtensions: c,
+    prepare: async (i) => {
+      const { files: u, assets: p } = await b(i);
+      return {
+        fileName: i.name,
+        files: u,
+        assets: p,
+        analysis: A(u)
+      };
+    },
+    convertPrepared: (i, u) => l(i.files, { ...u, assets: i.assets }),
+    convertFile: async (i, u) => {
+      const { files: p, assets: a } = await b(i);
+      return l(p, { ...u, assets: a });
+    },
+    cancel: () => {
+      r?.cancel(), r = null;
+    }
+  };
 }
 export {
-  B as LATEX_FORMAT_MARKERS,
-  W as MARKDOWN_FORMAT_MARKERS,
-  X as PRETEXT_DIVISION_TAGS,
-  G as PRETEXT_ROOT_TAGS,
-  U as analyzeImportSources,
-  H as assetsForImportMode,
-  q as attachLatexRoots,
-  J as attachMarkdownRoots,
-  Q as buildDivisionPool,
-  V as buildNativeDivisionPool,
-  O as buildPretextProjectFiles,
-  Y as carryOverProjectFiles,
-  Z as cleanLatex,
-  tt as convertLatexToPretext,
-  et as convertMarkdownToPretext,
-  nt as convertSourceToPretext,
-  at as defaultAttachLevel,
-  st as defaultManifestTarget,
-  j as detectDocumentKind,
-  ot as detectSourceFormat,
-  it as divisionChildRefs,
-  rt as expandPretextIncludes,
-  ct as extractUpload,
-  lt as filePrefixForDivision,
-  pt as filesForImportMode,
-  ut as findProjectManifest,
-  mt as formatWarningLine,
-  ft as getConversionErrorMessage,
-  dt as handleImportUploadFile,
-  Pt as importProjectFromFiles,
-  gt as isDivisionTag,
-  ht as normalizePretextSource,
-  bt as parseProjectManifest,
-  xt as projectForImportMode,
-  v as renderProjectPtx,
-  Tt as renderProjectPtxFromManifest,
-  R as renderPublicationPtx,
-  Ft as resolveSplitLevel,
-  St as sanitizeRef,
-  Et as serializeProjectToFiles,
-  N as serializeProjectToPlusPayload
+  q as CLEAN_RULES,
+  O as ConversionCancelledError,
+  V as LATEX_DIVISION_COMMANDS,
+  Y as LATEX_FORMAT_MARKERS,
+  J as MARKDOWN_FORMAT_MARKERS,
+  Q as MAX_SUGGESTED_SPLIT_LEVEL,
+  Z as PRETEXT_DIVISION_TAGS,
+  ee as PRETEXT_ROOT_TAGS,
+  A as analyzeImportSources,
+  te as applyLatexFixes,
+  Ke as assetsForImportMode,
+  se as attachLatexRoots,
+  ne as attachMarkdownRoots,
+  ae as buildDivisionPool,
+  oe as buildNativeDivisionPool,
+  z as buildPretextProjectFiles,
+  re as carryOverProjectFiles,
+  ie as cleanLatex,
+  ce as cleanLatexInChunks,
+  le as cleanLatexText,
+  ue as convertLatexToPretext,
+  pe as convertMarkdownToPretext,
+  fe as convertSourceToPretext,
+  U as createWorkerEngine,
+  me as defaultAttachLevel,
+  de as defaultManifestTarget,
+  w as detectDocumentKind,
+  ge as detectSourceFormat,
+  ze as diffHunks,
+  Ue as diffLines,
+  Ge as diffStats,
+  Pe as divisionChildRefs,
+  he as divisionsAtLevel,
+  xe as expandPretextIncludes,
+  b as extractUpload,
+  He as fileChangesForImport,
+  be as filePrefixForDivision,
+  qe as filesForImportMode,
+  Ee as findLatexFixes,
+  Te as findLatexHeaders,
+  ve as findProjectManifest,
+  Se as fixesToWarnings,
+  Ve as formatWarningLine,
+  Le as getConversionErrorMessage,
+  Fe as getLatexCleanDiagnostics,
+  we as handleImportUploadFile,
+  Ie as importProjectFromFiles,
+  _e as isDivisionTag,
+  Ce as latexDivisionHierarchy,
+  ke as latexFixesToCodeActions,
+  ye as mergeChunksAtLevel,
+  Ae as normalizePretextSource,
+  Me as parseLatexDivisions,
+  je as parseProjectManifest,
+  Ye as projectForImportMode,
+  Re as relayoutImport,
+  I as renderProjectPtx,
+  $e as renderProjectPtxFromManifest,
+  _ as renderPublicationPtx,
+  De as resolveImportSplitLevel,
+  Ne as resolveSplitLevel,
+  W as runConversionInWorker,
+  Oe as sanitizeRef,
+  Be as serializeProjectToFiles,
+  K as serializeProjectToPlusPayload,
+  We as suggestSplitLevel
 };

package/dist/lib/clean/clean-chunks.d.ts

@@ -0,0 +1,47 @@
+import { LatexFix } from '@pretextbook/latex-style-pretext';
+import { CleaningWarning } from './warnings';
+export interface CleanedChunk {
+    /**
+     * Heading path from the document root — `["Limits", "One-sided limits"]`.
+     * Empty for the preamble and for body text ahead of the first heading.
+     */
+    path: string[];
+    /** The chunk's own heading, or `""` when it has none. */
+    title: string;
+    /** `"preamble"`, a LaTeX sectioning command, or `null` for the lead-in text. */
+    kind: "preamble" | "lead" | "division";
+    /** Sectioning command that opened this chunk, when `kind` is `"division"`. */
+    command?: string;
+    /** Depth in the document's own hierarchy; 0 for preamble and lead-in. */
+    level: number;
+    before: string;
+    after: string;
+    fixes: LatexFix[];
+}
+export interface CleanLatexChunksResult {
+    /** The cleaned document, chunks rejoined in source order. */
+    output: string;
+    chunks: CleanedChunk[];
+    /** Aggregate over every chunk — the document-level summary. */
+    warnings: CleaningWarning[];
+    fixes: LatexFix[];
+}
+/**
+ * Clean `source`, cutting it at every division header so each piece carries its
+ * own before/after text and fix list.
+ *
+ * Chunks are cut at the *deepest* level the document has, not at a requested
+ * split depth. A shallower view is a matter of concatenating consecutive chunks
+ * (`mergeChunksAtLevel`), which lets the wizard change split depth without
+ * re-cleaning or re-converting anything.
+ */
+export declare function cleanLatexInChunks(source: string): CleanLatexChunksResult;
+/**
+ * Collapse chunks to the view a given split depth produces: one entry per file
+ * that depth would generate, with the chunks below it concatenated in.
+ *
+ * `level` 0 gives a single entry for the whole body; 1 one per top-level
+ * division; and so on. The preamble is always its own entry, since it never
+ * becomes a file of its own.
+ */
+export declare function mergeChunksAtLevel(chunks: CleanedChunk[], level: number): CleanedChunk[];

package/dist/lib/clean/clean-latex.d.ts

@@ -1,6 +1,40 @@
+import { CleanScope, LatexFix } from '@pretextbook/latex-style-pretext';
 import { CleaningWarning } from './warnings';
+export interface CleanLatexOptions {
+    /**
+     * What the text is. Defaults to `"auto"`, which detects `\begin{document}`.
+     * Per-division cleaning (SPEC §3.8) passes `"body"`.
+     */
+    scope?: CleanScope;
+    /** Rule ids to skip. */
+    disable?: string[];
+}
 export interface CleanLatexResult {
     output: string;
+    /** Aggregate, one row per rule — what the wizard's summary list renders. */
     warnings: CleaningWarning[];
+    /**
+     * Positioned fixes, in application order. The before/after diff and any
+     * per-file report read these; `warnings` is the rolled-up view of the same
+     * data.
+     */
+    fixes: LatexFix[];
 }
-export declare function cleanLatex(source: string): CleanLatexResult;
+/**
+ * Clean a piece of LaTeX: strip comments and trailing junk, then apply every
+ * cleaning rule to a fixpoint.
+ *
+ * `trimJunk` runs first and stays on this side of the boundary deliberately.
+ * Deleting every comment is right for an import (they are authoring notes about
+ * LaTeX, not content) but wrong for an editor, where the author is looking at
+ * their own comments and would not expect a cleanup to eat them.
+ */
+export declare function cleanLatex(source: string, options?: CleanLatexOptions): CleanLatexResult;
+/**
+ * Roll positioned fixes up into one `CleaningWarning` per rule.
+ *
+ * A rule with `reportMatch` emits two rows, matching what the cleaner has always
+ * produced: a `save` carrying the matched text (so the author can reconstruct
+ * what a `\def` meant) and a `delete` recording that it went away.
+ */
+export declare function fixesToWarnings(fixes: LatexFix[]): CleaningWarning[];

package/dist/lib/convert.d.ts

@@ -1,3 +1,4 @@
+import { CleanedChunk } from './clean/clean-chunks';
 import { CleaningWarning } from './clean/warnings';
 import { ConvertedPretextResult, SourceFormat } from './types';
 export declare function normalizePretextSource(pretextSource: string): string;
@@ -5,6 +6,12 @@ export interface LatexConversionResult {
     pretext: string;
     cleanedLatex: string;
     warnings: CleaningWarning[];
+    /**
+     * The cleaned source cut at its division headers, each piece carrying its own
+     * before/after text. The wizard's per-file diff reads these; see
+     * `clean-chunks.ts` for why cleaning is partitioned rather than global.
+     */
+    cleanChunks: CleanedChunk[];
 }
 export declare function convertLatexToPretext(latexSource: string): LatexConversionResult;
 export interface MarkdownConversionResult {

package/dist/lib/diff.d.ts

@@ -0,0 +1,36 @@
+export type DiffOp = "keep" | "add" | "remove";
+export interface DiffLine {
+    op: DiffOp;
+    text: string;
+    /** 1-based line number in the "before" text; absent for added lines. */
+    beforeLine?: number;
+    /** 1-based line number in the "after" text; absent for removed lines. */
+    afterLine?: number;
+}
+export interface DiffHunk {
+    /** Lines in this hunk, including the surrounding context. */
+    lines: DiffLine[];
+}
+export interface DiffStats {
+    added: number;
+    removed: number;
+}
+/**
+ * Longest common subsequence of two line arrays, as a diff.
+ *
+ * The classic O(n·m) dynamic program. A division is at most a few thousand
+ * lines, so the table is small enough not to matter; anything larger is guarded
+ * by `MAX_DIFF_LINES` below, which falls back to a whole-file replacement
+ * rather than allocating a table nobody will read.
+ */
+export declare function diffLines(before: string, after: string): DiffLine[];
+/** Above this combined line count, the LCS table is not worth building. */
+export declare const MAX_DIFF_LINES = 20000;
+export declare function diffStats(lines: DiffLine[]): DiffStats;
+/**
+ * Group a diff into hunks of changed lines with `context` unchanged lines
+ * around each, dropping the long runs of untouched text between them. A
+ * cleaning pass usually touches a handful of scattered lines, so showing the
+ * whole file would bury them.
+ */
+export declare function diffHunks(lines: DiffLine[], context?: number): DiffHunk[];

package/dist/lib/file-changes.d.ts

@@ -0,0 +1,22 @@
+import { DiffHunk, DiffStats } from './diff';
+import { ImportedProjectSuccess } from './types';
+export interface FileChangeRecord {
+    path: string;
+    /** Division title this file holds, or `""` for the main file. */
+    title: string;
+    before: string;
+    after: string;
+    stats: DiffStats;
+    hunks: DiffHunk[];
+    /** Number of cleaning fixes applied within this file's source. */
+    fixCount: number;
+}
+/**
+ * A before/after record for each generated source file at `splitLevel`.
+ *
+ * Files with no matching chunk are omitted rather than shown with an empty
+ * diff: a title that did not survive conversion means the join is unreliable
+ * for that file, and an empty diff would read as "nothing changed here" when
+ * the truth is "we do not know".
+ */
+export declare function fileChangesForImport(result: ImportedProjectSuccess, splitLevel?: number): FileChangeRecord[];