collabmd 0.1.47 → 0.1.48

package/src/client/assets/vendor/jetbrains-mono/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/src/client/bootstrap/collabmd-app-shell.js

@@ -168,6 +168,7 @@ export class CollabMdAppShell {
     this.chatToastController = new ToastController(this.elements.chatToastContainer);
     this.fileExplorer = new FileExplorerController({
       mobileBreakpointQuery: this.mobileBreakpointQuery,
+      onDirectoryExport: (directoryPath, format) => this.handleDirectoryExportRequest(directoryPath, format),
       onFileDelete: () => this.navigation.navigateToFile(null),
       onFileSelect: (filePath) => this.workspaceRouteController.handleFileSelection(filePath, {
         closeSidebarOnMobile: true,
@@ -208,7 +209,11 @@ export class CollabMdAppShell {
     });
     this.outlineController = new OutlineController({
       mobileBreakpointQuery: this.mobileBreakpointQuery,
-      onNavigateToHeading: ({ sourceLine }) => {
+      onNavigateToHeading: ({ headingId, sourceLine }) => {
+        const heading = document.getElementById(headingId);
+        if (this.elements.previewContent?.contains(heading)) {
+          this.unfoldPreviewHeading(heading);
+        }
         if (!Number.isFinite(sourceLine)) return;
         this.scrollSyncController.suspendSync(250);
         this.session?.scrollToLine(sourceLine, 0);
@@ -254,6 +259,7 @@ export class CollabMdAppShell {
         this.excalidrawEmbed.reconcileEmbeds(this.elements.previewContent, { isLargeDocument: stats.isLargeDocument });
         this.scrollSyncController.setLargeDocumentMode(stats.isLargeDocument);
         this.syncPreviewCodeCopyButtons();
+        this.syncPreviewHeadingFoldButtons();
         this.syncPreviewHeadingLinkButtons();
         this.applyPendingPreviewRouteAnchor({ behavior: 'auto', clearMissing: true });
         this.schedulePreviewLayoutSync({ delayMs: 0 });
@@ -500,8 +506,15 @@ export class CollabMdAppShell {
         this.clearInitialFileBootstrap();
       },
       onConnectionChange: (state) => this.handleConnectionChange(state),
-      onContentChange: ({ isBase, isMermaid, isPlantUml, isStructurizrWorkspace }) => {
+      onContentChange: ({ isBase, isHtml, isMermaid, isPlantUml, isStructurizrWorkspace }) => {
         this.handleCommentEditorContentChange();
+        if (isHtml) {
+          this.workspacePreviewController.renderHtmlFilePreview({
+            content: this.session?.getText?.() ?? '',
+          });
+          return;
+        }
+
         if (isBase) {
           this.scheduleBaseFilePreview(this.currentFilePath, {
             source: this.session?.getText?.() ?? '',
@@ -524,10 +537,11 @@ export class CollabMdAppShell {
       },
       onCommentsChange: (threads) => this.handleCommentThreadsChange(threads),
       onFileAwarenessChange: (users) => this.updateFileAwareness(users),
-      onFileOpenError: () => {
-        this.showEditorLoadError();
+      onFileOpenError: ({ code } = {}) => {
+        const notFound = code === 'not-found';
+        this.showEditorLoadError(notFound ? 'File not found' : 'Failed to load file');
         this.syncWrapToggle();
-        this.toastController.show('Failed to initialize editor');
+        this.toastController.show(notFound ? 'File not found' : 'Failed to initialize editor');
       },
       onFileOpenReady: () => {
         this.hideEditorLoading();
@@ -545,6 +559,7 @@ export class CollabMdAppShell {
       onRenderDrawioPreview: (filePath) => this.workspacePreviewController.renderDrawioFilePreview(filePath),
       onRenderBasePreview: (filePath) => this.renderBaseFilePreview(filePath),
       onRenderExcalidrawPreview: (filePath) => this.workspacePreviewController.renderExcalidrawFilePreview(filePath),
+      onRenderHtmlPreview: (options) => this.workspacePreviewController.renderHtmlFilePreview(options),
       onRenderImagePreview: (filePath) => this.workspacePreviewController.renderImageFilePreview(filePath),
       onRenderPdfPreview: (filePath) => this.workspacePreviewController.renderPdfFilePreview(filePath),
       onRenderStructurizrPreview: (filePath, options) => this.workspacePreviewController.renderStructurizrFilePreview(filePath, options),
@@ -561,6 +576,7 @@ export class CollabMdAppShell {
         });
         this.syncCommentChrome(filePath);
         this.syncFileHistoryButton({ filePath, mode: 'editor' });
+        this.syncReviewFileChangesButton({ filePath, mode: 'editor' });
         if (this.elements.activeFileName) {
           this.elements.activeFileName.textContent = displayName;
         }

package/src/client/domain/document-formatter.js

@@ -0,0 +1,193 @@
+import { getVaultFileKind } from '../../domain/file-kind.js';
+
+const FORMATTABLE_FILE_KINDS = new Set(['base', 'html', 'markdown', 'mermaid', 'plantuml']);
+const PLANTUML_BLOCK_OPENERS = [
+  [/^if\b.*\bthen\b/iu, 'endif'],
+  [/^while\b/iu, 'endwhile'],
+  [/^repeat\b(?!\s+while\b)/iu, 'repeat while'],
+  [/^switch\b/iu, 'endswitch'],
+  [/^fork\b(?!\s+again\b)/iu, 'end fork'],
+  [/^split\b(?!\s+again\b)/iu, 'end split'],
+  [/^(?:alt|opt|loop|par|critical|group|box|ref\s+over)\b/iu, 'end'],
+  [/^break\s+\S/iu, 'end'],
+];
+const PLANTUML_MIDDLE_PATTERN = /^(?:else(?:if)?|and|fork\s+again|split\s+again|case|option)\b/iu;
+
+function getPlantUmlOpaqueBlock(trimmedLine) {
+  if (trimmedLine.startsWith("/'")) {
+    return trimmedLine.slice(2).includes("'/")
+      ? { oneLine: true }
+      : { end: (line) => line.includes("'/") };
+  }
+  const tripleQuoteCount = trimmedLine.split('"""').length - 1;
+  if (tripleQuoteCount % 2 === 1) return { end: (line) => line.includes('"""') };
+  if (/^<style>.*<\/style>\s*$/iu.test(trimmedLine)) return { oneLine: true };
+  if (/^<style>\s*$/iu.test(trimmedLine)) return { end: (line) => /<\/style>/iu.test(line) };
+  if (/^!(?:if|ifdef|ifndef)\b/iu.test(trimmedLine)) {
+    let depth = 1;
+    return { end: (line) => {
+      if (/^!(?:if|ifdef|ifndef)\b/iu.test(line)) depth += 1;
+      if (/^!endif\b/iu.test(line)) depth -= 1;
+      return depth === 0;
+    } };
+  }
+  if (/^!(?:while|foreach)\b/iu.test(trimmedLine)) {
+    const endPattern = /^!while\b/iu.test(trimmedLine) ? /^!endwhile\b/iu : /^!endfor\b/iu;
+    return { end: (line) => endPattern.test(line) };
+  }
+  if (/^!(?:definelong|procedure|function)\b/iu.test(trimmedLine)) {
+    return { end: (line) => /^!end(?:definelong|procedure|function)\b/iu.test(line) };
+  }
+  if (/^!\w+/u.test(trimmedLine)) return { oneLine: true };
+  if (/^(?:[hr]?note|legend)\b(?!.*:\s*\S)/iu.test(trimmedLine)) {
+    return { end: (line) => /^(?:end\s+note|endlegend)\b/iu.test(line) };
+  }
+  if (/^(?:title|header|footer|caption)\s*$/iu.test(trimmedLine)) {
+    const blockName = trimmedLine.toLowerCase();
+    return { end: (line) => line.toLowerCase().replace(/\s/gu, '') === `end${blockName}` };
+  }
+  if (/^(?:json|yaml|salt|sprite)\b.*\{\s*$/iu.test(trimmedLine)) {
+    return { braceDepth: 1 };
+  }
+  return null;
+}
+
+function countPlantUmlBraces(line) {
+  let count = 0;
+  let escaped = false;
+  let quoted = false;
+  for (const character of line) {
+    if (escaped) {
+      escaped = false;
+    } else if (character === '\\') {
+      escaped = true;
+    } else if (character === '"') {
+      quoted = !quoted;
+    } else if (!quoted && character === '{') {
+      count += 1;
+    } else if (!quoted && character === '}') {
+      count -= 1;
+    }
+  }
+  return count;
+}
+
+function getPlantUmlCloser(trimmedLine) {
+  if (/^\}\s*$/u.test(trimmedLine)) return '}';
+  if (/^endif\b/iu.test(trimmedLine)) return 'endif';
+  if (/^endwhile\b/iu.test(trimmedLine)) return 'endwhile';
+  if (/^repeat\s+while\b/iu.test(trimmedLine)) return 'repeat while';
+  if (/^endswitch\b/iu.test(trimmedLine)) return 'endswitch';
+  if (/^end\s+fork\b/iu.test(trimmedLine)) return 'end fork';
+  if (/^end\s+split\b/iu.test(trimmedLine)) return 'end split';
+  if (/^end(?:\s+\w+)?\s*$/iu.test(trimmedLine)) return 'end';
+  return null;
+}
+
+function getPlantUmlOpener(trimmedLine) {
+  if (/\{\s*$/u.test(trimmedLine)) return '}';
+  return PLANTUML_BLOCK_OPENERS.find(([pattern]) => pattern.test(trimmedLine))?.[1] ?? null;
+}
+
+function indentPlantUml(source) {
+  const parts = String(source ?? '').split(/(\r\n|\n|\r)/u);
+  const stack = [];
+  let opaqueBlock = null;
+
+  for (let index = 0; index < parts.length; index += 2) {
+    const line = parts[index];
+    const content = line.replace(/^[\t ]*/u, '');
+    const trimmedLine = content.trimEnd();
+
+    if (opaqueBlock) {
+      if (opaqueBlock.braceDepth) {
+        opaqueBlock.braceDepth += countPlantUmlBraces(trimmedLine);
+        if (opaqueBlock.braceDepth <= 0) opaqueBlock = null;
+      } else if (opaqueBlock.end(trimmedLine)) {
+        opaqueBlock = null;
+      }
+      continue;
+    }
+
+    const nextOpaqueBlock = getPlantUmlOpaqueBlock(trimmedLine);
+    if (nextOpaqueBlock) {
+      opaqueBlock = nextOpaqueBlock.oneLine ? null : nextOpaqueBlock;
+      continue;
+    }
+    if (!trimmedLine) continue;
+
+    const closer = getPlantUmlCloser(trimmedLine);
+    const closesCurrentBlock = closer && stack.at(-1) === closer;
+    const isMiddle = PLANTUML_MIDDLE_PATTERN.test(trimmedLine) && stack.length > 0;
+    const opener = getPlantUmlOpener(trimmedLine);
+
+    if (stack.length > 0 || closesCurrentBlock || isMiddle || opener) {
+      const depth = Math.max(0, stack.length - (closesCurrentBlock || isMiddle ? 1 : 0));
+      parts[index] = `${'  '.repeat(depth)}${content}`;
+    }
+    if (closesCurrentBlock) stack.pop();
+    if (opener) stack.push(opener);
+  }
+
+  return parts.join('');
+}
+
+export function canFormatDocument(filePath) {
+  return FORMATTABLE_FILE_KINDS.has(getVaultFileKind(filePath));
+}
+
+async function formatWithPrettier(source, parser) {
+  let pluginImport = import('prettier/plugins/markdown');
+  if (parser === 'yaml') pluginImport = import('prettier/plugins/yaml');
+  if (parser === 'html') pluginImport = import('prettier/plugins/html');
+
+  const [{ format }, plugin] = await Promise.all([
+    import('prettier/standalone'),
+    pluginImport,
+  ]);
+  const plugins = [plugin.default];
+
+  if (parser === 'mdx') {
+    const [babel, estree] = await Promise.all([
+      import('prettier/plugins/babel'),
+      import('prettier/plugins/estree'),
+    ]);
+    plugins.push(babel.default, estree.default);
+  }
+
+  return format(source, {
+    parser,
+    plugins,
+    proseWrap: 'preserve',
+  });
+}
+
+async function formatMermaid(source) {
+  const [{ default: mermaid }, { formatMermaid }] = await Promise.all([
+    import('mermaid'),
+    import('mermaid-formatter'),
+  ]);
+  if (!await mermaid.parse(source, { suppressErrors: true })) {
+    throw new Error('Mermaid syntax is invalid');
+  }
+
+  const formatted = formatMermaid(source, { indentSize: 2 });
+  if (!await mermaid.parse(formatted, { suppressErrors: true })) {
+    throw new Error('The formatter produced invalid Mermaid syntax');
+  }
+  return formatted;
+}
+
+export async function formatDocumentText(filePath, source) {
+  const kind = getVaultFileKind(filePath);
+
+  if (kind === 'mermaid') return formatMermaid(source);
+  if (kind === 'plantuml') return indentPlantUml(source);
+  if (kind === 'base') return formatWithPrettier(source, 'yaml');
+  if (kind === 'html') return formatWithPrettier(source, 'html');
+  if (kind === 'markdown') {
+    const parser = String(filePath).toLowerCase().endsWith('.mdx') ? 'mdx' : 'markdown';
+    return formatWithPrettier(source, parser);
+  }
+  return null;
+}

package/src/client/domain/file-search.js

@@ -0,0 +1,73 @@
+import { stripVaultFileExtension } from '../../domain/file-kind.js';
+
+function createRangeIndices(start, length) {
+  return Array.from({ length }, (_, index) => start + index);
+}
+
+function findFuzzyMatch(text, query) {
+  const indices = [];
+  let queryIndex = 0;
+  let score = 0;
+  let consecutiveBonus = 0;
+
+  for (let index = 0; index < text.length && queryIndex < query.length; index += 1) {
+    if (/\s/u.test(query[queryIndex]) && /[\s/\\_-]/u.test(text[index])) {
+      queryIndex += 1;
+      consecutiveBonus = 0;
+      continue;
+    }
+
+    if (text[index] !== query[queryIndex]) {
+      if (queryIndex > 0) score -= 0.25;
+      consecutiveBonus = 0;
+      continue;
+    }
+
+    queryIndex += 1;
+    indices.push(index);
+    consecutiveBonus += 1;
+    score += consecutiveBonus;
+
+    if (index === 0 || /[/\-_ ]/u.test(text[index - 1])) score += 5;
+  }
+
+  return queryIndex === query.length && score > 0 ? { indices, score } : null;
+}
+
+export function createFileSearchEntry(filePath) {
+  const displayName = stripVaultFileExtension(filePath);
+  const fileName = displayName.split('/').pop() || displayName;
+  const rawFileName = String(filePath ?? '').split('/').pop() || String(filePath ?? '');
+
+  return {
+    displayName,
+    fileName,
+    filePath,
+    lowerDisplayName: displayName.toLowerCase(),
+    lowerFileName: fileName.toLowerCase(),
+    lowerPath: String(filePath).toLowerCase(),
+    lowerRawFileName: rawFileName.toLowerCase(),
+  };
+}
+
+export function findFileSearchMatch(entry, query) {
+  const fileNameStart = entry.displayName.length - entry.fileName.length;
+  const searches = [
+    [entry.lowerFileName, fileNameStart, 100],
+    [entry.lowerDisplayName, 0, 50],
+    [entry.lowerRawFileName, fileNameStart, 40],
+    [entry.lowerPath, 0, 25],
+  ];
+
+  for (const [text, offset, baseScore] of searches) {
+    const index = text.indexOf(query);
+    if (index >= 0) {
+      return {
+        indices: createRangeIndices(index + offset, query.length),
+        score: baseScore + (1 / text.length),
+      };
+    }
+  }
+
+  return findFuzzyMatch(entry.lowerDisplayName, query);
+}

package/src/client/domain/git-labels.js

@@ -0,0 +1,5 @@
+export function commitButtonLabel(count) {
+  return count > 0
+    ? `Commit ${count} file${count === 1 ? '' : 's'}`
+    : 'Commit included files';
+}

package/src/client/domain/vault-paths.js

@@ -8,10 +8,12 @@ import {
 } from '../../domain/file-kind.js';
 
 export function normalizeVaultPathInput(value) {
-  const segments = String(value ?? '')
-    .trim()
-    .replace(/\\/g, '/')
-    .replace(/^\/+/u, '')
+  const normalized = String(value ?? '').trim().replace(/\\/g, '/');
+  if (!normalized || normalized.startsWith('/')) {
+    return '';
+  }
+
+  const segments = normalized
     .split('/')
     .map((segment) => segment.trim())
     .filter(Boolean);

package/src/client/domain/wiki-link-completions.js

@@ -1,3 +1,7 @@
+import { createFileSearchEntry, findFileSearchMatch } from './file-search.js';
+
+const MAX_VISIBLE_RESULTS = 30;
+
 /**
  * CodeMirror autocomplete source for [[wiki-links]].
  *
@@ -29,31 +33,28 @@ export function wikiLinkCompletions(getFileList) {
       return null;
     }
 
-    const query = afterOpen.toLowerCase();
+    const query = afterOpen.trim().toLowerCase().replace(/\s+/gu, ' ');
     const from = line.from + openIndex + 2;
-    const files = getFileList();
+    const entries = getFileList().map((filePath) => createFileSearchEntry(filePath));
+    const matches = query
+      ? entries
+        .map((entry) => ({ entry, match: findFileSearchMatch(entry, query) }))
+        .filter(({ match }) => match)
+        .sort((left, right) => right.match.score - left.match.score
+          || left.entry.lowerPath.localeCompare(right.entry.lowerPath))
+      : entries.map((entry) => ({ entry, match: null }));
 
-    // Build completion options: show file paths without .md extension
-    const options = files
-      .map((filePath) => {
-        const label = filePath.replace(/\.md$/i, '');
-        // Match against full path and just the filename
-        const fileName = label.split('/').pop();
-        return { filePath, label, fileName };
-      })
-      .filter(({ label, fileName }) =>
-        label.toLowerCase().includes(query) || fileName.toLowerCase().includes(query),
-      )
-      .map(({ label, fileName }) => ({
-        label,
-        // Show just the filename as detail when in a subdirectory
-        detail: label.includes('/') ? `  ${fileName}` : undefined,
+    const options = matches
+      .slice(0, MAX_VISIBLE_RESULTS)
+      .map(({ entry }) => ({
+        label: entry.filePath,
+        displayLabel: entry.filePath.split('/').pop(),
+        detail: entry.displayName.slice(0, -entry.fileName.length - 1) || undefined,
         apply: (view, completion, from, to) => {
           // Replace from the query start to cursor, and also consume any trailing `]]`
-          const docText = view.state.doc.toString();
           let end = to;
           // If there's already a `]]` right after cursor, consume it
-          if (docText.slice(to, to + 2) === ']]') {
+          if (view.state.sliceDoc(to, to + 2) === ']]') {
             end = to + 2;
           }
           view.dispatch({
@@ -62,7 +63,6 @@ export function wikiLinkCompletions(getFileList) {
           });
         },
         type: 'text',
-        boost: label.toLowerCase().startsWith(query) ? 1 : 0,
       }));
 
     if (options.length === 0) {

package/src/client/drawio-editor.js

@@ -155,8 +155,13 @@ function teardownDrawioFrame() {
 }
 
 function buildDrawioFrameUrl() {
-  const baseUrl = runtimeConfig.drawioBaseUrl || 'https://embed.diagrams.net';
-  const url = new URL(baseUrl);
+  const fallbackUrl = 'https://embed.diagrams.net';
+  let url;
+  try {
+    url = new URL(runtimeConfig.drawioBaseUrl || fallbackUrl);
+  } catch {
+    url = new URL(fallbackUrl);
+  }
   url.searchParams.set('embed', '1');
   url.searchParams.set('proto', 'json');
   url.searchParams.set('spin', '1');
@@ -396,7 +401,7 @@ function handleLeaseState(nextState) {
   state.canClaim = Boolean(nextState?.canClaim);
 
   if (state.isEditor) {
-    state.bannerText = 'Editing';
+    state.bannerText = 'Changes save automatically.';
   } else if (nextState?.hasHealthyHolder) {
     const holderName = nextState.holderName || 'Another user';
     state.bannerText = `${holderName} is editing this diagram. Read-only mode. Updates appear after they save.`;