@pretextbook/import 0.6.0 → 0.8.0

package/dist/index.js

@@ -1,5 +1,6 @@
-import { d as _, r as v, a as A, f as g, b as h, w as P, s as x, e as I, c as C, p as j } from "./import-mode-C0KIll3S.js";
-import { C as B, L as X, g as U, M as W, h as G, P as H, i as V, j as Y, k as q, l as J, m as Q, n as Z, o as ee, q as te, t as ae, u as se, v as ne, x as ie, y as oe, z as re, A as ce, B as le, D as pe, E as ue, F as fe, G as me, H as de, I as Pe, J as ge, K as he, N as xe, O as be, Q as Se, R as Te, S as Ee, T as Fe, U as Le, V as _e, W as ve, X as Ae, Y as Ie, Z as Ce, _ as je, $ as Me, a0 as Re, a1 as ke, a2 as $e, a3 as De, a4 as ye, a5 as we, a6 as Ne, a7 as Oe, a8 as Ke, a9 as ze, aa as Be, ab as Xe, ac as Ue, ad as We } from "./import-mode-C0KIll3S.js";
+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-BmErkg8I.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-BmErkg8I.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-BCGuSwkM.js";
 const M = {
   png: "image/png",
   jpg: "image/jpeg",
@@ -14,18 +15,18 @@ const M = {
   webp: "image/webp",
   ico: "image/vnd.microsoft.icon"
 };
-function R(e) {
-  const t = e.split(".").pop()?.toLowerCase() ?? "";
-  return M[t] ?? "application/octet-stream";
+function j(e) {
+  const s = e.split(".").pop()?.toLowerCase() ?? "";
+  return M[s] ?? "application/octet-stream";
 }
-const m = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-function k(e) {
-  const t = e.length, n = [];
-  for (let a = 0; a < t; a += 3) {
-    const s = e[a], o = a + 1 < t, c = a + 2 < t, r = o ? e[a + 1] : 0, l = c ? e[a + 2] : 0;
-    n.push(m[s >> 2]), n.push(m[(s & 3) << 4 | r >> 4]), n.push(o ? m[(r & 15) << 2 | l >> 6] : "="), n.push(c ? m[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 n.join("");
+  return o.join("");
 }
 function $(e) {
   return {
@@ -35,82 +36,82 @@ function $(e) {
     short_description: e.fileName,
     file: {
       filename: e.fileName,
-      content_type: R(e.fileName),
-      data: k(e.data)
+      content_type: j(e.fileName),
+      data: R(e.data)
     }
   };
 }
-function N(e) {
+function K(e) {
   return {
     title: e.title,
     docinfo: e.docinfo,
     document_type: e.documentKind,
-    divisions_attributes: e.divisions.map((t) => ({
-      ref: t.xmlId,
-      source: t.content,
-      source_format: t.sourceFormat,
-      is_root: t.isRoot
+    divisions_attributes: e.divisions.map((s) => ({
+      ref: s.xmlId,
+      source: s.content,
+      source_format: s.sourceFormat,
+      is_root: s.isRoot
     })),
     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 b(e) {
-  return g(e, "pretext") ? e : `<pretext>
+function S(e) {
+  return E(e, "pretext") ? e : `<pretext>
 ${e}
 </pretext>`;
 }
-function S(e, t, n) {
-  const a = /* @__PURE__ */ new Map(), s = [], o = `${t}-`;
-  return e.forEach((c, r) => {
-    const l = c.attributes["xml:id"];
-    let p;
-    if (l) {
-      const u = C(l);
-      p = u.startsWith(o) ? u : `${o}${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 = `${o}${j(r + 1, e.length)}`, n.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 f = a.get(p) ?? 0;
-    a.set(p, f + 1);
-    const i = f === 0 ? p : `${p}-${f + 1}`;
-    s.push({
-      span: c,
-      slug: i,
-      filename: `${i}.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`
     });
-  }), s;
+  }), n;
 }
-function D(e, t, n, a) {
-  const s = h(e, "section");
-  if (s.length === 0)
+function D(e, s, o, t) {
+  const n = T(e, "section");
+  if (n.length === 0)
     return e;
-  const c = S(s, "sec", a).map((r) => {
-    const l = `source/${t}/${r.filename}`;
-    return n[l] = P(r.span.outer), {
-      start: r.span.start,
-      end: r.span.end,
-      replacement: `<xi:include href="${t}/${r.filename}"/>`
+  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 x(e, c);
+  return v(e, r);
 }
-function y(e, t, n) {
-  const a = g(e, "book");
-  if (!a)
-    return n.push({
+function N(e, s, o) {
+  const t = E(e, "book");
+  if (!t)
+    return o.push({
       action: "anomaly",
       severity: "warning",
       kind: "structure",
@@ -118,117 +119,200 @@ function y(e, t, n) {
       macro: "book",
       occurrences: 1,
       message: "Document was treated as a book but no <book> element found; emitting as a single file."
-    }), T(e, t);
-  const s = {}, o = h(a.inner, "chapter");
-  let c = a.inner;
-  if (t.splitChapters && o.length > 0) {
-    const f = S(o, "ch", n).map((i) => {
-      let u = i.span.outer;
-      if (t.splitSections) {
-        const F = i.span.inner, L = D(
-          F,
-          i.slug,
-          s,
-          n
+    }), 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 = i.span.outer.slice(0, i.span.startTagEnd - i.span.start) + L + i.span.outer.slice(i.span.contentEnd - i.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 E = `source/${i.filename}`;
-      return s[E] = P(u), {
-        start: i.span.start,
-        end: i.span.end,
-        replacement: `<xi:include href="${i.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 = x(a.inner, f);
+    r = v(t.inner, p);
   }
-  const r = e.slice(a.start, a.startTagEnd) + c + e.slice(a.contentEnd, a.end), l = e.slice(0, a.start) + r + e.slice(a.end);
-  return s[t.mainSourcePath] = P(
-    I(b(l.trim()))
-  ), s;
+  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 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 };
 }
-function T(e, t, n) {
-  const a = {};
-  return a[t.mainSourcePath] = P(
-    b(e.trim())
-  ), a;
+class O extends Error {
+  constructor() {
+    super("Import cancelled."), this.name = "ConversionCancelledError";
+  }
 }
-function O(e, t = {}) {
-  const n = [], a = t.documentKind ?? _(e), s = {
-    splitChapters: t.splitChapters ?? a === "book",
-    splitSections: t.splitSections ?? !1,
-    mainSourcePath: t.mainSourcePath ?? d.mainSourcePath,
-    publicationPath: t.publicationPath ?? d.publicationPath,
-    projectFilePath: t.projectFilePath ?? d.projectFilePath,
-    docinfoPath: t.docinfoPath ?? d.docinfoPath
-  }, o = a === "book" ? y(e, s, n) : T(e, s);
-  return o[s.projectFilePath] = v({
-    mainSource: s.mainSourcePath,
-    publication: s.publicationPath
-  }), o[s.publicationPath] = A(), { files: o, documentKind: a, warnings: n };
+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 CLEAN_RULES,
-  X as LATEX_DIVISION_COMMANDS,
-  U as LATEX_FORMAT_MARKERS,
-  W as MARKDOWN_FORMAT_MARKERS,
-  G as MAX_SUGGESTED_SPLIT_LEVEL,
-  H as PRETEXT_DIVISION_TAGS,
-  V as PRETEXT_ROOT_TAGS,
-  Y as analyzeImportSources,
-  q as applyLatexFixes,
-  J as assetsForImportMode,
-  Q as attachLatexRoots,
-  Z as attachMarkdownRoots,
-  ee as buildDivisionPool,
-  te as buildNativeDivisionPool,
-  O as buildPretextProjectFiles,
-  ae as carryOverProjectFiles,
-  se as cleanLatex,
-  ne as cleanLatexInChunks,
-  ie as cleanLatexText,
-  oe as convertLatexToPretext,
-  re as convertMarkdownToPretext,
-  ce as convertSourceToPretext,
-  le as defaultAttachLevel,
-  pe as defaultManifestTarget,
-  _ as detectDocumentKind,
-  ue as detectSourceFormat,
-  fe as diffHunks,
-  me as diffLines,
-  de as diffStats,
+  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,
-  ge as divisionsAtLevel,
-  he as expandPretextIncludes,
-  xe as extractUpload,
-  be as fileChangesForImport,
-  Se as filePrefixForDivision,
-  Te as filesForImportMode,
+  he as divisionsAtLevel,
+  xe as expandPretextIncludes,
+  b as extractUpload,
+  He as fileChangesForImport,
+  be as filePrefixForDivision,
+  qe as filesForImportMode,
   Ee as findLatexFixes,
-  Fe as findLatexHeaders,
-  Le as findProjectManifest,
-  _e as fixesToWarnings,
-  ve as formatWarningLine,
-  Ae as getConversionErrorMessage,
-  Ie as getLatexCleanDiagnostics,
-  Ce as handleImportUploadFile,
-  je as importProjectFromFiles,
-  Me as isDivisionTag,
-  Re as latexDivisionHierarchy,
+  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,
-  $e as mergeChunksAtLevel,
-  De as normalizePretextSource,
-  ye as parseLatexDivisions,
-  we as parseProjectManifest,
-  Ne as projectForImportMode,
-  Oe as relayoutImport,
-  v as renderProjectPtx,
-  Ke as renderProjectPtxFromManifest,
-  A as renderPublicationPtx,
-  ze as resolveImportSplitLevel,
-  Be as resolveSplitLevel,
-  Xe as sanitizeRef,
-  Ue as serializeProjectToFiles,
-  N as serializeProjectToPlusPayload,
+  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/latex-preamble.d.ts

@@ -1,3 +1,4 @@
+import { CleaningWarning } from './warnings';
 export interface PreambleInfo {
     /** Argument of \documentclass{...}, e.g. "book" or "article". Defaults to "article". */
     documentClass: string;
@@ -5,7 +6,7 @@ export interface PreambleInfo {
     title: string;
     /** Inner content of \author{...}, or empty string. */
     author: string;
-    /** Collected \newcommand / \renewcommand / \DeclareMathOperator definitions. */
+    /** Collected \newcommand / \renewcommand / \DeclareMathOperator / \def definitions. */
     macros: string;
 }
 export declare function splitLatexAtDocument(source: string): {
@@ -18,10 +19,26 @@ export declare function splitLatexAtDocument(source: string): {
  * Returns the inner content (without surrounding braces), or "".
  */
 export declare function extractLatexField(source: string, cmdName: string): string;
+export interface ExtractMacrosResult {
+    /** Collected macro definitions, joined with newlines. */
+    macros: string;
+    /** One warning summarizing any `\def` blocks found (empty if none). */
+    warnings: CleaningWarning[];
+}
 /**
  * Collects LaTeX macro definition lines from `preamble`, including multi-line
  * definitions (tracks brace depth to know when a definition is complete).
- * Returns the collected definitions joined with newlines.
+ *
+ * `\def` is kept verbatim alongside `\newcommand` et al. — rewriting its
+ * syntax isn't safe in general (delimited parameter text, `\global`/`\edef`
+ * semantics, and no way to tell here whether it's redefining an existing
+ * command, which would make a mechanical `\newcommand` rewrite fail to
+ * build) — but it's reported as a warning, since PreTeXt tooling downstream
+ * (e.g. WeBWorK/PG macro extraction) only recognises `\newcommand`.
  */
-export declare function extractMacros(preamble: string): string;
-export declare function extractPreambleInfo(preamble: string): PreambleInfo;
+export declare function extractMacros(preamble: string): ExtractMacrosResult;
+export interface ExtractPreambleInfoResult {
+    info: PreambleInfo;
+    warnings: CleaningWarning[];
+}
+export declare function extractPreambleInfo(preamble: string): ExtractPreambleInfoResult;

package/dist/react/import-wizard.d.ts

@@ -39,12 +39,30 @@ export interface ImportEngine {
     convertFile: (file: File, options: ImportProjectOptions) => Promise<ImportedProjectResult>;
     /** Unpack and survey an upload without converting it. */
     prepare?: (file: File) => Promise<PreparedUpload>;
-    /** Convert an already-prepared upload with the user's source choices. */
-    convertPrepared?: (prepared: PreparedUpload, options: ImportProjectOptions) => ImportedProjectResult;
+    /**
+     * Convert an already-prepared upload with the user's source choices.
+     *
+     * May return synchronously (the built-in engine does) or a promise (the
+     * worker engine does). The wizard always awaits, which is what lets the
+     * processing screen paint and its timer tick before the work starts.
+     */
+    convertPrepared?: (prepared: PreparedUpload, options: ImportProjectOptions) => ImportedProjectResult | Promise<ImportedProjectResult>;
+    /**
+     * Stop an in-flight conversion. Engines that run the pipeline in-process
+     * cannot honour this — the pipeline has no yield points — so only the worker
+     * engine supplies it, and the processing screen shows Cancel only when it is
+     * present.
+     */
+    cancel?: () => void;
 }
 export interface ImportWizardProps {
-    /** Called when the user confirms the import. */
-    onConfirm: (result: ImportedProjectSuccess, mode: ImportMode) => void;
+    /**
+     * Called when the user confirms the import. May return a promise — writing
+     * the file map out is the host's slow step (VS Code writes to disk,
+     * pretext-plus uploads), so the wizard awaits it and holds the button in a
+     * pending state until it settles rather than appearing to do nothing.
+     */
+    onConfirm: (result: ImportedProjectSuccess, mode: ImportMode) => void | Promise<void>;
     /** Called when the user cancels at the review step. */
     onCancel?: () => void;
     /** Pass fixed options to skip the document-kind / split-sections controls. */

package/dist/react/index.d.ts

@@ -1,5 +1,7 @@
 export { ImportWizard } from './import-wizard';
 export type { ImportWizardProps, ImportMode, ImportEngine, PreparedUpload, } from './import-wizard';
+export { ProcessingPanel } from './processing-panel';
+export type { ProcessingPanelProps } from './processing-panel';
 export { ImportSourceForm } from './import-source-form';
 export { ImportUploadPanel } from './import-upload-panel';
 export type { ImportSourceFormProps, ImportSourceFormLabels, } from './import-source-form';

package/dist/react/processing-panel.d.ts

@@ -0,0 +1,6 @@
+export interface ProcessingPanelProps {
+    message?: string;
+    /** Omitted when the work cannot be interrupted (e.g. a host write). */
+    onCancel?: () => void;
+}
+export declare function ProcessingPanel({ message, onCancel, }: ProcessingPanelProps): import("react").JSX.Element;