collabmd 0.1.45 → 0.1.46

package/src/server/infrastructure/http/create-vault-api-query-handler.js

@@ -3,7 +3,7 @@ import { readdir } from 'node:fs/promises';
 import { basename } from 'node:path';
 import { join } from 'node:path';
 
-import { isImageAttachmentFilePath } from '../../../domain/file-kind.js';
+import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { isIgnoredVaultEntry } from '../persistence/path-utils.js';
 import { parseJsonBody } from './request-body.js';
 import {
@@ -19,6 +19,36 @@ const SVG_ATTACHMENT_CSP = "default-src 'none'; img-src 'self' data: blob:; styl
 const DEFAULT_MAX_ARCHIVE_ENTRIES = 10_000;
 const DEFAULT_MAX_DOWNLOAD_FILE_BYTES = 268_435_456;
 
+function createSearchCancellation(req, res) {
+  const controller = new AbortController();
+
+  const abort = () => {
+    if (controller.signal.aborted || res.writableEnded || res.writableFinished) {
+      return;
+    }
+
+    controller.abort();
+  };
+  const handleRequestClose = () => {
+    if (!req.complete) {
+      abort();
+    }
+  };
+
+  req.once('aborted', abort);
+  req.once('close', handleRequestClose);
+  res.once('close', abort);
+
+  return {
+    cleanup() {
+      req.off('aborted', abort);
+      req.off('close', handleRequestClose);
+      res.off('close', abort);
+    },
+    signal: controller.signal,
+  };
+}
+
 function createAttachmentHeaders(attachment) {
   const fileName = basename(String(attachment?.path ?? 'attachment'));
   const headers = {
@@ -35,10 +65,10 @@ function createAttachmentHeaders(attachment) {
   return headers;
 }
 
-function createDownloadHeaders(fileName, contentType) {
+function createDownloadHeaders(fileName, contentType, { inline = false } = {}) {
   return {
     'Cache-Control': 'no-store',
-    'Content-Disposition': `attachment; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
+    'Content-Disposition': `${inline ? 'inline' : 'attachment'}; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
     'Content-Type': contentType,
     'X-Content-Type-Options': 'nosniff',
   };
@@ -304,6 +334,7 @@ async function handleFileDownload(req, res, requestUrl, { config, vaultFileStore
       headers: createDownloadHeaders(
         basename(String(download.path ?? 'download')),
         download.mimeType || 'application/octet-stream',
+        { inline: getVaultFileKind(download.path) === 'pdf' },
       ),
       statusCode: 200,
       stream: download.stream,
@@ -418,13 +449,28 @@ async function handleSearch(req, res, requestUrl, { searchService }) {
     return;
   }
 
+  const cancellation = createSearchCancellation(req, res);
+
   try {
     const result = await searchService.search({
       limit: requestUrl.searchParams.get('limit') || '',
       query: requestUrl.searchParams.get('q') || '',
+      signal: cancellation.signal,
     });
+    if (cancellation.signal.aborted || res.destroyed || res.writableEnded) {
+      return;
+    }
+
     jsonResponse(req, res, 200, result);
   } catch (error) {
+    if (
+      cancellation.signal.aborted
+      || res.destroyed
+      || res.writableEnded
+    ) {
+      return;
+    }
+
     const statusCode = Number(error?.statusCode) || 500;
     console.error('[api] Failed to search vault:', error.message);
     jsonResponse(req, res, statusCode, {
@@ -435,6 +481,8 @@ async function handleSearch(req, res, requestUrl, { searchService }) {
         backend: 'ripgrep',
       },
     });
+  } finally {
+    cancellation.cleanup();
   }
 }
 

package/src/server/infrastructure/http/http-request-helpers.js

@@ -1,6 +1,28 @@
 import { getRequestErrorStatusCode } from './http-errors.js';
 import { jsonResponse } from './http-response.js';
 
+export function stripBasePath(pathname, basePath) {
+  if (!basePath) {
+    return pathname;
+  }
+
+  if (pathname === basePath) {
+    return '/';
+  }
+
+  if (pathname.startsWith(`${basePath}/`)) {
+    return pathname.slice(basePath.length) || '/';
+  }
+
+  return pathname;
+}
+
+export function createRequestUrlWithPathname(requestUrl, pathname) {
+  const nextUrl = new URL(requestUrl.toString());
+  nextUrl.pathname = pathname || '/';
+  return nextUrl;
+}
+
 export function readRequestId(req) {
   const value = String(req.headers['x-collabmd-request-id'] || '').trim();
   return value ? value.slice(0, 120) : null;

package/src/server/infrastructure/persistence/path-utils.js

@@ -3,7 +3,7 @@ import { isAbsolute, normalize, relative, resolve } from 'path';
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
 export const IGNORED_DIRECTORIES = new Set(['.git', '.obsidian', '.trash', 'node_modules', '.DS_Store']);
-export const VAULT_FILE_PATH_REQUIREMENT = '.md, .base, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .png, .jpg, .jpeg, .webp, .gif, or .svg';
+export const VAULT_FILE_PATH_REQUIREMENT = '.md, .markdown, .mdx, .base, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .dsl, .png, .jpg, .jpeg, .webp, .gif, or .svg';
 export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in ${VAULT_FILE_PATH_REQUIREMENT}`;
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -31,6 +31,7 @@ const EDITABLE_VAULT_CONTENT_PATH_ERRORS = {
   markdown: 'Invalid file path',
   mermaid: 'Invalid file path — must end in .mmd or .mermaid',
   plantuml: 'Invalid file path — must end in .puml or .plantuml',
+  structurizr: 'Invalid file path — must end in .dsl',
 };
 
 function getEditableVaultContentKind(filePath) {
@@ -67,7 +68,9 @@ const TEXT_FILE_MIME_TYPES = Object.freeze({
   excalidraw: 'application/json; charset=utf-8',
   markdown: 'text/markdown; charset=utf-8',
   mermaid: 'text/plain; charset=utf-8',
+  pdf: 'application/pdf',
   plantuml: 'text/plain; charset=utf-8',
+  structurizr: 'text/plain; charset=utf-8',
 });
 
 function createTransactionalPath(targetPath, label) {

package/src/server/infrastructure/structurizr/structurizr-embed.css

@@ -0,0 +1,43 @@
+html, body, #content {
+  height: 100% !important;
+  min-height: 0 !important;
+}
+
+body {
+  margin: 0 !important;
+  overflow: hidden !important;
+  background: transparent !important;
+}
+
+#diagramControls,
+#diagramNavigationPanel,
+#embeddedControls {
+  display: none !important;
+}
+
+#diagramControls + .row,
+#diagramControls + .row > .col-10,
+#diagramControls + .row #diagram,
+#diagram-viewport {
+  height: 100% !important;
+  min-height: 0 !important;
+}
+
+#diagramControls + .row > .col-10 {
+  width: 100% !important;
+}
+
+#diagram {
+  background: transparent !important;
+}
+
+#diagram-viewport {
+  overflow: auto !important;
+  touch-action: pan-x pan-y !important;
+  overscroll-behavior: contain !important;
+  background: transparent !important;
+}
+
+#diagram-canvas {
+  margin: 0 auto !important;
+}

package/src/server/infrastructure/structurizr/structurizr-workspace-service.js

@@ -0,0 +1,374 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, readdir, realpath, rm, stat, utimes, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, resolve } from 'node:path';
+
+import {
+  isStructurizrFilePath,
+  isVaultFilePath,
+} from '../../../domain/file-kind.js';
+import { sanitizeVaultPath } from '../persistence/path-utils.js';
+
+const MANIFEST_FILE_NAME = '.collabmd-manifest.json';
+const WORKSPACE_DSL_FILE_NAME = 'workspace.dsl';
+const WORKSPACE_JSON_FILE_NAME = 'workspace.json';
+const SIDECAR_TIMEOUT_MS = 15_000;
+
+function createServiceError(message, statusCode, code) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  error.requestCode = code;
+  return error;
+}
+
+function normalizeWorkspaceRootPath(pathValue) {
+  const normalized = String(pathValue ?? '').trim().replace(/\\/g, '/');
+  if (!normalized || normalized.startsWith('/') || normalized.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
+    return '';
+  }
+
+  return normalized;
+}
+
+function validateStructurizrDsl(source, { trustedExecutableDsl = false } = {}) {
+  if (trustedExecutableDsl) {
+    return;
+  }
+
+  const text = String(source ?? '');
+  if (/^\s*!script\b/im.test(text) || /^\s*!plugin\b/im.test(text)) {
+    throw createServiceError(
+      'Executable Structurizr DSL is disabled for this workspace.',
+      422,
+      'STRUCTURIZR_EXECUTABLE_DSL_DISABLED',
+    );
+  }
+
+  if (/^\s*!include\s+<?(?:https?|file):/im.test(text)) {
+    throw createServiceError(
+      'Remote Structurizr DSL includes are disabled for this workspace.',
+      422,
+      'STRUCTURIZR_REMOTE_INCLUDE_DISABLED',
+    );
+  }
+}
+
+function isMirrorFileAllowed(relativePath) {
+  return basename(relativePath) === WORKSPACE_JSON_FILE_NAME || isVaultFilePath(relativePath);
+}
+
+async function collectWorkspaceFiles(directoryPath, prefix = '') {
+  const files = new Map();
+  const entries = (await readdir(directoryPath, { withFileTypes: true }))
+    .sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: 'base' }));
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === '.git') {
+      continue;
+    }
+
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const absolutePath = join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      const nested = await collectWorkspaceFiles(absolutePath, relativePath);
+      nested.forEach((content, pathValue) => files.set(pathValue, content));
+      continue;
+    }
+
+    if (!entry.isFile() || !isMirrorFileAllowed(relativePath)) {
+      continue;
+    }
+
+    files.set(relativePath, await readFile(absolutePath));
+  }
+
+  return files;
+}
+
+async function collectMirrorPaths(directoryPath, prefix = '') {
+  let entries;
+  try {
+    entries = await readdir(directoryPath, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+
+  const paths = [];
+  for (const entry of entries) {
+    if (entry.name === '.structurizr') {
+      continue;
+    }
+
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+    const absolutePath = join(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      paths.push(...await collectMirrorPaths(absolutePath, relativePath));
+    } else if (entry.isFile()) {
+      paths.push(relativePath);
+    }
+  }
+
+  return paths;
+}
+
+async function readManifest(manifestPath) {
+  try {
+    const parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
+    return Array.isArray(parsed?.paths) ? parsed.paths : [];
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) {
+      return [];
+    }
+    throw error;
+  }
+}
+
+async function writeMirrorFiles(mirrorDir, files) {
+  await Promise.all(Array.from(files, async ([relativePath, content]) => {
+    const targetPath = join(mirrorDir, relativePath);
+    await mkdir(dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, content);
+  }));
+}
+
+async function removeMirrorPaths(mirrorDir, paths) {
+  await Promise.all(paths.map((relativePath) => rm(join(mirrorDir, relativePath), {
+    force: true,
+    recursive: true,
+  })));
+}
+
+async function snapshotMirror(mirrorDir) {
+  const paths = await collectMirrorPaths(mirrorDir);
+  const files = new Map();
+  await Promise.all(paths.map(async (relativePath) => {
+    files.set(relativePath, await readFile(join(mirrorDir, relativePath)));
+  }));
+  return files;
+}
+
+async function restoreMirror(mirrorDir, snapshot) {
+  await removeMirrorPaths(mirrorDir, await collectMirrorPaths(mirrorDir));
+  await writeMirrorFiles(mirrorDir, snapshot);
+}
+
+function hashFiles(files) {
+  const hash = createHash('sha256');
+  Array.from(files.keys()).sort().forEach((pathValue) => {
+    hash.update(pathValue);
+    hash.update('\0');
+    hash.update(files.get(pathValue));
+    hash.update('\0');
+  });
+  return hash.digest('hex');
+}
+
+export class StructurizrWorkspaceService {
+  constructor({
+    mirrorDir,
+    serverUrl = '',
+    trustedExecutableDsl = false,
+    vaultDir,
+  }) {
+    this.mirrorDir = resolve(mirrorDir);
+    this.serverUrl = String(serverUrl ?? '').trim().replace(/\/+$/u, '');
+    this.trustedExecutableDsl = Boolean(trustedExecutableDsl);
+    this.vaultDir = resolve(vaultDir);
+    this.syncPromise = Promise.resolve();
+  }
+
+  isEnabled() {
+    return Boolean(this.serverUrl);
+  }
+
+  isProxyPath(pathname) {
+    return this.isEnabled() && (
+      pathname === '/workspace/1'
+      || pathname.startsWith('/workspace/1/')
+      || pathname.startsWith('/static/')
+      || pathname === '/api/workspace/1'
+      || pathname.startsWith('/api/workspace/1/')
+    );
+  }
+
+  async sync({ content, rootPath }) {
+    if (!this.isEnabled()) {
+      throw createServiceError('Structurizr renderer is not configured.', 503, 'STRUCTURIZR_NOT_CONFIGURED');
+    }
+
+    const run = async () => this.syncWorkspace({ content, rootPath });
+    this.syncPromise = this.syncPromise.catch(() => {}).then(run);
+    return this.syncPromise;
+  }
+
+  async syncWorkspace({ content, rootPath }) {
+    const normalizedRootPath = normalizeWorkspaceRootPath(rootPath);
+    if (!isStructurizrFilePath(normalizedRootPath)) {
+      throw createServiceError('Structurizr previews require a workspace.dsl root file.', 400, 'STRUCTURIZR_ROOT_REQUIRED');
+    }
+
+    const rootAbsolutePath = sanitizeVaultPath(this.vaultDir, normalizedRootPath);
+    if (!rootAbsolutePath) {
+      throw createServiceError('Invalid Structurizr workspace path.', 400, 'STRUCTURIZR_ROOT_INVALID');
+    }
+
+    let rootInfo;
+    try {
+      rootInfo = await stat(rootAbsolutePath);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw createServiceError('Structurizr workspace not found.', 404, 'STRUCTURIZR_ROOT_NOT_FOUND');
+      }
+      throw error;
+    }
+    if (!rootInfo.isFile()) {
+      throw createServiceError('Structurizr workspace root is not a file.', 400, 'STRUCTURIZR_ROOT_INVALID');
+    }
+
+    const [vaultRealPath, rootRealPath] = await Promise.all([
+      realpath(this.vaultDir),
+      realpath(rootAbsolutePath),
+    ]);
+    if (rootRealPath !== vaultRealPath && !rootRealPath.startsWith(`${vaultRealPath}/`)) {
+      throw createServiceError('Structurizr workspace must remain inside the vault.', 400, 'STRUCTURIZR_ROOT_INVALID');
+    }
+
+    const sourceDirectory = dirname(rootRealPath);
+    const files = await collectWorkspaceFiles(sourceDirectory);
+    const sourceRootFileName = basename(normalizedRootPath);
+    const rootSource = typeof content === 'string'
+      ? content
+      : files.get(sourceRootFileName)?.toString('utf8');
+    if (typeof rootSource !== 'string') {
+      throw createServiceError('Structurizr workspace source is unavailable.', 400, 'STRUCTURIZR_ROOT_UNREADABLE');
+    }
+
+    files.delete(sourceRootFileName);
+    files.set(WORKSPACE_DSL_FILE_NAME, Buffer.from(rootSource, 'utf8'));
+    for (const [pathValue, fileContent] of files) {
+      if (pathValue.toLowerCase().endsWith('.dsl')) {
+        validateStructurizrDsl(fileContent.toString('utf8'), {
+          trustedExecutableDsl: this.trustedExecutableDsl,
+        });
+      }
+    }
+
+    await mkdir(this.mirrorDir, { recursive: true });
+    const snapshot = await snapshotMirror(this.mirrorDir);
+    const previousManifest = await readManifest(join(this.mirrorDir, MANIFEST_FILE_NAME));
+    const sourcePaths = Array.from(files.keys());
+    const stalePaths = previousManifest.filter((pathValue) => !files.has(pathValue));
+
+    try {
+      await removeMirrorPaths(this.mirrorDir, stalePaths);
+      await writeMirrorFiles(this.mirrorDir, files);
+      // Local caches workspace.json; an old mtime makes it parse the DSL without a delete race.
+      const workspaceJsonPath = join(this.mirrorDir, WORKSPACE_JSON_FILE_NAME);
+      try {
+        await utimes(workspaceJsonPath, new Date(0), new Date(0));
+      } catch (error) {
+        if (error.code !== 'ENOENT') {
+          throw error;
+        }
+      }
+      await this.validateMirror();
+      if (files.has(WORKSPACE_JSON_FILE_NAME)) {
+        await writeMirrorFiles(this.mirrorDir, new Map([
+          [WORKSPACE_JSON_FILE_NAME, files.get(WORKSPACE_JSON_FILE_NAME)],
+        ]));
+      }
+      await writeFile(
+        join(this.mirrorDir, MANIFEST_FILE_NAME),
+        `${JSON.stringify({ paths: sourcePaths }, null, 2)}\n`,
+        'utf8',
+      );
+    } catch (error) {
+      await restoreMirror(this.mirrorDir, snapshot);
+      throw error;
+    }
+
+    return {
+      ok: true,
+      rootPath: normalizedRootPath,
+      version: hashFiles(files),
+    };
+  }
+
+  async validateMirror() {
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      let response;
+      try {
+        response = await fetch(`${this.serverUrl}/api/workspace/1`, {
+          headers: { Accept: 'application/json' },
+          signal: AbortSignal.timeout(SIDECAR_TIMEOUT_MS),
+        });
+      } catch (error) {
+        throw createServiceError(
+          `Structurizr renderer is unavailable: ${error.message}`,
+          503,
+          'STRUCTURIZR_UNAVAILABLE',
+        );
+      }
+
+      const payload = await response.json().catch(() => ({}));
+      if (response.ok && payload.success !== false) {
+        return;
+      }
+
+      const message = String(payload.message || payload.error || `Structurizr renderer returned HTTP ${response.status}`)
+        .replace(/^com\.structurizr\.dsl\.StructurizrDslParserException:\s*/u, '');
+      const isTransientStartupFailure = response.status >= 500
+        && /(?:No workspace|FileNotFoundException|workspace\.json)/iu.test(message);
+      if (isTransientStartupFailure && attempt < 7) {
+        await new Promise((resolvePromise) => setTimeout(resolvePromise, 250));
+        continue;
+      }
+
+      throw createServiceError(
+        message,
+        response.status >= 400 && response.status < 500 ? 422 : 502,
+        response.status >= 400 && response.status < 500
+          ? 'STRUCTURIZR_DSL_INVALID'
+          : 'STRUCTURIZR_VALIDATION_FAILED',
+      );
+    }
+  }
+
+  async proxy(requestUrl, { method = 'GET', headers = {} } = {}) {
+    if (!this.isProxyPath(requestUrl.pathname)) {
+      return null;
+    }
+
+    const upstreamUrl = `${this.serverUrl}${requestUrl.pathname}${requestUrl.search}`;
+    let response;
+    try {
+      const proxyHeaders = {
+        Accept: headers.accept || '*/*',
+      };
+      if (headers.range) {
+        proxyHeaders.Range = headers.range;
+      }
+      response = await fetch(upstreamUrl, {
+        headers: proxyHeaders,
+        method,
+        redirect: 'follow',
+        signal: AbortSignal.timeout(SIDECAR_TIMEOUT_MS),
+      });
+    } catch (error) {
+      throw createServiceError(
+        `Structurizr renderer is unavailable: ${error.message}`,
+        503,
+        'STRUCTURIZR_UNAVAILABLE',
+      );
+    }
+
+    return {
+      body: Buffer.from(await response.arrayBuffer()),
+      contentType: response.headers.get('content-type') || 'application/octet-stream',
+      statusCode: response.status,
+    };
+  }
+}
+

package/src/server/infrastructure/websocket/attach-collaboration-gateway.js

@@ -1,6 +1,10 @@
 import { WebSocketServer } from 'ws';
 
 import { normalizeHostedEmail } from '../../domain/hosted-workspace-contract.js';
+import {
+  createRequestUrlWithPathname,
+  stripBasePath,
+} from '../http/http-request-helpers.js';
 import { ClientSocketSession } from './client-socket-session.js';
 
 function rejectUpgrade(socket, statusCode, statusMessage, {
@@ -25,28 +29,6 @@ function extractRoomName(pathname, wsBasePath) {
   return decodeURIComponent(roomSegment || 'default');
 }
 
-function stripBasePath(pathname, basePath) {
-  if (!basePath) {
-    return pathname;
-  }
-
-  if (pathname === basePath) {
-    return '/';
-  }
-
-  if (pathname.startsWith(`${basePath}/`)) {
-    return pathname.slice(basePath.length) || '/';
-  }
-
-  return pathname;
-}
-
-function createRequestUrlWithPathname(requestUrl, pathname) {
-  const nextUrl = new URL(requestUrl.toString());
-  nextUrl.pathname = pathname || '/';
-  return nextUrl;
-}
-
 export function attachCollaborationGateway({
   authService,
   basePath = '',

package/dist/client/assets/CodeMirrorEditor-UCMRAMCV-CbSISC1w.js

@@ -1 +0,0 @@
-import{i as e}from"./rolldown-runtime-Dd_uD5pT.js";import{A as t,F as n,J as r,L as i,P as a,V as o,X as s,c,lt as l,q as u,st as d,t as f}from"./dist-C11hHqv_.js";import"./chunk-SRAX5OIU-KFQikY-4.js";import{n as p,t as m}from"./jsx-runtime-BpzPEenQ.js";import{n as h,r as g,s as _,t as v}from"./dist-GrygD2zE.js";var y=e(p(),1),b=m(),x=c.define({token(e){return e.match(/^%%.*$/)?`comment`:e.match(/^"(?:[^"\\]|\\.)*"/)?`string`:e.match(/^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i)||e.match(/^(TB|TD|BT|RL|LR)\b/)||e.match(/^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i)?`keyword`:e.match(/^[-.=<>|ox]+>/)||e.match(/^<[-.=<>|ox]+/)||e.match(/^--+|\.\.+|==+/)?`operator`:e.match(/^[[\](){}|<>]/)?`bracket`:e.match(/^[A-Za-z_][A-Za-z0-9_]*/)?`variableName`:e.match(/^\d+(\.\d+)?/)?`number`:e.match(/^[,:;]/)?`punctuation`:(e.eatSpace()||e.next(),null)}});function S(){return x}var C=i.theme({"&":{backgroundColor:`#1e1e1e`,color:`#d4d4d4`},".cm-content":{caretColor:`#fff`},".cm-cursor":{borderLeftColor:`#fff`},".cm-gutters":{backgroundColor:`#1e1e1e`,color:`#858585`,border:`none`},".cm-activeLineGutter":{backgroundColor:`#2a2a2a`},".cm-activeLine":{backgroundColor:`#2a2a2a`},".cm-errorLine":{backgroundColor:`rgba(255, 0, 0, 0.15)`}},{dark:!0}),w=f.define([{tag:a.keyword,color:`#569cd6`},{tag:a.string,color:`#ce9178`},{tag:a.comment,color:`#6a9955`},{tag:a.number,color:`#b5cea8`},{tag:a.operator,color:`#d4d4d4`},{tag:a.punctuation,color:`#d4d4d4`},{tag:a.variableName,color:`#9cdcfe`},{tag:a.bracket,color:`#ffd700`}]),T=i.theme({"&":{backgroundColor:`#ffffff`,color:`#1e1e1e`},".cm-content":{caretColor:`#000`},".cm-cursor":{borderLeftColor:`#000`},".cm-gutters":{backgroundColor:`#fff`,color:`#999`,border:`none`},".cm-activeLineGutter":{backgroundColor:`#e8e8e8`},".cm-activeLine":{backgroundColor:`#e8e8e8`},".cm-errorLine":{backgroundColor:`rgba(255, 0, 0, 0.1)`}}),E=f.define([{tag:a.keyword,color:`#0000ff`},{tag:a.string,color:`#a31515`},{tag:a.comment,color:`#008000`},{tag:a.number,color:`#098658`},{tag:a.operator,color:`#1e1e1e`},{tag:a.punctuation,color:`#1e1e1e`},{tag:a.variableName,color:`#001080`},{tag:a.bracket,color:`#af00db`}]),D=n.line({class:`cm-errorLine`}),O=(e,t)=>{if(!e||e<1||e>t.lines)return i.decorations.of(n.none);let r=t.line(e);return i.decorations.of(n.set([D.range(r.from)]))},k=e=>e===`dark`?[C,t(w)]:[T,t(E)],A=({value:e,onChange:t,onKeyboardSubmit:n,placeholder:a,theme:c,errorLine:f})=>{let p=(0,y.useRef)(null),m=(0,y.useRef)(null),x=(0,y.useRef)(t),C=(0,y.useRef)(n),w=(0,y.useRef)(new d),T=(0,y.useRef)(new d);return x.current=t,C.current=n,(0,y.useEffect)(()=>{if(!p.current)return;let t=w.current,n=new i({state:l.create({doc:e,extensions:[u.of([{key:`Mod-Enter`,run:()=>(C.current?.(),!0)},{key:`Mod-Shift-z`,run:_,preventDefault:!0}]),i.updateListener.of(e=>{e.docChanged&&x.current(e.state.doc.toString())}),h(),u.of([...v,...g]),r(),i.lineWrapping,t.of(k(c)),T.current.of([]),S(),o({drawRangeCursor:!0}),...a?[s(a)]:[]]}),parent:p.current});return m.current=n,n.focus(),()=>{n.destroy(),m.current=null}},[]),(0,y.useEffect)(()=>{let e=m.current;e&&e.dispatch({effects:w.current.reconfigure(k(c))})},[c]),(0,y.useEffect)(()=>{let e=m.current;e&&e.dispatch({effects:T.current.reconfigure(O(f,e.state.doc))})},[f]),(0,y.useEffect)(()=>{let t=m.current;if(!t)return;let n=t.state.doc.toString();e!==n&&t.dispatch({changes:{from:0,to:n.length,insert:e}})},[e]),(0,b.jsx)(`div`,{ref:p,className:`ttd-dialog-input ttd-dialog-input--codemirror`})};export{A as default};

package/dist/client/assets/browser-utils-CKtI_rZl.js

@@ -1 +0,0 @@
-function e(){return typeof window>`u`?globalThis:window}function t(t,n){let r=e();return typeof r.requestIdleCallback==`function`?r.requestIdleCallback(t,{timeout:n}):r.setTimeout(()=>t({didTimeout:!1,timeRemaining:()=>0}),1)}function n(t){if(t===null)return;let n=e();if(typeof n.cancelIdleCallback==`function`){n.cancelIdleCallback(t);return}n.clearTimeout(t)}function r(e,t,n){if(!e||!t)return!1;let r=t.getBoundingClientRect(),i=e.getBoundingClientRect();return i.bottom>=r.top-n&&i.top<=r.bottom+n}function i(t,n,{removeDelayMs:r=3e4,revokeDelayMs:i=r}={}){let a=e(),o=URL.createObjectURL(t),s=document.createElement(`a`);s.href=o,s.download=n,s.style&&(s.style.display=`none`),document.body.appendChild(s),s.click(),r>0?a.setTimeout(()=>s.remove(),r):s.remove(),a.setTimeout(()=>URL.revokeObjectURL(o),i)}function a(e=``,t=`download`){let n=String(e).match(/filename\*=UTF-8''([^;]+)/iu);if(n)try{return decodeURIComponent(n[1])}catch{return t}return String(e).match(/filename="([^"]+)"/iu)?.[1]||t}export{t as a,a as i,i as n,r,n as t};