collabmd 0.1.43 → 0.1.45

package/src/client/bootstrap/app-shell-feature-surface.js

@@ -1,67 +0,0 @@
-import { chatFeature } from '../application/app-shell/chat-feature.js';
-import { commentsFeature } from '../application/app-shell/comments-feature.js';
-import { exportFeature } from '../application/app-shell/export-feature.js';
-import { gitFeature } from '../application/app-shell/git-feature.js';
-import { lazyControllerFeature } from './lazy-controller-feature.js';
-import { presenceFeature } from '../application/app-shell/presence-feature.js';
-import { uiFeature } from '../application/app-shell/ui-feature.js';
-import { workspaceFeature } from '../application/app-shell/workspace-feature.js';
-
-export const appShellFeatures = Object.freeze({
-  chat: chatFeature,
-  comments: commentsFeature,
-  export: exportFeature,
-  git: gitFeature,
-  lazyControllers: lazyControllerFeature,
-  presence: presenceFeature,
-  ui: uiFeature,
-  workspace: workspaceFeature,
-});
-
-export function createAppShellFeatureSurface(appShell, features = appShellFeatures) {
-  const methodEntries = [];
-  const methodOwners = new Map();
-
-  for (const [featureName, feature] of Object.entries(features)) {
-    for (const [methodName, method] of Object.entries(feature)) {
-      if (typeof method !== 'function') {
-        continue;
-      }
-      if (methodOwners.has(methodName)) {
-        throw new Error(`Duplicate App Shell feature method "${methodName}" from ${methodOwners.get(methodName)} and ${featureName}`);
-      }
-      methodOwners.set(methodName, featureName);
-      methodEntries.push([methodName, method]);
-    }
-  }
-
-  const target = {};
-  const surface = new Proxy(target, {
-    get(surfaceTarget, property, receiver) {
-      if (Reflect.has(surfaceTarget, property)) {
-        return Reflect.get(surfaceTarget, property, receiver);
-      }
-      return appShell[property];
-    },
-    has(surfaceTarget, property) {
-      return Reflect.has(surfaceTarget, property) || property in appShell;
-    },
-    set(surfaceTarget, property, value) {
-      if (Reflect.has(surfaceTarget, property)) {
-        return Reflect.set(surfaceTarget, property, value);
-      }
-      appShell[property] = value;
-      return true;
-    },
-  });
-
-  for (const [methodName, method] of methodEntries) {
-    Object.defineProperty(target, methodName, {
-      configurable: false,
-      enumerable: true,
-      value: (...args) => method.apply(surface, args),
-    });
-  }
-
-  return surface;
-}

package/src/client/bootstrap/lazy-controller-feature.js

