papilot 0.8.3 → 0.8.4

package/engine/dist/web/index.html

@@ -9,7 +9,7 @@
       rel="icon"
       href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Crect width='16' height='16' rx='3' fill='%232b6e5c'/%3E%3Cpath d='M4 8.5l2.5 2.5L12 5' stroke='white' stroke-width='2' fill='none'/%3E%3C/svg%3E"
     />
-    <script type="module" crossorigin src="/assets/index-DJywe0wU.js"></script>
+    <script type="module" crossorigin src="/assets/index-C_KwLmXQ.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-D3_ZFdT8.css">
   </head>
   <body>

package/engine/src/web/review.tsx

@@ -175,7 +175,7 @@ export function ReviewApp({
   const [shortcuts, setShortcuts] = useState(readShortcuts);
   // The whole paper with the changes in place, or the changed sections only.
   // A host may fix the view in the address (Papilot's manuscript chooses its
-  // PDF with its own switch); otherwise it follows the stored choice.
+  // PDF with its own switch); otherwise it opens on the stored default.
   const [pinnedView] = useState<ReviewView | null>(() => {
     const value = new URLSearchParams(location.search).get("view");
     return value === "paper" || value === "changes" ? value : null;
@@ -1144,13 +1144,9 @@ export function ReviewApp({
       if (article) reveal(article);
     });
   }, [paperView]);
+  // The switch changes this review only; the default is a Papilot setting.
   function chooseView(next: ReviewView) {
     setView(next);
-    try {
-      localStorage.setItem(VIEW_STORAGE, next);
-    } catch {
-      /* The choice lasts for this page. */
-    }
   }
   let index = 0;
   return (

package/engine/src/web/view-preferences.ts

@@ -1,13 +1,15 @@
-// Whole paper or changed sections only. A host such as Papilot shows its own
-// switch: it stores the choice and tells this frame; storage events also
-// update other tabs.
-export const VIEW_STORAGE = "latex-review:view";
+// Whole paper ("paper") or changed sections only ("changes"). Reviews open on
+// the stored default: the changed sections, which show fastest, unless the
+// whole paper was chosen in Papilot's settings. Switching views lasts for the
+// open review only. A host such as Papilot shows its own switch and tells this
+// frame; storage events bring a new default to reviews already open.
+export const VIEW_STORAGE = "latex-review:default-view";
 export const VIEW_EVENT = "latex-review:view-changed";
 export type ReviewView = "paper" | "changes";
 export function readView(): ReviewView {
   try {
-    return localStorage.getItem(VIEW_STORAGE) === "changes" ? "changes" : "paper";
+    return localStorage.getItem(VIEW_STORAGE) === "paper" ? "paper" : "changes";
   } catch {
-    return "paper";
+    return "changes";
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "papilot",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "A Cursor-like workspace for your papers: annotate and review PDFs directly without ever touching LaTeX.",
   "keywords": [
     "latex",

package/src/server/app.ts

@@ -25,7 +25,7 @@ import type { Updates } from './updates.ts';
 import { Diagnostics } from './diagnostics.ts';
 import { attachmentIds } from './attachments.ts';
 import { MAX_ATTACHMENT_BYTES } from '../shared.ts';
-import { PaperImports } from './imports.ts';
+import { PaperImports, openFolder } from './imports.ts';
 import { DATA } from './paths.ts';
 import { registerAiReviewRoutes } from './ai-review-routes.ts';
 import { detectLatex } from './latex-installation.ts';
@@ -174,6 +174,7 @@ export async function buildApp(options: AppOptions) {
   const string = (value: unknown, name: string, max = 20000) => { if (typeof value !== 'string' || !value.trim() || value.length > max) throw new Error(`${name} is required and must be no longer than ${max} characters.`); return value.trim(); };
   // Adding a paper names a folder on this host, so only the owner can.
   app.post('/api/projects', owner, async request => { const b = request.body as any; return workspace.addProject(string(b.path, 'Repository path', 4000), b.name ? string(b.name, 'Paper name', 120) : undefined); });
+  app.post('/api/projects/open', owner, request => openFolder((request.body || {}) as any, root => store.projectByPath(root), (root, name) => workspace.addProject(root, name)));
   app.post('/api/imports', { ...owner, bodyLimit: 90 * 1024 * 1024 }, request => imports!.create((request.body || {}) as any));
   app.get<{ Params: { id: string } }>('/api/imports/:id', owner, request => imports!.get(request.params.id));
   app.post<{ Params: { id: string } }>('/api/imports/:id/build', owner, request => imports!.build(request.params.id, (request.body || {}) as any));

package/src/server/imports.ts

@@ -88,18 +88,25 @@ export async function inspectPaper(root: string) {
     const found = new Set(roots);
     candidates = [...roots, ...files.filter(file => !found.has(file))];
   }
-  try {
-    // Engine detection also works before Git initialization by reading the source hints.
-    if (main) {
-      const text = sourceHead(path.join(root, main));
-      engine = typeof settings.engine === 'string' ? settings.engine : '';
-      const rc = [path.join(path.dirname(main), '.latexmkrc'), path.join(path.dirname(main), 'latexmkrc'), '.latexmkrc', 'latexmkrc'].find(file => fs.existsSync(path.join(root, file)));
-      const mode = rc ? fs.readFileSync(path.join(root, rc), 'utf8').match(/^\s*\$pdf_mode\s*=\s*(\d)/m)?.[1] : undefined;
-      if (!engine) engine = text.match(/^%\s*!\s*TEX\s+(?:TS-)?program\s*=\s*(pdflatex|xelatex|lualatex)/im)?.[1].toLowerCase() || ({ '1': 'pdflatex', '4': 'lualatex', '5': 'xelatex' } as Record<string, string>)[mode || ''] || (/\\(?:usepackage(?:\[[^\]]*\])?\{[^}]*\b(?:fontspec|xeCJK|unicode-math|polyglossia)\b|documentclass(?:\[[^\]]*\])?\{ctex)/.test(text) ? 'xelatex' : 'pdflatex');
-    }
-  } catch (failure) { error = (failure as Error).message; }
+  try { if (main) engine = engineFor(root, main, settings); } catch (failure) { error = (failure as Error).message; }
   return { candidates, main, engine: engine || 'pdflatex', error };
 }
+// Engine detection also works before Git initialization by reading the source hints.
+function engineFor(root: string, main: string, settings: Record<string, unknown>) {
+  if (typeof settings.engine === 'string' && settings.engine) return settings.engine;
+  const text = sourceHead(path.join(root, main));
+  const rc = [path.join(path.dirname(main), '.latexmkrc'), path.join(path.dirname(main), 'latexmkrc'), '.latexmkrc', 'latexmkrc'].find(file => fs.existsSync(path.join(root, file)));
+  const mode = rc ? fs.readFileSync(path.join(root, rc), 'utf8').match(/^\s*\$pdf_mode\s*=\s*(\d)/m)?.[1] : undefined;
+  return text.match(/^%\s*!\s*TEX\s+(?:TS-)?program\s*=\s*(pdflatex|xelatex|lualatex)/im)?.[1].toLowerCase() || ({ '1': 'pdflatex', '4': 'lualatex', '5': 'xelatex' } as Record<string, string>)[mode || ''] || (/\\(?:usepackage(?:\[[^\]]*\])?\{[^}]*\b(?:fontspec|xeCJK|unicode-math|polyglossia)\b|documentclass(?:\[[^\]]*\])?\{ctex)/.test(text) ? 'xelatex' : 'pdflatex');
+}
+// Keep the author's settings, including a source folder that still contains
+// the main file; without one, the whole folder compiles.
+function rememberMain(root: string, main: string, engine: string) {
+  const settings = config(root), folder = typeof settings.source_dir === 'string' ? settings.source_dir.replace(/\/+$/, '') : null;
+  const contains = folder === '' || (folder !== null && main.startsWith(folder + '/'));
+  const next = { ...settings, main, engine, ...(contains ? {} : { source_dir: '' }) };
+  if (JSON.stringify(next) !== JSON.stringify(settings)) fs.writeFileSync(path.join(root, CONFIG), JSON.stringify(next, null, 2) + '\n');
+}
 async function repositoryRoot(root: string) {
   let top: string | undefined;
   try { top = await git(root, 'rev-parse', '--show-toplevel'); } catch { /* A plain folder needs Git. */ }
@@ -115,6 +122,28 @@ export async function prepareRepository(root: string) {
   await git(root, 'add', '--all');
   await git(root, '-c', 'user.name=Papilot', '-c', 'user.email=papilot@localhost', '-c', 'commit.gpgsign=false', '-c', 'core.hooksPath=/dev/null', 'commit', '-qm', 'Import paper into Papilot');
 }
+// The desktop app opens a folder the way an editor does. A paper already in
+// Papilot opens again; any other folder with a clear main file is added as it
+// is and compiles in its own view. Only a folder with several possible main
+// files returns them, so the author can pick one.
+export async function openFolder(input: { path?: unknown; main?: unknown }, known: (root: string) => Project | undefined, register: (root: string, name: string) => Promise<Project>): Promise<{ project: Project } | { name: string; candidates: string[] }> {
+  if (typeof input.path !== 'string' || !input.path.trim()) throw new Error('Enter a folder path.');
+  const root = fs.realpathSync(input.path);
+  if (!fs.statSync(root).isDirectory()) throw new Error('Select a folder containing the paper.');
+  const project = known(root);
+  if (project) return { project };
+  await repositoryRoot(root);
+  const detected = await inspectPaper(root);
+  if (detected.error) throw new Error(detected.error);
+  if (input.main === undefined && !detected.main) {
+    if (!detected.candidates.length) throw new Error('Select a folder containing the paper.');
+    return { name: path.basename(root), candidates: detected.candidates };
+  }
+  const main = input.main ?? detected.main;
+  if (!existingTex(root, main)) throw new Error('Choose an existing TeX main file.');
+  rememberMain(root, main, engineFor(root, main, config(root)));
+  return { project: await register(root, path.basename(root)) };
+}
 export async function extractZip(buffer: Buffer, root: string) {
   if (buffer.length > MAX_BYTES) throw new Error('Choose a ZIP smaller than 64 MB.');
   const zip = await new Promise<yauzl.ZipFile>((resolve, reject) => yauzl.fromBuffer(buffer, { lazyEntries: true, strictFileNames: true, validateEntrySizes: true }, (error, value) => error ? reject(error) : resolve(value)));
@@ -214,14 +243,7 @@ export class PaperImports {
     void (async () => {
       try {
         await repositoryRoot(value.path);
-        if (!repair) {
-          // Keep the author's settings, including a source folder that still
-          // contains the main file; without one, the whole folder compiles.
-          const settings = config(value.path), folder = typeof settings.source_dir === 'string' ? settings.source_dir.replace(/\/+$/, '') : null;
-          const contains = folder === '' || (folder !== null && (main as string).startsWith(folder + '/'));
-          const next = { ...settings, main, engine, ...(contains ? {} : { source_dir: '' }) };
-          if (JSON.stringify(next) !== JSON.stringify(settings)) fs.writeFileSync(path.join(value.path, CONFIG), JSON.stringify(next, null, 2) + '\n');
-        }
+        if (!repair) rememberMain(value.path, main as string, engine as string);
         await prepareRepository(value.path); value.versioned = true;
         if (repair) { value.summary = await repair(value.path, previousError); Object.assign(value, await inspectPaper(value.path)); }
         value.phase = 'building'; this.save(value);