betterstart-cli 0.0.1

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

@@ -0,0 +1,316 @@
+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 = [
+  'gray',
+  'brown',
+  'orange',
+  'yellow',
+  'green',
+  'blue',
+  'purple',
+  'pink',
+  'red'
+] as const
+
+export type ContentEditorHighlightColor = (typeof CONTENT_EDITOR_HIGHLIGHT_COLORS)[number]
+
+export const CONTENT_EDITOR_HIGHLIGHT_COLOR_VALUES: Record<ContentEditorHighlightColor, string> = {
+  gray: 'var(--tt-color-highlight-gray)',
+  brown: 'var(--tt-color-highlight-brown)',
+  orange: 'var(--tt-color-highlight-orange)',
+  yellow: 'var(--tt-color-highlight-yellow)',
+  green: 'var(--tt-color-highlight-green)',
+  blue: 'var(--tt-color-highlight-blue)',
+  purple: 'var(--tt-color-highlight-purple)',
+  pink: 'var(--tt-color-highlight-pink)',
+  red: 'var(--tt-color-highlight-red)'
+}
+
+const HIGHLIGHT_VALUE_NAMES = new Map(
+  Object.entries(CONTENT_EDITOR_HIGHLIGHT_COLOR_VALUES).map(([name, value]) => [value, name])
+)
+
+export function getContentEditorHighlightColorName(
+  value: string | null | undefined
+): ContentEditorHighlightColor {
+  if (!value) return 'yellow'
+
+  const normalized = value.trim()
+  const variableMatch = normalized.match(/var\((--tt-color-highlight-[^)]+)\)/)
+  const variableName = variableMatch ? `var(${variableMatch[1]})` : normalized
+  const mapped = HIGHLIGHT_VALUE_NAMES.get(variableName)
+
+  if (mapped && isContentEditorHighlightColor(mapped)) {
+    return mapped
+  }
+
+  const cssVariableMatch = normalized.match(
+    /--tt-color-highlight-(gray|brown|orange|yellow|green|blue|purple|pink|red)/
+  )
+  if (cssVariableMatch && isContentEditorHighlightColor(cssVariableMatch[1])) {
+    return cssVariableMatch[1]
+  }
+
+  if (isContentEditorHighlightColor(normalized)) {
+    return normalized
+  }
+
+  return 'yellow'
+}
+
+export function getContentEditorHighlightColorValue(color: ContentEditorHighlightColor): string {
+  return CONTENT_EDITOR_HIGHLIGHT_COLOR_VALUES[color]
+}
+
+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
+}
+
+function matchHtmlMarkSyntax(markdown: string, index: number): number | null {
+  const remaining = markdown.slice(index)
+  const match =
+    /^<\/?(?:u|sub|sup|kbd)>/i.exec(remaining) ??
+    /^<span\s+data-highlight-color="(?:gray|brown|orange|yellow|green|blue|purple|pink|red)">/i.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))
+}

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

@@ -0,0 +1,19 @@
+import type { Editor } from '@tiptap/core'
+
+type MountedEditorView = Editor['view']
+
+export function getMountedEditorView(editor: Editor | null): MountedEditorView | null {
+  if (!editor || editor.isDestroyed || typeof HTMLElement === 'undefined') return null
+
+  try {
+    const view = editor.view
+    const { dom } = view
+    return dom instanceof HTMLElement && !view.isDestroyed ? view : null
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('The editor view is not available')) {
+      return null
+    }
+
+    throw error
+  }
+}