@@ -1,434 +0,0 @@
-function getPathLeaf(filePath = '') {
-  return String(filePath ?? '').split('/').filter(Boolean).pop() || String(filePath ?? '') || 'File';
-}
-
-function createLazyControllerProxy({
-  createController,
-  fallback = {},
-  loadController,
-  onControllerReady = null,
-  shouldLoad = () => true,
-}) {
-  let controller = null;
-  let controllerPromise = null;
-
-  const ensure = async () => {
-    if (controller) {
-      return controller;
-    }
-    if (!controllerPromise) {
-      controllerPromise = loadController()
-        .then((ControllerClass) => {
-          controller = createController(ControllerClass);
-          onControllerReady?.(controller);
-          return controller;
-        })
-        .catch((error) => {
-          controllerPromise = null;
-          throw error;
-        });
-    }
-    return controllerPromise;
-  };
-
-  const proxy = new Proxy({}, {
-    get(_target, prop) {
-      if (prop === 'then' || typeof prop !== 'string') {
-        return undefined;
-      }
-      if (prop === 'ensure') {
-        return ensure;
-      }
-      if (prop === 'current') {
-        return controller;
-      }
-      if (controller && prop in controller) {
-        const value = controller[prop];
-        return typeof value === 'function' ? value.bind(controller) : value;
-      }
-      if (Object.hasOwn(fallback, prop)) {
-        const value = fallback[prop];
-        return typeof value === 'function' ? value.bind(proxy) : value;
-      }
-      return (...args) => {
-        if (!shouldLoad(prop, args)) {
-          return undefined;
-        }
-        return ensure().then((resolvedController) => {
-          const value = resolvedController[prop];
-          return typeof value === 'function' ? value.apply(resolvedController, args) : value;
-        });
-      };
-    },
-  });
-
-  return proxy;
-}
-
-function hasPreviewSelector(previewElement, selector) {
-  return Boolean(previewElement?.querySelector?.(selector));
-}
-
-export const lazyControllerFeature = {
-  reportLazyControllerError(label, error) {
-    console.error(`[lazy-controller] Failed to load ${label}.`, error);
-    this.toastController?.show?.(`Failed to load ${label}. Try again.`, {
-      dismissible: true,
-    });
-  },
-
-  loadBasesPreviewController() {
-    return import('../presentation/bases-preview-controller.js')
-      .then((module) => module.BasesPreviewController);
-  },
-
-  loadDrawioEmbedController() {
-    return import('../presentation/drawio-embed-controller.js')
-      .then((module) => module.DrawioEmbedController);
-  },
-
-  loadExcalidrawEmbedController() {
-    return import('../presentation/excalidraw-embed-controller.js')
-      .then((module) => module.ExcalidrawEmbedController);
-  },
-
-  loadGitPanelController() {
-    return import('../presentation/git-panel-controller.js')
-      .then((module) => module.GitPanelController);
-  },
-
-  loadGitDiffViewController() {
-    return import('../presentation/git-diff-view-controller.js')
-      .then((module) => module.GitDiffViewController);
-  },
-
-  loadFileHistoryViewController() {
-    return import('../presentation/file-history-view-controller.js')
-      .then((module) => module.FileHistoryViewController);
-  },
-
-  createLazyBasesPreviewController() {
-    let proxy;
-    proxy = createLazyControllerProxy({
-      createController: (BasesPreviewController) => new BasesPreviewController({
-        getActiveFilePath: () => this.currentFilePath,
-        getSession: () => this.session,
-        onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
-        previewElement: this.elements.previewContent,
-        replaceBaseSource: ({ path, source }) => {
-          if (path && path === this.currentFilePath) {
-            this.session?.replaceText?.(source);
-          }
-        },
-        toastController: this.toastController,
-        vaultApiClient: this.vaultApiClient,
-      }),
-      fallback: {
-        destroy: () => { },
-        reconcileEmbeds: (previewElement = this.elements.previewContent) => {
-          if (!hasPreviewSelector(previewElement, '.bases-embed-placeholder[data-base-key]')) {
-            return;
-          }
-          void proxy.ensure()
-            .then((controller) => controller.reconcileEmbeds(previewElement))
-            .catch((error) => this.reportLazyControllerError('Bases preview', error));
-        },
-        renderStandalone: async (payload) => {
-          const controller = await proxy.ensure();
-          return controller.renderStandalone(payload);
-        },
-      },
-      loadController: () => this.loadBasesPreviewController(),
-      shouldLoad: (methodName) => methodName === 'renderStandalone',
-    });
-    return proxy;
-  },
-
-  createLazyDrawioEmbedController() {
-    const state = {
-      hydrationPaused: false,
-      theme: null,
-    };
-    let proxy;
-    proxy = createLazyControllerProxy({
-      createController: (DrawioEmbedController) => new DrawioEmbedController({
-        getLocalUser: () => this.lobby.getLocalUser(),
-        getTheme: () => this.themeController.getTheme(),
-        onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
-        onOpenTextFile: (filePath) => filePath && this.navigation.navigateToFile(filePath, { drawioMode: 'text' }),
-        onToggleQuickSwitcher: () => {
-          void this.toggleQuickSwitcher();
-        },
-        previewContainer: this.elements.previewContainer,
-        previewElement: this.elements.previewContent,
-        toastController: this.toastController,
-      }),
-      fallback: {
-        destroy: () => { },
-        detachForCommit: () => { },
-        hydrateVisibleEmbeds: () => { },
-        reconcileEmbeds: (previewElement = this.elements.previewContent) => {
-          if (!hasPreviewSelector(previewElement, '.drawio-embed-placeholder[data-drawio-key]')) {
-            return;
-          }
-          void proxy.ensure()
-            .then((controller) => {
-              controller.reconcileEmbeds(previewElement);
-              controller.hydrateVisibleEmbeds();
-              controller.syncLayout();
-            })
-            .catch((error) => this.reportLazyControllerError('Draw.io preview', error));
-        },
-        setHydrationPaused: (paused) => {
-          state.hydrationPaused = Boolean(paused);
-        },
-        syncLayout: () => { },
-        updateLocalUser: () => { },
-        updateTheme: (theme) => {
-          state.theme = theme;
-        },
-      },
-      loadController: () => this.loadDrawioEmbedController(),
-      onControllerReady: (controller) => {
-        controller.setHydrationPaused(state.hydrationPaused);
-        if (state.theme) {
-          controller.updateTheme(state.theme);
-        }
-      },
-    });
-    return proxy;
-  },
-
-  createLazyExcalidrawEmbedController() {
-    const state = {
-      hydrationPaused: false,
-      localUser: null,
-      theme: null,
-    };
-    let proxy;
-    proxy = createLazyControllerProxy({
-      createController: (ExcalidrawEmbedController) => new ExcalidrawEmbedController({
-        getLocalUser: () => this.lobby.getLocalUser(),
-        getTheme: () => this.themeController.getTheme(),
-        onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
-        onToggleQuickSwitcher: () => {
-          void this.toggleQuickSwitcher();
-        },
-        previewContainer: this.elements.previewContainer,
-        previewElement: this.elements.previewContent,
-        toastController: this.toastController,
-      }),
-      fallback: {
-        destroy: () => { },
-        detachForCommit: () => { },
-        hydrateVisibleEmbeds: () => { },
-        prepareFileDisconnect: async () => false,
-        reconcileEmbeds: (previewElement = this.elements.previewContent, options = {}) => {
-          if (!hasPreviewSelector(previewElement, '.excalidraw-embed-placeholder[data-embed-key]')) {
-            return;
-          }
-          void proxy.ensure()
-            .then((controller) => {
-              controller.reconcileEmbeds(previewElement, options);
-              controller.hydrateVisibleEmbeds();
-              controller.syncLayout();
-            })
-            .catch((error) => this.reportLazyControllerError('Excalidraw preview', error));
-        },
-        setHydrationPaused: (paused) => {
-          state.hydrationPaused = Boolean(paused);
-        },
-        syncLayout: () => { },
-        updateLocalUser: (user) => {
-          state.localUser = user;
-        },
-        updateTheme: (theme) => {
-          state.theme = theme;
-        },
-      },
-      loadController: () => this.loadExcalidrawEmbedController(),
-      onControllerReady: (controller) => {
-        controller.setHydrationPaused(state.hydrationPaused);
-        if (state.theme) {
-          controller.updateTheme(state.theme);
-        }
-        if (state.localUser) {
-          controller.updateLocalUser(state.localUser);
-        }
-      },
-    });
-    return proxy;
-  },
-
-  createLazyGitPanelController() {
-    const state = {
-      active: false,
-      mode: 'changes',
-      selection: {},
-    };
-    let proxy;
-    proxy = createLazyControllerProxy({
-      createController: (GitPanelController) => new GitPanelController({
-        enabled: this.runtimeConfig.gitEnabled !== false,
-        gitApiClient: this.gitApiClient,
-        onCommitStaged: () => this.openGitCommitDialog(),
-        onOpenPullBackup: (filePath) => filePath && this.navigation.navigateToFile(filePath),
-        onPullBranch: () => this.pullGitBranch(),
-        onPushBranch: () => this.pushGitBranch(),
-        onRepoChange: (isGitRepo, status) => this.handleGitRepoChange(isGitRepo, status),
-        onResetFile: (filePath, { scope }) => this.openGitResetDialog(filePath, { scope }),
-        onSelectCommit: (hash, { path }) => this.handleGitCommitSelection(hash, { closeSidebarOnMobile: true, path }),
-        onSelectDiff: (filePath, { scope }) => this.handleGitDiffSelection(filePath, { closeSidebarOnMobile: true, scope }),
-        onStageFile: (filePath, { scope }) => this.stageGitFile(filePath, { scope }),
-        onUnstageFile: (filePath, { scope }) => this.unstageGitFile(filePath, { scope }),
-        onViewAllDiff: () => this.handleGitDiffSelection(null, { closeSidebarOnMobile: true, scope: 'all' }),
-        searchInput: this.elements.gitSearchInput,
-        toastController: this.toastController,
-      }),
-      fallback: {
-        initialize: () => { },
-        refresh: async (options) => {
-          const controller = await proxy.ensure();
-          return controller.refresh(options);
-        },
-        setActive: (active) => {
-          state.active = Boolean(active);
-          if (state.active) {
-            void proxy.ensure().catch((error) => this.reportLazyControllerError('Git panel', error));
-          }
-        },
-        setMode: (mode) => {
-          state.mode = mode;
-          if (state.active) {
-            void proxy.ensure().catch((error) => this.reportLazyControllerError('Git panel', error));
-          }
-        },
-        setSelection: (selection = {}) => {
-          state.selection = selection;
-          if (state.active) {
-            void proxy.ensure().catch((error) => this.reportLazyControllerError('Git panel', error));
-          }
-        },
-        status: null,
-      },
-      loadController: () => this.loadGitPanelController(),
-      onControllerReady: (controller) => {
-        controller.initialize();
-        void controller.setMode(state.mode);
-        controller.setSelection(state.selection);
-        controller.setActive(state.active);
-        if (state.active) {
-          void controller.refresh({ force: true });
-        }
-      },
-    });
-    return proxy;
-  },
-
-  createLazyGitDiffViewController() {
-    const state = {
-      repoStatus: null,
-    };
-    let proxy;
-    proxy = createLazyControllerProxy({
-      createController: (GitDiffViewController) => new GitDiffViewController({
-        gitApiClient: this.gitApiClient,
-        onBackToHistory: ({ historyFilePath } = {}) => {
-          if (historyFilePath) {
-            this.navigation.navigateToGitFileHistory({ filePath: historyFilePath });
-            return;
-          }
-          this.navigation.navigateToGitHistory();
-        },
-        onCommitStaged: () => this.openGitCommitDialog(),
-        onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
-        onStageFile: (filePath, { scope }) => this.stageGitFile(filePath, { scope }),
-        onUnstageFile: (filePath, { scope }) => this.unstageGitFile(filePath, { scope }),
-        toastController: this.toastController,
-      }),
-      fallback: {
-        getToolbarTitle: ({ commitHash = null, filePath = null, path = null, scope = 'all', source = 'workspace' } = {}) => {
-          if (source === 'commit') {
-            if (path) return getPathLeaf(path);
-            return commitHash ? `Commit ${String(commitHash).slice(0, 7)}` : 'Commit Diff';
-          }
-          if (filePath) return getPathLeaf(filePath);
-          if (scope === 'staged') return 'Staged Changes';
-          if (scope === 'working-tree') return 'Working Tree Changes';
-          return 'All Changes';
-        },
-        hide: () => { },
-        initialize: () => { },
-        setRepoStatus: (status) => {
-          state.repoStatus = status;
-        },
-      },
-      loadController: () => this.loadGitDiffViewController(),
-      onControllerReady: (controller) => {
-        controller.initialize();
-        controller.setRepoStatus(state.repoStatus);
-      },
-    });
-    return proxy;
-  },
-
-  createLazyFileHistoryViewController() {
-    let proxy;
-    proxy = createLazyControllerProxy({
-      createController: (FileHistoryViewController) => new FileHistoryViewController({
-        diffRenderer: this.gitDiffView,
-        gitApiClient: this.gitApiClient,
-        onOpenCommitDiff: (hash, { historyFilePath, path }) => this.handleGitCommitSelection(hash, {
-          closeSidebarOnMobile: false,
-          historyFilePath,
-          path,
-        }),
-        onOpenFile: (filePath) => filePath && this.navigation.navigateToFile(filePath),
-        onOpenPreview: ({ hash, path, currentFilePath }) => this.handleGitFilePreviewSelection({
-          hash,
-          path,
-          currentFilePath,
-        }),
-        onOpenWorkspaceDiff: (filePath) => this.handleGitDiffSelection(filePath, { closeSidebarOnMobile: false, scope: 'all' }),
-        toastController: this.toastController,
-      }),
-      fallback: {
-        hide: () => { },
-        initialize: () => { },
-      },
-      loadController: () => this.loadFileHistoryViewController(),
-      onControllerReady: (controller) => {
-        controller.initialize();
-      },
-    });
-    return proxy;
-  },
-
-  async ensureGitControllers() {
-    await Promise.all([
-      this.gitPanel.ensure(),
-      this.gitDiffView.ensure(),
-      this.fileHistoryView.ensure(),
-    ]);
-  },
-
-  scheduleGitControllerPrewarm({ timeout = 2500 } = {}) {
-    if (this.runtimeConfig.gitEnabled === false || this._gitControllerPrewarmHandle) {
-      return;
-    }
-
-    const runPrewarm = () => {
-      this._gitControllerPrewarmHandle = null;
-      void this.gitPanel.ensure()
-        .then((controller) => controller.refresh({ force: true }))
-        .catch((error) => this.reportLazyControllerError('Git tools', error));
-    };
-
-    if (typeof window.requestIdleCallback === 'function') {
-      this._gitControllerPrewarmHandle = window.requestIdleCallback(runPrewarm, { timeout });
-      return;
-    }
-
-    this._gitControllerPrewarmHandle = window.setTimeout(runPrewarm, 0);
-  },
-};

