@aleph-alpha/chat-kit 3.1.3 → 3.3.0

package/src/helpers/unified/remarkNormalizeMath.ts

@@ -0,0 +1,134 @@
+import type { Plugin } from 'unified';
+
+const PLACEHOLDER_PREFIX = '\uE000PH_';
+const PLACEHOLDER_SUFFIX = '\uE000';
+const PLACEHOLDER_RE = /\uE000PH_(\d+)\uE000/g;
+
+const FENCE_START_RE = /^[ \t]{0,3}(`{3,}|~{3,})/;
+const INLINE_CODE_RE = /`[^`\n]+`/g;
+
+const LATEX_BLOCK_RE = /\\\[([\s\S]+?)\\\]/g;
+const LATEX_INLINE_RE = /\\\(([^\n]+?)\\\)/g;
+const SINGLE_LINE_DOUBLE_DOLLAR_RE = /\$\$([^\n$]+?)\$\$/g;
+
+type Stash = (value: string) => string;
+
+function isClosingFence(
+  line: string,
+  fenceChar: string,
+  minLen: number,
+): boolean {
+  let i = 0;
+  let indent = 0;
+  while (
+    i < line.length &&
+    (line[i] === ' ' || line[i] === '\t') &&
+    indent < 4
+  ) {
+    indent++;
+    i++;
+  }
+  if (indent >= 4) return false;
+  let runLen = 0;
+  while (i < line.length && line[i] === fenceChar) {
+    runLen++;
+    i++;
+  }
+  if (runLen < minLen) return false;
+  while (i < line.length) {
+    if (line[i] !== ' ' && line[i] !== '\t') return false;
+    i++;
+  }
+  return true;
+}
+
+/**
+ * Walk the source line-by-line and stash fenced code blocks (```/~~~) so
+ * their contents are not rewritten by subsequent math regexes. A line-based
+ * scanner avoids the catastrophic-backtracking risk of a single regex over the
+ * whole document.
+ */
+function protectFencedCode(input: string, stash: Stash): string {
+  const lines = input.split('\n');
+  const out: string[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    const match = FENCE_START_RE.exec(lines[i]);
+    if (match) {
+      const fence = match[1];
+      const fenceChar = fence[0];
+      const minLen = fence.length;
+      const block: string[] = [lines[i]];
+      i++;
+      while (i < lines.length) {
+        const current = lines[i];
+        block.push(current);
+        i++;
+        if (isClosingFence(current, fenceChar, minLen)) break;
+      }
+      out.push(stash(block.join('\n')));
+    } else {
+      out.push(lines[i]);
+      i++;
+    }
+  }
+  return out.join('\n');
+}
+
+/**
+ * Normalize math delimiters in a markdown source string so they survive
+ * `remark-math`'s CommonMark-style parsing:
+ *
+ * - LaTeX-style block delimiters `\[ ... \]` become a fenced `$$ ... $$` block.
+ * - LaTeX-style inline delimiters `\( ... \)` become inline `$ ... $`.
+ * - Single-line `$$ ... $$` (which `remark-math` treats as inline math)
+ *   is promoted to a proper block math fence on its own lines.
+ *
+ * Content inside fenced (``` / ~~~) or inline (`) code spans is preserved
+ * verbatim and is not subject to any of these rewrites.
+ */
+export function normalizeMathDelimiters(input: string): string {
+  if (!input) return input;
+
+  const placeholders: string[] = [];
+  const stash: Stash = (value) => {
+    const id = placeholders.length;
+    placeholders.push(value);
+    return `${PLACEHOLDER_PREFIX}${id}${PLACEHOLDER_SUFFIX}`;
+  };
+
+  let s = protectFencedCode(input, stash);
+  s = s.replace(INLINE_CODE_RE, stash);
+
+  s = s.replace(
+    LATEX_BLOCK_RE,
+    (_m, body: string) => `\n\n$$\n${body.trim()}\n$$\n\n`,
+  );
+  s = s.replace(LATEX_INLINE_RE, (_m, body: string) => `$${body.trim()}$`);
+  s = s.replace(
+    SINGLE_LINE_DOUBLE_DOLLAR_RE,
+    (_m, body: string) => `\n\n$$\n${body.trim()}\n$$\n\n`,
+  );
+
+  s = s.replace(PLACEHOLDER_RE, (_m, id: string) => placeholders[Number(id)]);
+  return s;
+}
+
+type ParserLike = (document: string, file: unknown) => unknown;
+
+/**
+ * Unified plugin that wraps `this.parser` so the markdown source is run
+ * through {@link normalizeMathDelimiters} before parsing.
+ *
+ * Register this plugin *after* `remark-parse`, otherwise `this.parser` is not
+ * yet defined when the plugin is invoked at freeze time and the wrap is a
+ * no-op.
+ */
+export const remarkNormalizeMath: Plugin<[]> = function () {
+  const processor = this as unknown as { parser?: ParserLike };
+  const originalParser = processor.parser;
+  if (typeof originalParser !== 'function') return;
+
+  processor.parser = (document, file) =>
+    originalParser(normalizeMathDelimiters(document), file);
+};

package/src/index.ts

@@ -63,6 +63,8 @@ export type {
 // Components
 export {
   CkAgentMessage,
+  CkCitation,
+  CkCitationCard,
   CkConversation,
   CkConversationLayout,
   CkCopyMessageActionButton,
@@ -87,6 +89,11 @@ export {
   CkUserMessage,
 } from './components';
 export type {
+  CkCitationProps,
+  CkCitationEmits,
+  CkCitationSource,
+  CkCitationCardProps,
+  CkCitationCardEmits,
   CkConversationLayoutProps,
   CkConversationProps,
   CkDropZoneOverlayProps,
@@ -110,6 +117,7 @@ export type {
   CkHistoryWrapperProps,
   CkMarkdownElementClasses,
   CkMarkdownRendererProps,
+  CkMarkdownRendererEmits,
   CkModelOption,
   CkModelSelectorProps,
   CkModelSelectorEmits,