betterstart-cli 0.0.99 → 0.0.101

package/dist/assets/adapters/next/templates/init/utils/editor/content-editor.ts

@@ -1,389 +0,0 @@
-import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
-import { TextSelection } from '@tiptap/pm/state'
-
-export type ContentEditorMode = 'rich' | 'source'
-
-export interface ContentEditorSelectionRequest {
-  id: number
-  offset: number
-}
-
-export const CONTENT_EDITOR_HIGHLIGHT_COLORS = [
-  'default',
-  'gray',
-  'brown',
-  'orange',
-  'yellow',
-  'green',
-  'blue',
-  'purple',
-  'pink',
-  'red'
-] as const
-
-export type ContentEditorHighlightColor = (typeof CONTENT_EDITOR_HIGHLIGHT_COLORS)[number]
-
-export interface ContentEditorHighlightColorOption {
-  label: string
-  value: string
-  colorValue: string
-  border: string
-}
-
-export const CONTENT_EDITOR_HIGHLIGHT_COLOR_OPTIONS: Record<
-  ContentEditorHighlightColor,
-  ContentEditorHighlightColorOption
-> = {
-  default: {
-    label: 'Default background',
-    value: 'var(--tt-bg-color)',
-    colorValue: '#ffffff',
-    border: 'var(--tt-bg-color-contrast)'
-  },
-  gray: {
-    label: 'Gray background',
-    value: 'var(--tt-color-highlight-gray)',
-    colorValue: '#f8f8f7',
-    border: 'var(--tt-color-highlight-gray-contrast)'
-  },
-  brown: {
-    label: 'Brown background',
-    value: 'var(--tt-color-highlight-brown)',
-    colorValue: '#f4eeee',
-    border: 'var(--tt-color-highlight-brown-contrast)'
-  },
-  orange: {
-    label: 'Orange background',
-    value: 'var(--tt-color-highlight-orange)',
-    colorValue: '#fbecdd',
-    border: 'var(--tt-color-highlight-orange-contrast)'
-  },
-  yellow: {
-    label: 'Yellow background',
-    value: 'var(--tt-color-highlight-yellow)',
-    colorValue: '#fef9c3',
-    border: 'var(--tt-color-highlight-yellow-contrast)'
-  },
-  green: {
-    label: 'Green background',
-    value: 'var(--tt-color-highlight-green)',
-    colorValue: '#dcfce7',
-    border: 'var(--tt-color-highlight-green-contrast)'
-  },
-  blue: {
-    label: 'Blue background',
-    value: 'var(--tt-color-highlight-blue)',
-    colorValue: '#e0f2fe',
-    border: 'var(--tt-color-highlight-blue-contrast)'
-  },
-  purple: {
-    label: 'Purple background',
-    value: 'var(--tt-color-highlight-purple)',
-    colorValue: '#f3e8ff',
-    border: 'var(--tt-color-highlight-purple-contrast)'
-  },
-  pink: {
-    label: 'Pink background',
-    value: 'var(--tt-color-highlight-pink)',
-    colorValue: '#fcf1f6',
-    border: 'var(--tt-color-highlight-pink-contrast)'
-  },
-  red: {
-    label: 'Red background',
-    value: 'var(--tt-color-highlight-red)',
-    colorValue: '#ffe4e6',
-    border: 'var(--tt-color-highlight-red-contrast)'
-  }
-}
-
-export const CONTENT_EDITOR_HIGHLIGHT_COLOR_NAME_PATTERN = CONTENT_EDITOR_HIGHLIGHT_COLORS.join('|')
-
-const HIGHLIGHT_NAMES_BY_VALUE = new Map(
-  CONTENT_EDITOR_HIGHLIGHT_COLORS.map(
-    (name) => [CONTENT_EDITOR_HIGHLIGHT_COLOR_OPTIONS[name].value, name] as const
-  )
-)
-
-const HIGHLIGHT_NAMES_BY_CSS_VARIABLE = new Map(
-  CONTENT_EDITOR_HIGHLIGHT_COLORS.map(
-    (name) =>
-      [CONTENT_EDITOR_HIGHLIGHT_COLOR_OPTIONS[name].value.slice('var('.length, -1), name] as const
-  )
-)
-
-export function getContentEditorHighlightColorName(
-  value: string | null | undefined
-): ContentEditorHighlightColor {
-  if (!value) return 'yellow'
-
-  const normalized = value.trim()
-  const mapped = HIGHLIGHT_NAMES_BY_VALUE.get(normalized)
-
-  if (mapped) {
-    return mapped
-  }
-
-  for (const [cssVariable, name] of HIGHLIGHT_NAMES_BY_CSS_VARIABLE) {
-    if (normalized.includes(cssVariable)) {
-      return name
-    }
-  }
-
-  if (isContentEditorHighlightColor(normalized)) {
-    return normalized
-  }
-
-  return 'yellow'
-}
-
-export function getContentEditorHighlightColorValue(color: ContentEditorHighlightColor): string {
-  return CONTENT_EDITOR_HIGHLIGHT_COLOR_OPTIONS[color].value
-}
-
-export function isContentEditorHighlightColor(value: string): value is ContentEditorHighlightColor {
-  return CONTENT_EDITOR_HIGHLIGHT_COLORS.includes(value as ContentEditorHighlightColor)
-}
-
-export function normalizeEditorMarkdown(markdown: string): string {
-  return markdown.trim()
-}
-
-export function prepareMarkdownForRichMode(markdown: string): string {
-  return markdown
-}
-
-export function getPlainTextOffsetBeforeMarkdownOffset(
-  markdown: string,
-  markdownOffset: number
-): number {
-  const offsetMap = createMarkdownPlainTextOffsetMap(markdown)
-  const safeOffset = Math.max(0, Math.min(markdownOffset, markdown.length))
-
-  return offsetMap.markdownToPlainOffsets[safeOffset] ?? 0
-}
-
-export function markdownOffsetFromPlainTextOffset(markdown: string, textOffset: number): number {
-  const offsetMap = createMarkdownPlainTextOffsetMap(markdown)
-  const safeOffset = Math.max(0, Math.min(textOffset, offsetMap.plainToMarkdownOffsets.length - 1))
-
-  return offsetMap.plainToMarkdownOffsets[safeOffset] ?? markdown.length
-}
-
-export function getPlainTextOffsetBeforeDocPosition(
-  doc: ProseMirrorNode,
-  position: number
-): number {
-  return doc.textBetween(0, position, '\n', '\ufffc').length
-}
-
-export function docPositionFromPlainTextOffset(doc: ProseMirrorNode, textOffset: number): number {
-  const minPosition = TextSelection.atStart(doc).from
-  const maxPosition = TextSelection.atEnd(doc).to
-  const safeOffset = Math.max(0, textOffset)
-
-  if (safeOffset === 0) return minPosition
-
-  let low = minPosition
-  let high = maxPosition
-
-  while (low < high) {
-    const midpoint = Math.floor((low + high) / 2)
-    const currentOffset = getPlainTextOffsetBeforeDocPosition(doc, midpoint)
-
-    if (currentOffset < safeOffset) {
-      low = midpoint + 1
-    } else {
-      high = midpoint
-    }
-  }
-
-  return Math.max(minPosition, Math.min(low, maxPosition))
-}
-
-interface MarkdownPlainTextOffsetMap {
-  markdownToPlainOffsets: number[]
-  plainToMarkdownOffsets: number[]
-}
-
-function createMarkdownPlainTextOffsetMap(markdown: string): MarkdownPlainTextOffsetMap {
-  const markdownToPlainOffsets = new Array<number>(markdown.length + 1).fill(0)
-  const plainToMarkdownOffsets = [0]
-  let index = 0
-  let plainOffset = 0
-
-  const skipUntil = (nextIndex: number) => {
-    const safeNextIndex = Math.max(index, Math.min(nextIndex, markdown.length))
-
-    while (index < safeNextIndex) {
-      markdownToPlainOffsets[index] = plainOffset
-      index++
-      markdownToPlainOffsets[index] = plainOffset
-    }
-  }
-
-  const consumeVisibleUntil = (nextIndex: number) => {
-    const safeNextIndex = Math.max(index, Math.min(nextIndex, markdown.length))
-
-    while (index < safeNextIndex) {
-      consumeVisibleCharacter()
-    }
-  }
-
-  const consumeVisibleCharacter = () => {
-    const character = markdown[index]
-
-    if (character === '\r') {
-      skipUntil(index + 1)
-      return
-    }
-
-    if (character === '\n') {
-      const runStart = index
-      let runEnd = index + 1
-
-      while (runEnd < markdown.length && markdown[runEnd] === '\n') {
-        runEnd++
-      }
-
-      markdownToPlainOffsets[runStart] = plainOffset
-      plainOffset++
-      plainToMarkdownOffsets[plainOffset] = runEnd
-
-      for (let offset = runStart + 1; offset <= runEnd; offset++) {
-        markdownToPlainOffsets[offset] = plainOffset
-      }
-
-      index = runEnd
-      return
-    }
-
-    markdownToPlainOffsets[index] = plainOffset
-    plainOffset++
-    index++
-    plainToMarkdownOffsets[plainOffset] = index
-    markdownToPlainOffsets[index] = plainOffset
-  }
-
-  while (index < markdown.length) {
-    const imageMatch = /^!\[([^\]]*)\]\([^)]+\)/.exec(markdown.slice(index))
-    if (imageMatch) {
-      const textStart = index + 2
-      const textEnd = textStart + imageMatch[1].length
-      skipUntil(textStart)
-      consumeVisibleUntil(textEnd)
-      skipUntil(index + imageMatch[0].length)
-      continue
-    }
-
-    const linkMatch = /^\[([^\]]+)\]\([^)]+\)/.exec(markdown.slice(index))
-    if (linkMatch) {
-      const textStart = index + 1
-      const textEnd = textStart + linkMatch[1].length
-      skipUntil(textStart)
-      consumeVisibleUntil(textEnd)
-      skipUntil(index + linkMatch[0].length)
-      continue
-    }
-
-    const codeFenceEnd = matchCodeFenceStart(markdown, index)
-    if (codeFenceEnd !== null) {
-      skipUntil(codeFenceEnd)
-      continue
-    }
-
-    const blockPrefixEnd = matchMarkdownBlockPrefix(markdown, index)
-    if (blockPrefixEnd !== null) {
-      skipUntil(blockPrefixEnd)
-      continue
-    }
-
-    const markSyntaxEnd = matchMarkdownMarkSyntax(markdown, index)
-    if (markSyntaxEnd !== null) {
-      skipUntil(markSyntaxEnd)
-      continue
-    }
-
-    const htmlMarkSyntaxEnd = matchHtmlMarkSyntax(markdown, index)
-    if (htmlMarkSyntaxEnd !== null) {
-      skipUntil(htmlMarkSyntaxEnd)
-      continue
-    }
-
-    if (markdown[index] === '\\' && index + 1 < markdown.length) {
-      skipUntil(index + 1)
-      consumeVisibleCharacter()
-      continue
-    }
-
-    consumeVisibleCharacter()
-  }
-
-  markdownToPlainOffsets[markdown.length] = plainOffset
-  return { markdownToPlainOffsets, plainToMarkdownOffsets }
-}
-
-function matchCodeFenceStart(markdown: string, index: number): number | null {
-  if (!isMarkdownLineStart(markdown, index)) return null
-
-  const match = /^```[^\n]*(?:\n|$)/.exec(markdown.slice(index))
-  return match ? index + match[0].length : null
-}
-
-function matchMarkdownBlockPrefix(markdown: string, index: number): number | null {
-  if (!isMarkdownLineStart(markdown, index)) return null
-
-  const match = /^(?: {0,3}(?:#{1,6}\s+|>\s?|[-*+]\s+\[[ xX]\]\s+|[-*+]\s+|\d+[.)]\s+))/.exec(
-    markdown.slice(index)
-  )
-
-  return match ? index + match[0].length : null
-}
-
-function matchMarkdownMarkSyntax(markdown: string, index: number): number | null {
-  const character = markdown[index]
-  const nextCharacter = markdown[index + 1]
-  const previousCharacter = markdown[index - 1]
-
-  if (character === '`') {
-    const match = /^`+/.exec(markdown.slice(index))
-    return match ? index + match[0].length : null
-  }
-
-  if (character === '*' || character === '~') {
-    const match = new RegExp(`^\\${character}+`).exec(markdown.slice(index))
-    return match ? index + Math.min(match[0].length, 2) : null
-  }
-
-  if (
-    character === '_' &&
-    !(isWordCharacter(previousCharacter) && isWordCharacter(nextCharacter))
-  ) {
-    const match = /^_+/.exec(markdown.slice(index))
-    return match ? index + Math.min(match[0].length, 2) : null
-  }
-
-  return null
-}
-
-const HIGHLIGHT_SPAN_OPEN_PATTERN = new RegExp(
-  `^<span\\s+data-highlight-color="(?:${CONTENT_EDITOR_HIGHLIGHT_COLOR_NAME_PATTERN})">`,
-  'i'
-)
-
-function matchHtmlMarkSyntax(markdown: string, index: number): number | null {
-  const remaining = markdown.slice(index)
-  const match =
-    /^<\/?(?:u|sub|sup|kbd)>/i.exec(remaining) ??
-    HIGHLIGHT_SPAN_OPEN_PATTERN.exec(remaining) ??
-    /^<\/span>/i.exec(remaining)
-
-  return match ? index + match[0].length : null
-}
-
-function isMarkdownLineStart(markdown: string, index: number): boolean {
-  return index === 0 || markdown[index - 1] === '\n'
-}
-
-function isWordCharacter(character: string | undefined): boolean {
-  return Boolean(character && /\w/.test(character))
-}