package/src/client/domain/excalidraw-document-switch.js

@@ -1,3 +0,0 @@
-export function normalizeDocumentMode(mode) {
-  return mode === 'preview' ? 'preview' : 'edit';
-}

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

@@ -1 +0,0 @@
-export { VaultApiClient, vaultApiClient } from '../infrastructure/vault-api-client.js';

package/src/client/domain/workspace-request-id.js

@@ -1,7 +0,0 @@
-export function createWorkspaceRequestId() {
-  if (globalThis.crypto?.randomUUID) {
-    return globalThis.crypto.randomUUID();
-  }
-
-  return `workspace-${Date.now()}-${Math.random().toString(16).slice(2, 10)}`;
-}

package/src/client/infrastructure/backlinks-api-client.js

@@ -1,18 +0,0 @@
-import { resolveApiUrl } from '../domain/runtime-paths.js';
-
-export class BacklinksApiClient {
-  async readBacklinks(filePath, { signal } = {}) {
-    const response = await fetch(
-      resolveApiUrl(`/backlinks?file=${encodeURIComponent(filePath)}`),
-      { signal },
-    );
-    const data = await response.json().catch(() => ({}));
-    if (!response.ok) {
-      throw new Error(data.error || 'Failed to load backlinks');
-    }
-
-    return Array.isArray(data.backlinks) ? data.backlinks : [];
-  }
-}
-
-export const backlinksApiClient = new BacklinksApiClient();

