collabmd 0.1.18

package/src/domain/comment-threads.js

@@ -0,0 +1,233 @@
+import * as Y from 'yjs';
+
+export const COMMENT_BODY_MAX_LENGTH = 2000;
+export const COMMENT_EXCERPT_MAX_LENGTH = 160;
+export const COMMENT_ANCHOR_QUOTE_MAX_LENGTH = 280;
+
+const COMMENT_ANCHOR_KINDS = new Set(['line', 'text']);
+
+function asFiniteNumber(value) {
+  return Number.isFinite(value) ? value : null;
+}
+
+function asObject(value) {
+  if (value instanceof Y.Map) {
+    return value.toJSON();
+  }
+
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+
+function asString(value) {
+  return typeof value === 'string' ? value : '';
+}
+
+function readThreadValue(thread, key) {
+  if (thread instanceof Y.Map) {
+    return thread.get(key);
+  }
+
+  return thread?.[key];
+}
+
+function isResolvedThread(thread) {
+  return asFiniteNumber(readThreadValue(thread, 'resolvedAt')) !== null;
+}
+
+function normalizeAnchorKind(value) {
+  return COMMENT_ANCHOR_KINDS.has(value) ? value : null;
+}
+
+export function normalizeCommentBody(value) {
+  const normalized = String(value ?? '')
+    .replace(/\r\n?/g, '\n')
+    .trim()
+    .slice(0, COMMENT_BODY_MAX_LENGTH);
+
+  return normalized || null;
+}
+
+export function normalizeCommentQuote(value) {
+  const normalized = String(value ?? '')
+    .replace(/\r\n?/g, '\n')
+    .trim()
+    .slice(0, COMMENT_ANCHOR_QUOTE_MAX_LENGTH);
+
+  return normalized || '';
+}
+
+export function normalizeCommentQuoteForComparison(value) {
+  return String(value ?? '')
+    .replace(/\r\n?/g, '\n')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function summarizeCommentExcerpt(value, maxLength = COMMENT_EXCERPT_MAX_LENGTH) {
+  const normalized = normalizeCommentQuoteForComparison(value);
+  if (!normalized) {
+    return '';
+  }
+
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+
+  return `${normalized.slice(0, Math.max(maxLength - 1, 1)).trimEnd()}…`;
+}
+
+function createMessageRecord(message) {
+  const body = normalizeCommentBody(message?.body);
+  if (!body) {
+    return null;
+  }
+
+  return {
+    body,
+    createdAt: asFiniteNumber(message?.createdAt) ?? Date.now(),
+    id: asString(message?.id) || createCommentId('comment'),
+    peerId: asString(message?.peerId),
+    userColor: asString(message?.userColor),
+    userName: asString(message?.userName) || 'Anonymous',
+  };
+}
+
+function serializeMessages(messages) {
+  const source = messages instanceof Y.Array
+    ? messages.toArray()
+    : Array.isArray(messages)
+      ? messages
+      : [];
+
+  return source
+    .map((message) => createMessageRecord(message))
+    .filter(Boolean);
+}
+
+export function createCommentId(prefix = 'comment') {
+  if (globalThis.crypto?.randomUUID) {
+    return `${prefix}-${globalThis.crypto.randomUUID()}`;
+  }
+
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+export function normalizeCommentAnchor(record = {}) {
+  const anchorKind = normalizeAnchorKind(record.anchorKind);
+  const anchorStart = asObject(record.anchorStart);
+  const anchorEnd = asObject(record.anchorEnd);
+  const anchorStartLine = asFiniteNumber(record.anchorStartLine);
+  const anchorEndLine = asFiniteNumber(record.anchorEndLine);
+  const anchorQuote = normalizeCommentQuote(record.anchorQuote);
+
+  if (!anchorKind || !anchorStart || !anchorEnd || anchorStartLine === null || anchorEndLine === null) {
+    return null;
+  }
+
+  return {
+    anchorEnd,
+    anchorEndLine: Math.max(anchorEndLine, anchorStartLine),
+    anchorKind,
+    anchorQuote,
+    anchorStart,
+    anchorStartLine: Math.max(anchorStartLine, 1),
+  };
+}
+
+export function createCommentThreadSharedType(record = {}) {
+  if (asFiniteNumber(record.resolvedAt) !== null) {
+    return null;
+  }
+
+  const anchor = normalizeCommentAnchor(record);
+  const initialMessage = createMessageRecord(record.messages?.[0]);
+  if (!anchor || !initialMessage) {
+    return null;
+  }
+
+  const messages = new Y.Array();
+  const normalizedMessages = record.messages
+    ?.map((message) => createMessageRecord(message))
+    .filter(Boolean) ?? [];
+
+  messages.push(normalizedMessages.length > 0 ? normalizedMessages : [initialMessage]);
+
+  const thread = new Y.Map();
+  thread.set('anchorEnd', anchor.anchorEnd);
+  thread.set('anchorEndLine', anchor.anchorEndLine);
+  thread.set('anchorKind', anchor.anchorKind);
+  thread.set('anchorQuote', anchor.anchorQuote);
+  thread.set('anchorStart', anchor.anchorStart);
+  thread.set('anchorStartLine', anchor.anchorStartLine);
+  thread.set('createdAt', asFiniteNumber(record.createdAt) ?? Date.now());
+  thread.set('createdByColor', asString(record.createdByColor));
+  thread.set('createdByName', asString(record.createdByName) || initialMessage.userName);
+  thread.set('createdByPeerId', asString(record.createdByPeerId) || initialMessage.peerId);
+  thread.set('id', asString(record.id) || createCommentId('thread'));
+  thread.set('messages', messages);
+  thread.set('resolvedAt', asFiniteNumber(record.resolvedAt));
+  thread.set('resolvedByColor', asString(record.resolvedByColor));
+  thread.set('resolvedByName', asString(record.resolvedByName));
+  thread.set('resolvedByPeerId', asString(record.resolvedByPeerId));
+  return thread;
+}
+
+export function serializeCommentThread(thread) {
+  if (isResolvedThread(thread)) {
+    return null;
+  }
+
+  const anchor = normalizeCommentAnchor({
+    anchorEnd: readThreadValue(thread, 'anchorEnd'),
+    anchorEndLine: readThreadValue(thread, 'anchorEndLine'),
+    anchorKind: readThreadValue(thread, 'anchorKind'),
+    anchorQuote: readThreadValue(thread, 'anchorQuote'),
+    anchorStart: readThreadValue(thread, 'anchorStart'),
+    anchorStartLine: readThreadValue(thread, 'anchorStartLine'),
+  });
+  const messages = serializeMessages(readThreadValue(thread, 'messages'));
+
+  if (!anchor || messages.length === 0) {
+    return null;
+  }
+
+  return {
+    ...anchor,
+    createdAt: asFiniteNumber(readThreadValue(thread, 'createdAt')) ?? messages[0].createdAt,
+    createdByColor: asString(readThreadValue(thread, 'createdByColor')) || messages[0].userColor,
+    createdByName: asString(readThreadValue(thread, 'createdByName')) || messages[0].userName,
+    createdByPeerId: asString(readThreadValue(thread, 'createdByPeerId')) || messages[0].peerId,
+    id: asString(readThreadValue(thread, 'id')) || createCommentId('thread'),
+    messages,
+    resolvedAt: asFiniteNumber(readThreadValue(thread, 'resolvedAt')),
+    resolvedByColor: asString(readThreadValue(thread, 'resolvedByColor')),
+    resolvedByName: asString(readThreadValue(thread, 'resolvedByName')),
+    resolvedByPeerId: asString(readThreadValue(thread, 'resolvedByPeerId')),
+  };
+}
+
+export function serializeCommentThreads(source) {
+  const items = source instanceof Y.Array
+    ? source.toArray()
+    : Array.isArray(source)
+      ? source
+      : [];
+
+  return items
+    .map((thread) => serializeCommentThread(thread))
+    .filter(Boolean);
+}
+
+export function populateCommentThreads(sharedArray, records = []) {
+  if (!(sharedArray instanceof Y.Array) || !Array.isArray(records) || records.length === 0) {
+    return;
+  }
+
+  const threads = records
+    .map((record) => createCommentThreadSharedType(record))
+    .filter(Boolean);
+
+  if (threads.length > 0) {
+    sharedArray.push(threads);
+  }
+}

package/src/domain/excalidraw-room-codec.js

@@ -0,0 +1,427 @@
+import * as Y from 'yjs';
+
+const EXCALIDRAW_TYPE = 'excalidraw';
+const EXCALIDRAW_VERSION = 2;
+const EXCALIDRAW_SOURCE = 'collabmd';
+
+export const EXCALIDRAW_APP_STATE_KEY = 'excalidraw-app-state';
+export const EXCALIDRAW_ELEMENTS_KEY = 'excalidraw-elements';
+export const EXCALIDRAW_FILES_KEY = 'excalidraw-files';
+export const EXCALIDRAW_META_KEY = 'excalidraw-meta';
+export const EXCALIDRAW_ROOM_SCHEMA_VERSION = 1;
+export const EXCALIDRAW_ROOM_TEXT_KEY = 'codemirror';
+export const EXCALIDRAW_SCHEMA_VERSION_KEY = 'schemaVersion';
+
+function createEmptyScene() {
+  return {
+    type: EXCALIDRAW_TYPE,
+    version: EXCALIDRAW_VERSION,
+    source: EXCALIDRAW_SOURCE,
+    elements: [],
+    appState: {
+      gridSize: null,
+      viewBackgroundColor: '#ffffff',
+    },
+    files: {},
+  };
+}
+
+function normalizeAppState(appState = {}) {
+  return {
+    gridSize: appState?.gridSize ?? null,
+    viewBackgroundColor: appState?.viewBackgroundColor ?? '#ffffff',
+  };
+}
+
+function normalizeScene(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return createEmptyScene();
+  }
+
+  return {
+    type: EXCALIDRAW_TYPE,
+    version: EXCALIDRAW_VERSION,
+    source: EXCALIDRAW_SOURCE,
+    elements: Array.isArray(raw.elements) ? raw.elements : [],
+    appState: normalizeAppState(raw.appState),
+    files: raw.files && typeof raw.files === 'object' ? raw.files : {},
+  };
+}
+
+function parseSceneJson(rawJson, { fallbackToEmpty = true } = {}) {
+  if (!rawJson) {
+    return fallbackToEmpty ? createEmptyScene() : null;
+  }
+
+  try {
+    return normalizeScene(JSON.parse(rawJson));
+  } catch {
+    return fallbackToEmpty ? createEmptyScene() : null;
+  }
+}
+
+function cloneJsonValue(value) {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  return JSON.parse(JSON.stringify(value));
+}
+
+function getRevisionKey(element) {
+  const version = Number.isFinite(Number(element?.version)) ? Number(element.version) : 0;
+  const versionNonce = Number.isFinite(Number(element?.versionNonce)) ? Number(element.versionNonce) : 0;
+  const updated = Number.isFinite(Number(element?.updated)) ? Number(element.updated) : 0;
+  return `${version}:${versionNonce}:${updated}`;
+}
+
+function compareElementVersions(left, right) {
+  const leftVersion = Number(left?.version) || 0;
+  const rightVersion = Number(right?.version) || 0;
+  if (leftVersion !== rightVersion) {
+    return leftVersion - rightVersion;
+  }
+
+  const leftVersionNonce = Number(left?.versionNonce) || 0;
+  const rightVersionNonce = Number(right?.versionNonce) || 0;
+  if (leftVersionNonce !== rightVersionNonce) {
+    return leftVersionNonce - rightVersionNonce;
+  }
+
+  const leftUpdated = Number(left?.updated) || 0;
+  const rightUpdated = Number(right?.updated) || 0;
+  if (leftUpdated !== rightUpdated) {
+    return leftUpdated - rightUpdated;
+  }
+
+  return String(left?.id || '').localeCompare(String(right?.id || ''));
+}
+
+function compareElementIndex(left, right) {
+  const leftIndex = left?.index ?? '';
+  const rightIndex = right?.index ?? '';
+  if (leftIndex !== rightIndex) {
+    return String(leftIndex).localeCompare(String(rightIndex));
+  }
+
+  return String(left?.id || '').localeCompare(String(right?.id || ''));
+}
+
+function getNestedMapValue(map, key, { create = false } = {}) {
+  const existing = map.get(key);
+  if (existing instanceof Y.Map) {
+    return existing;
+  }
+
+  if (!create) {
+    return null;
+  }
+
+  const nested = new Y.Map();
+  map.set(key, nested);
+  return nested;
+}
+
+function readRevisionEntry(entryValue) {
+  if (typeof entryValue === 'string') {
+    try {
+      return JSON.parse(entryValue);
+    } catch {
+      return null;
+    }
+  }
+
+  if (!entryValue || typeof entryValue !== 'object') {
+    return null;
+  }
+
+  return cloneJsonValue(entryValue);
+}
+
+function selectWinningElementFromSlot(slot) {
+  if (!(slot instanceof Y.Map) || slot.size === 0) {
+    return null;
+  }
+
+  let winningElement = null;
+  slot.forEach((value) => {
+    const candidate = readRevisionEntry(value);
+    if (!candidate || !candidate.id) {
+      return;
+    }
+
+    if (!winningElement || compareElementVersions(candidate, winningElement) > 0) {
+      winningElement = candidate;
+    }
+  });
+
+  return winningElement;
+}
+
+function writeElementSlot(slot, element, {
+  maxRevisions = 2,
+} = {}) {
+  const revisionKey = getRevisionKey(element);
+  const serialized = cloneJsonValue(element);
+  const previous = slot.get(revisionKey);
+  const previousSerialized = previous && typeof previous === 'object'
+    ? JSON.stringify(previous)
+    : '';
+  const nextSerialized = JSON.stringify(serialized);
+  if (previousSerialized === nextSerialized) {
+    return false;
+  }
+
+  slot.set(revisionKey, serialized);
+  pruneElementSlot(slot, maxRevisions);
+  return true;
+}
+
+function pruneElementSlot(slot, maxRevisions = 2) {
+  if (!(slot instanceof Y.Map) || slot.size <= maxRevisions) {
+    return;
+  }
+
+  const revisions = [];
+  slot.forEach((value, key) => {
+    const element = readRevisionEntry(value);
+    if (!element) {
+      revisions.push({ element: null, key });
+      return;
+    }
+
+    revisions.push({ element, key });
+  });
+
+  revisions.sort((left, right) => {
+    if (!left.element) {
+      return -1;
+    }
+    if (!right.element) {
+      return 1;
+    }
+    return compareElementVersions(left.element, right.element);
+  });
+
+  while (revisions.length > maxRevisions) {
+    const entry = revisions.shift();
+    if (entry?.key) {
+      slot.delete(entry.key);
+    }
+  }
+}
+
+function sortSceneElements(elements) {
+  return [...elements].sort(compareElementIndex);
+}
+
+export function isExcalidrawRoomDocStructured(ydoc) {
+  if (!ydoc) {
+    return false;
+  }
+
+  const meta = ydoc.getMap(EXCALIDRAW_META_KEY);
+  if (Number(meta.get(EXCALIDRAW_SCHEMA_VERSION_KEY)) === EXCALIDRAW_ROOM_SCHEMA_VERSION) {
+    return true;
+  }
+
+  return (
+    ydoc.getMap(EXCALIDRAW_ELEMENTS_KEY).size > 0
+    || ydoc.getMap(EXCALIDRAW_FILES_KEY).size > 0
+    || ydoc.getMap(EXCALIDRAW_APP_STATE_KEY).size > 0
+  );
+}
+
+export function ensureExcalidrawRoomSchema(ydoc) {
+  const meta = ydoc.getMap(EXCALIDRAW_META_KEY);
+  if (Number(meta.get(EXCALIDRAW_SCHEMA_VERSION_KEY)) !== EXCALIDRAW_ROOM_SCHEMA_VERSION) {
+    meta.set(EXCALIDRAW_SCHEMA_VERSION_KEY, EXCALIDRAW_ROOM_SCHEMA_VERSION);
+  }
+
+  return meta;
+}
+
+export function buildExcalidrawRoomScene(ydoc, {
+  includeDeleted = true,
+} = {}) {
+  if (!ydoc) {
+    return createEmptyScene();
+  }
+
+  const elementsMap = ydoc.getMap(EXCALIDRAW_ELEMENTS_KEY);
+  const filesMap = ydoc.getMap(EXCALIDRAW_FILES_KEY);
+  const appStateMap = ydoc.getMap(EXCALIDRAW_APP_STATE_KEY);
+
+  const elements = [];
+  elementsMap.forEach((value) => {
+    const winningElement = selectWinningElementFromSlot(value);
+    if (!winningElement) {
+      return;
+    }
+
+    if (!includeDeleted && winningElement.isDeleted) {
+      return;
+    }
+
+    elements.push(winningElement);
+  });
+
+  const files = {};
+  filesMap.forEach((value, key) => {
+    if (!value || typeof value !== 'object') {
+      return;
+    }
+
+    files[key] = cloneJsonValue(value);
+  });
+
+  const scene = normalizeScene({
+    appState: {
+      gridSize: appStateMap.get('gridSize'),
+      viewBackgroundColor: appStateMap.get('viewBackgroundColor'),
+    },
+    elements: sortSceneElements(elements),
+    files,
+  });
+
+  return scene;
+}
+
+export function serializeExcalidrawRoomScene(ydoc, {
+  includeDeleted = false,
+} = {}) {
+  const scene = buildExcalidrawRoomScene(ydoc, { includeDeleted });
+  if (!includeDeleted) {
+    scene.elements = scene.elements.filter((element) => !element.isDeleted);
+  }
+  return JSON.stringify(scene);
+}
+
+export function replaceExcalidrawRoomScene(ydoc, rawScene, {
+  maxRevisionsPerElement = 2,
+} = {}) {
+  if (!ydoc) {
+    return createEmptyScene();
+  }
+
+  const scene = normalizeScene(rawScene);
+  ensureExcalidrawRoomSchema(ydoc);
+
+  const elementsMap = ydoc.getMap(EXCALIDRAW_ELEMENTS_KEY);
+  const filesMap = ydoc.getMap(EXCALIDRAW_FILES_KEY);
+  const appStateMap = ydoc.getMap(EXCALIDRAW_APP_STATE_KEY);
+
+  Array.from(elementsMap.keys()).forEach((key) => elementsMap.delete(key));
+  Array.from(filesMap.keys()).forEach((key) => filesMap.delete(key));
+  Array.from(appStateMap.keys()).forEach((key) => appStateMap.delete(key));
+
+  scene.elements.forEach((element) => {
+    if (!element?.id) {
+      return;
+    }
+
+    const slot = getNestedMapValue(elementsMap, element.id, { create: true });
+    writeElementSlot(slot, element, { maxRevisions: maxRevisionsPerElement });
+  });
+
+  Object.entries(scene.files || {}).forEach(([key, value]) => {
+    filesMap.set(key, cloneJsonValue(value));
+  });
+
+  const nextAppState = normalizeAppState(scene.appState);
+  appStateMap.set('gridSize', nextAppState.gridSize);
+  appStateMap.set('viewBackgroundColor', nextAppState.viewBackgroundColor);
+
+  return scene;
+}
+
+export function applySceneDiffToExcalidrawRoom(ydoc, rawScene, {
+  maxRevisionsPerElement = 2,
+} = {}) {
+  if (!ydoc) {
+    return false;
+  }
+
+  const scene = normalizeScene(rawScene);
+  ensureExcalidrawRoomSchema(ydoc);
+
+  const elementsMap = ydoc.getMap(EXCALIDRAW_ELEMENTS_KEY);
+  const filesMap = ydoc.getMap(EXCALIDRAW_FILES_KEY);
+  const appStateMap = ydoc.getMap(EXCALIDRAW_APP_STATE_KEY);
+  const nextElementIds = new Set();
+  let changed = false;
+
+  scene.elements.forEach((element) => {
+    if (!element?.id) {
+      return;
+    }
+
+    nextElementIds.add(element.id);
+    const slot = getNestedMapValue(elementsMap, element.id, { create: true });
+    changed = writeElementSlot(slot, element, { maxRevisions: maxRevisionsPerElement }) || changed;
+  });
+
+  Array.from(elementsMap.keys()).forEach((key) => {
+    if (!nextElementIds.has(key)) {
+      elementsMap.delete(key);
+      changed = true;
+    }
+  });
+
+  const nextFiles = scene.files || {};
+  Object.entries(nextFiles).forEach(([key, value]) => {
+    const nextValue = cloneJsonValue(value);
+    const currentValue = filesMap.get(key);
+    if (JSON.stringify(currentValue) === JSON.stringify(nextValue)) {
+      return;
+    }
+
+    filesMap.set(key, nextValue);
+    changed = true;
+  });
+
+  Array.from(filesMap.keys()).forEach((key) => {
+    if (!(key in nextFiles)) {
+      filesMap.delete(key);
+      changed = true;
+    }
+  });
+
+  const nextAppState = normalizeAppState(scene.appState);
+  Object.entries(nextAppState).forEach(([key, value]) => {
+    if (appStateMap.get(key) === value) {
+      return;
+    }
+
+    appStateMap.set(key, value);
+    changed = true;
+  });
+
+  Array.from(appStateMap.keys()).forEach((key) => {
+    if (!(key in nextAppState)) {
+      appStateMap.delete(key);
+      changed = true;
+    }
+  });
+
+  return changed;
+}
+
+export function readLegacyExcalidrawRoomScene(ydoc) {
+  if (!ydoc) {
+    return null;
+  }
+
+  const rawJson = ydoc.getText(EXCALIDRAW_ROOM_TEXT_KEY).toString();
+  return parseSceneJson(rawJson, { fallbackToEmpty: false });
+}
+
+export function migrateLegacyExcalidrawRoomData(ydoc, rawScene, options = {}) {
+  const scene = normalizeScene(rawScene);
+  replaceExcalidrawRoomScene(ydoc, scene, options);
+  return scene;
+}
+
+export function tryParseExcalidrawSceneJson(rawJson) {
+  return parseSceneJson(rawJson, { fallbackToEmpty: false });
+}