package/src/client/infrastructure/browser-navigation-port.js

@@ -1,39 +0,0 @@
-import {
-  getHashRoute,
-  navigateToGitCommit,
-  navigateToFile,
-  navigateToGitDiff,
-  navigateToGitFileHistory,
-  navigateToGitFilePreview,
-  navigateToGitHistory,
-} from './runtime-config.js';
-
-export class BrowserNavigationPort {
-  getHashRoute() {
-    return getHashRoute();
-  }
-
-  navigateToFile(filePath, options) {
-    navigateToFile(filePath, options);
-  }
-
-  navigateToGitDiff(payload) {
-    navigateToGitDiff(payload);
-  }
-
-  navigateToGitCommit(payload) {
-    navigateToGitCommit(payload);
-  }
-
-  navigateToGitHistory() {
-    navigateToGitHistory();
-  }
-
-  navigateToGitFileHistory(payload) {
-    navigateToGitFileHistory(payload);
-  }
-
-  navigateToGitFilePreview(payload) {
-    navigateToGitFilePreview(payload);
-  }
-}

package/src/client/infrastructure/plantuml-api-client.js

@@ -1,21 +0,0 @@
-import { resolveApiUrl } from '../domain/runtime-paths.js';
-
-export class PlantUmlApiClient {
-  async renderSvg(source) {
-    const response = await fetch(resolveApiUrl('/plantuml/render'), {
-      body: JSON.stringify({ source }),
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      method: 'POST',
-    });
-    const data = await response.json().catch(() => null);
-    if (!response.ok || !data?.ok || typeof data.svg !== 'string') {
-      throw new Error(data?.error || 'Failed to render PlantUML');
-    }
-
-    return data.svg;
-  }
-}
-
-export const plantUmlApiClient = new PlantUmlApiClient();

package/src/client/infrastructure/runtime-config-loader.js

@@ -1,56 +0,0 @@
-let runtimeConfigLoadPromise = null;
-
-function getRuntimeConfigScriptUrl() {
-  return new URL('./app-config.js', window.location.href).toString();
-}
-
-function createRuntimeConfigScript() {
-  const script = document.createElement('script');
-  script.src = getRuntimeConfigScriptUrl();
-  script.dataset.collabmdRuntimeConfig = 'true';
-  return script;
-}
-
-export function ensureRuntimeConfigLoaded() {
-  if (window.__COLLABMD_CONFIG__) {
-    return Promise.resolve(window.__COLLABMD_CONFIG__);
-  }
-
-  if (runtimeConfigLoadPromise) {
-    return runtimeConfigLoadPromise;
-  }
-
-  runtimeConfigLoadPromise = new Promise((resolve, reject) => {
-    const existingScript = document.querySelector('script[data-collabmd-runtime-config]');
-    const script = existingScript instanceof HTMLScriptElement
-      ? existingScript
-      : createRuntimeConfigScript();
-
-    const cleanup = () => {
-      script.removeEventListener('error', handleError);
-      script.removeEventListener('load', handleLoad);
-    };
-
-    const handleError = () => {
-      cleanup();
-      runtimeConfigLoadPromise = null;
-      reject(new Error('Failed to load runtime config'));
-    };
-
-    const handleLoad = () => {
-      cleanup();
-      resolve(window.__COLLABMD_CONFIG__ ?? {});
-    };
-
-    script.addEventListener('error', handleError, { once: true });
-    script.addEventListener('load', handleLoad, { once: true });
-
-    if (!existingScript) {
-      document.head.append(script);
-    } else if (window.__COLLABMD_CONFIG__) {
-      handleLoad();
-    }
-  });
-
-  return runtimeConfigLoadPromise;
-}

package/src/client/mermaid-runtime.js

@@ -1,3 +0,0 @@
-import mermaid from 'mermaid';
-
-export default mermaid;

package/src/client/presentation/app-shell-renderer.js

@@ -1,13 +0,0 @@
-import { render } from 'lit-html';
-
-import { appShellTemplate } from './app-shell-template.js';
-
-export function renderAppShell(doc = document) {
-  const host = doc.getElementById('appRoot');
-  if (!host) {
-    throw new Error('App shell root element #appRoot is missing.');
-  }
-
-  render(appShellTemplate(), host);
-  return host;
-}