betterstart-cli 0.0.99 → 0.0.101

package/dist/assets/adapters/next/templates/init/utils/editor/get-plain-text-offset-before-markdown-offset.ts

@@ -0,0 +1,11 @@
+import { createMarkdownPlainTextOffsetMap } from '@admin/utils/editor/create-markdown-plain-text-offset-map'
+
+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
+}

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

@@ -0,0 +1,7 @@
+'use client'
+
+import type { RawContentKind } from '@admin/utils/editor/raw-content-kind'
+
+export function getRawContentKind(value: unknown): RawContentKind {
+  return value === 'math' ? value : 'html'
+}

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

@@ -0,0 +1,13 @@
+'use client'
+
+interface RawContentToken {
+  raw?: string
+  text?: string
+  delimiter?: string
+  kind?: string
+}
+
+export function getRawContentToken(token: unknown): RawContentToken {
+  if (!token || typeof token !== 'object') return {}
+  return token as RawContentToken
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-selected-block-nodes.ts

@@ -0,0 +1,23 @@
+import type { Node as PMNode } from '@tiptap/pm/model'
+import type { Editor } from '@tiptap/react'
+
+export function getSelectedBlockNodes(editor: Editor): PMNode[] {
+  const { doc } = editor.state
+  const { from, to } = editor.state.selection
+
+  const blocks: PMNode[] = []
+  const seen = new Set<number>()
+
+  doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isBlock) return
+
+    if (!seen.has(pos)) {
+      seen.add(pos)
+      blocks.push(node)
+    }
+
+    return false
+  })
+
+  return blocks
+}

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

@@ -0,0 +1,43 @@
+import type { ContentEditorSelectedMath } from '@admin/utils/editor/content-editor-selected-math'
+import type { Editor } from '@tiptap/react'
+import { NodeSelection } from '@tiptap/pm/state'
+
+export function getSelectedContentEditorMath(
+  editor: Editor | null
+): ContentEditorSelectedMath | null {
+  if (!editor) return null
+
+  const { selection } = editor.state
+  if (!(selection instanceof NodeSelection)) return null
+
+  const node = selection.node
+  const pos = selection.from
+
+  if (node.type.name === 'inlineMath') {
+    const raw = typeof node.attrs.raw === 'string' ? node.attrs.raw : ''
+    const delimiter = node.attrs.delimiter === '\\(' ? '\\(' : '$'
+
+    return {
+      delimiter,
+      kind: 'inline',
+      node,
+      pos,
+      raw,
+      value: raw
+    }
+  }
+
+  if (node.type.name === 'rawContentBlock' && node.attrs.kind === 'math') {
+    const raw = typeof node.attrs.raw === 'string' ? node.attrs.raw : ''
+
+    return {
+      kind: 'display',
+      node,
+      pos,
+      raw,
+      value: raw
+    }
+  }
+
+  return null
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-selected-nodes-of-type.ts

@@ -0,0 +1,50 @@
+import type { Node as PMNode } from '@tiptap/pm/model'
+import type { Selection } from '@tiptap/pm/state'
+import type { NodeWithPos } from '@tiptap/react'
+import { NodeSelection } from '@tiptap/pm/state'
+import { CellSelection, cellAround } from '@tiptap/pm/tables'
+import { findParentNodeClosestToPos } from '@tiptap/react'
+
+export function getSelectedNodesOfType(
+  selection: Selection,
+  allowedNodeTypes: string[]
+): NodeWithPos[] {
+  const results: NodeWithPos[] = []
+  const allowed = new Set(allowedNodeTypes)
+
+  if (selection instanceof CellSelection) {
+    selection.forEachCell((node: PMNode, pos: number) => {
+      if (allowed.has(node.type.name)) {
+        results.push({ node, pos })
+      }
+    })
+    return results
+  }
+
+  if (selection instanceof NodeSelection) {
+    const { node, from: pos } = selection
+    if (node && allowed.has(node.type.name)) {
+      results.push({ node, pos })
+    }
+    return results
+  }
+
+  const { $anchor } = selection
+  const cell = cellAround($anchor)
+
+  if (cell) {
+    const cellNode = selection.$anchor.doc.nodeAt(cell.pos)
+    if (cellNode && allowed.has(cellNode.type.name)) {
+      results.push({ node: cellNode, pos: cell.pos })
+      return results
+    }
+  }
+
+  const parentNode = findParentNodeClosestToPos($anchor, (node) => allowed.has(node.type.name))
+
+  if (parentNode) {
+    results.push({ node: parentNode.node, pos: parentNode.pos })
+  }
+
+  return results
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-selected-table-column-cell-positions.ts

@@ -0,0 +1,21 @@
+import type { Editor } from '@tiptap/react'
+import { selectedRect } from '@tiptap/pm/tables'
+
+export function getSelectedTableColumnCellPositions(editor: Editor): number[] {
+  if (!editor.isActive('table')) return []
+
+  try {
+    const rect = selectedRect(editor.state)
+    const columnIndex = rect.left
+    const cellPositions = rect.map.cellsInRect({
+      bottom: rect.map.height,
+      left: columnIndex,
+      right: columnIndex + 1,
+      top: 0
+    })
+
+    return [...new Set(cellPositions)].map((pos) => rect.tableStart + pos)
+  } catch {
+    return []
+  }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-selection-table-cell.ts

@@ -0,0 +1,10 @@
+import type { Editor } from '@tiptap/core'
+import { getClosestTableCell } from '@admin/utils/editor/get-closest-table-cell'
+import { getEditorElement } from '@admin/utils/editor/get-editor-element'
+
+export function getSelectionTableCell(editor: Editor) {
+  const selection = getEditorElement(editor)?.ownerDocument.getSelection()
+  const anchorNode = selection?.anchorNode
+
+  return getClosestTableCell(anchorNode ?? null)
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-selection-table-element.ts

@@ -0,0 +1,19 @@
+import type { Editor } from '@tiptap/core'
+import { getMountedEditorView } from '@admin/utils/editor/editor-view'
+import { getSelectionTableCell } from '@admin/utils/editor/get-selection-table-cell'
+import { findTable } from '@tiptap/pm/tables'
+
+export function getSelectionTableElement(editor: Editor) {
+  const view = getMountedEditorView(editor)
+  if (!view) return null
+
+  const table = findTable(editor.state.selection.$from)
+  if (!table) return getSelectionTableCell(editor)?.closest('table') ?? null
+
+  const tableDom = view.nodeDOM(table.pos)
+  if (tableDom instanceof HTMLTableElement) return tableDom
+  if (!(tableDom instanceof HTMLElement)) return null
+
+  const tableElement = tableDom.querySelector('table')
+  return tableElement instanceof HTMLTableElement ? tableElement : tableDom
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-selection-table.ts

@@ -0,0 +1,17 @@
+import type { MountedEditorView } from '@admin/utils/editor/mounted-editor-view'
+import type { Editor } from '@tiptap/react'
+import { getTableWrapperElement } from '@admin/utils/editor/get-table-wrapper-element'
+import { findTable } from '@tiptap/pm/tables'
+
+export function getSelectionTable(
+  editor: Editor,
+  view: MountedEditorView
+): { pos: number; wrapper: HTMLElement } | null {
+  const table = findTable(editor.state.selection.$from)
+  if (!table) return null
+
+  const wrapper = getTableWrapperElement(view.nodeDOM(table.pos))
+  if (!wrapper) return null
+
+  return { pos: table.pos, wrapper }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-slash-menu-state.ts

@@ -0,0 +1,47 @@
+import type { SlashMenuState } from '@admin/utils/editor/slash-menu-state'
+import type { Editor } from '@tiptap/react'
+
+const SLASH_QUERY_LIMIT = 48
+
+export function getSlashMenuState(editor: Editor): SlashMenuState | null {
+  const { selection } = editor.state
+
+  if (!selection.empty || !editor.isEditable) return null
+
+  const { $from } = selection
+  const parent = $from.parent
+
+  if (!parent.isTextblock || parent.type.name === 'codeBlock') return null
+
+  const textBeforeCursor = parent.textBetween(0, $from.parentOffset, '\n', '\ufffc')
+  const slashIndex = textBeforeCursor.lastIndexOf('/')
+
+  if (slashIndex === -1) return null
+  if (slashIndex > 0 && !/\s/.test(textBeforeCursor[slashIndex - 1])) {
+    return null
+  }
+
+  const query = textBeforeCursor.slice(slashIndex + 1)
+
+  if (query.includes('/') || query.length > SLASH_QUERY_LIMIT) return null
+
+  const from = $from.start() + slashIndex
+  const to = selection.from
+
+  try {
+    const coords = editor.view.coordsAtPos(from)
+    return {
+      from,
+      to,
+      query,
+      rect: new DOMRect(
+        coords.left,
+        coords.top,
+        Math.max(1, coords.right - coords.left),
+        Math.max(1, coords.bottom - coords.top)
+      )
+    }
+  } catch {
+    return null
+  }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-string-attr.ts

@@ -0,0 +1,5 @@
+'use client'
+
+export function getStringAttr(value: unknown) {
+  return typeof value === 'string' ? value : ''
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-table-element.ts

@@ -0,0 +1,5 @@
+export function getTableElement(dom: Node | null): HTMLTableElement | null {
+  if (!(dom instanceof HTMLElement)) return null
+  if (dom instanceof HTMLTableElement) return dom
+  return dom.querySelector('table')
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-table-from-event-target.ts

@@ -0,0 +1,19 @@
+import type { MountedEditorView } from '@admin/utils/editor/mounted-editor-view'
+import type { Editor } from '@tiptap/react'
+import { getTableFromWrapper } from '@admin/utils/editor/get-table-from-wrapper'
+import { TABLE_WRAPPER_CLASS } from '@admin/utils/editor/table-wrapper-class'
+
+export function getTableFromEventTarget(
+  editor: Editor,
+  view: MountedEditorView,
+  target: EventTarget | null
+): { pos: number; wrapper: HTMLElement } | null {
+  if (!(target instanceof HTMLElement)) return null
+
+  const wrapper = target.closest(`.${TABLE_WRAPPER_CLASS}`)
+  if (!(wrapper instanceof HTMLElement) || !view.dom.contains(wrapper)) {
+    return null
+  }
+
+  return getTableFromWrapper(editor, view, wrapper)
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-table-from-wrapper.ts

@@ -0,0 +1,15 @@
+import type { MountedEditorView } from '@admin/utils/editor/mounted-editor-view'
+import type { Editor } from '@tiptap/react'
+import { getTablePositionForElement } from '@admin/utils/editor/get-table-position-for-element'
+
+export function getTableFromWrapper(
+  editor: Editor,
+  view: MountedEditorView,
+  wrapper: HTMLElement
+): { pos: number; wrapper: HTMLElement } | null {
+  const tableElement = wrapper.querySelector('table')
+  if (!(tableElement instanceof HTMLTableElement)) return null
+
+  const pos = getTablePositionForElement(editor, view, tableElement)
+  return pos === null ? null : { pos, wrapper }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-table-position-for-element.ts

@@ -0,0 +1,24 @@
+import type { MountedEditorView } from '@admin/utils/editor/mounted-editor-view'
+import type { Editor } from '@tiptap/react'
+import { getTableElement } from '@admin/utils/editor/get-table-element'
+
+export function getTablePositionForElement(
+  editor: Editor,
+  view: MountedEditorView,
+  tableElement: HTMLTableElement
+): number | null {
+  let tablePos: number | null = null
+
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type.name !== 'table') return true
+
+    if (getTableElement(view.nodeDOM(pos)) === tableElement) {
+      tablePos = pos
+      return false
+    }
+
+    return true
+  })
+
+  return tablePos
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-table-rect-at-position.ts

@@ -0,0 +1,20 @@
+import type { TableRect } from '@tiptap/pm/tables'
+import type { Editor } from '@tiptap/react'
+import { TableMap } from '@tiptap/pm/tables'
+
+export function getTableRectAtPosition(editor: Editor, tablePos: number): TableRect | null {
+  const table = editor.state.doc.nodeAt(tablePos)
+  if (!table || table.type.name !== 'table') return null
+
+  const map = TableMap.get(table)
+
+  return {
+    bottom: map.height,
+    left: 0,
+    map,
+    right: map.width,
+    table,
+    tableStart: tablePos + 1,
+    top: 0
+  }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/get-table-wrapper-element.ts

@@ -0,0 +1,11 @@
+import { getTableElement } from '@admin/utils/editor/get-table-element'
+import { TABLE_WRAPPER_CLASS } from '@admin/utils/editor/table-wrapper-class'
+
+export function getTableWrapperElement(dom: Node | null): HTMLElement | null {
+  if (!(dom instanceof HTMLElement)) return null
+  if (dom.classList.contains(TABLE_WRAPPER_CLASS)) return dom
+
+  const table = getTableElement(dom)
+  const wrapper = table?.closest(`.${TABLE_WRAPPER_CLASS}`)
+  return wrapper instanceof HTMLElement ? wrapper : null
+}

package/dist/assets/adapters/next/templates/init/utils/editor/{task-item.ts → get-task-item-checkbox-label.ts}

@@ -1,12 +1,6 @@
-import type { TaskItemOptions } from '@tiptap/extension-list'
+import type { CheckboxLabelFactory } from '@admin/utils/editor/checkbox-label-factory'
 import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
 
-type CheckboxLabelFactory = NonNullable<NonNullable<TaskItemOptions['a11y']>['checkboxLabel']>
-
-export function isTaskItemChecked(node: ProseMirrorNode): boolean {
-  return node.attrs.checked === true
-}
-
 export function getTaskItemCheckboxLabel(
   node: ProseMirrorNode,
   checked: boolean,

package/dist/assets/adapters/next/templates/init/utils/editor/has-own-attribute.ts

@@ -0,0 +1,3 @@
+export function hasOwnAttribute(attributes: Record<string, unknown>, key: string): boolean {
+  return Object.hasOwn(attributes, key)
+}

package/dist/assets/adapters/next/templates/init/utils/editor/highlight-span-pattern.ts

@@ -0,0 +1,6 @@
+import { CONTENT_EDITOR_HIGHLIGHT_COLOR_NAME_PATTERN } from '@admin/utils/editor/content-editor-highlight-color-name-pattern'
+
+export const HIGHLIGHT_SPAN_PATTERN = new RegExp(
+  `<span\\s+data-highlight-color="(?:${CONTENT_EDITOR_HIGHLIGHT_COLOR_NAME_PATTERN})">([\\s\\S]*?)<\\/span>`,
+  'g'
+)

package/dist/assets/adapters/next/templates/init/utils/editor/inline-math-delimiter.ts

@@ -0,0 +1,3 @@
+'use client'
+
+export type InlineMathDelimiter = '$' | '\\('

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

@@ -0,0 +1,51 @@
+'use client'
+
+import type { InlineMathDelimiter } from '@admin/utils/editor/inline-math-delimiter'
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model'
+import { getInlineMathDelimiter } from '@admin/utils/editor/get-inline-math-delimiter'
+import { getStringAttr } from '@admin/utils/editor/get-string-attr'
+import { renderLatex } from '@admin/utils/editor/render-latex'
+
+export class InlineMathNodeView {
+  readonly dom: HTMLElement
+  private currentRaw: string
+  private currentDelimiter: InlineMathDelimiter
+  private node: ProseMirrorNode
+
+  constructor(node: ProseMirrorNode) {
+    this.node = node
+    this.currentRaw = getStringAttr(node.attrs.raw)
+    this.currentDelimiter = getInlineMathDelimiter(node.attrs.delimiter)
+    this.dom = document.createElement('span')
+    this.dom.dataset.contentEditorInlineMath = ''
+    this.dom.contentEditable = 'false'
+    this.dom.className = 'content-editor-inline-math rounded-[3px] px-0.5'
+    this.render()
+  }
+
+  update(node: ProseMirrorNode) {
+    if (node.type !== this.node.type) return false
+
+    this.node = node
+    const nextRaw = getStringAttr(node.attrs.raw)
+    const nextDelimiter = getInlineMathDelimiter(node.attrs.delimiter)
+
+    if (nextRaw !== this.currentRaw || nextDelimiter !== this.currentDelimiter) {
+      this.currentRaw = nextRaw
+      this.currentDelimiter = nextDelimiter
+      this.render()
+    }
+
+    return true
+  }
+
+  ignoreMutation() {
+    return true
+  }
+
+  private render() {
+    this.dom.dataset.raw = this.currentRaw
+    this.dom.dataset.delimiter = this.currentDelimiter
+    this.dom.innerHTML = renderLatex(this.currentRaw, false)
+  }
+}

package/dist/assets/adapters/next/templates/init/utils/editor/insert-component-at-cursor.ts

@@ -0,0 +1,28 @@
+import type { InsertResult } from '@admin/utils/editor/insert-result'
+import type { EditorView } from '@codemirror/view'
+
+export function insertComponentAtCursor(
+  view: EditorView | null,
+  currentValue: string,
+  snippet: string
+): InsertResult {
+  const wrapped = `\n${snippet}\n`
+
+  if (view) {
+    const { from } = view.state.selection.main
+    view.dispatch({
+      changes: { from, insert: wrapped },
+      selection: { anchor: from + wrapped.length }
+    })
+
+    return {
+      newValue: currentValue.slice(0, from) + wrapped + currentValue.slice(from),
+      newCursorPos: from + wrapped.length
+    }
+  }
+
+  return {
+    newValue: currentValue + wrapped,
+    newCursorPos: currentValue.length + wrapped.length
+  }
+}

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

@@ -0,0 +1,35 @@
+import type { Editor } from '@tiptap/react'
+import { parseContentEditorMathInput } from '@admin/utils/editor/parse-content-editor-math-input'
+
+export function insertContentEditorMath(editor: Editor | null, input: string): boolean {
+  if (!editor?.isEditable) return false
+
+  const math = parseContentEditorMathInput(input)
+  if (!math) return false
+
+  if (math.kind === 'display') {
+    return editor
+      .chain()
+      .focus()
+      .insertContent({
+        type: 'rawContentBlock',
+        attrs: {
+          kind: 'math',
+          raw: math.markdown
+        }
+      })
+      .run()
+  }
+
+  return editor
+    .chain()
+    .focus()
+    .insertContent({
+      type: 'inlineMath',
+      attrs: {
+        delimiter: math.delimiter ?? '$',
+        raw: math.raw
+      }
+    })
+    .run()
+}

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

@@ -0,0 +1,20 @@
+import type { Editor } from '@tiptap/react'
+import { canInsertContentEditorMediaPlaceholder } from '@admin/utils/editor/can-insert-content-editor-media-placeholder'
+import { CONTENT_EDITOR_MEDIA_PLACEHOLDER_NODE } from '@admin/utils/editor/content-editor-media-placeholder-node'
+
+export function insertContentEditorMediaPlaceholder(editor: Editor | null): boolean {
+  if (!editor) return false
+  if (!canInsertContentEditorMediaPlaceholder(editor)) return false
+
+  try {
+    return editor
+      .chain()
+      .focus()
+      .insertContent({
+        type: CONTENT_EDITOR_MEDIA_PLACEHOLDER_NODE
+      })
+      .run()
+  } catch {
+    return false
+  }
+}

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

@@ -0,0 +1,12 @@
+import type { Editor } from '@tiptap/react'
+import { createContentEditorTableNode } from '@admin/utils/editor/create-content-editor-table-node'
+import { DEFAULT_CONTENT_EDITOR_TABLE_COLS } from '@admin/utils/editor/default-content-editor-table-cols'
+import { DEFAULT_CONTENT_EDITOR_TABLE_ROWS } from '@admin/utils/editor/default-content-editor-table-rows'
+
+export function insertContentEditorTable(
+  editor: Editor,
+  rows: number = DEFAULT_CONTENT_EDITOR_TABLE_ROWS,
+  cols: number = DEFAULT_CONTENT_EDITOR_TABLE_COLS
+): boolean {
+  return editor.chain().focus().insertContent(createContentEditorTableNode(rows, cols)).run()
+}

package/dist/assets/adapters/next/templates/init/utils/editor/insert-markdown-text-at-position.ts

@@ -0,0 +1,14 @@
+import type { InsertResult } from '@admin/utils/editor/insert-result'
+
+export function insertMarkdownTextAtPosition(
+  currentValue: string,
+  text: string,
+  requestedPos: number
+): InsertResult {
+  const insertPos = Math.min(requestedPos, currentValue.length)
+
+  return {
+    newValue: currentValue.slice(0, insertPos) + text + currentValue.slice(insertPos),
+    newCursorPos: insertPos + text.length
+  }
+}

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

@@ -0,0 +1,4 @@
+export interface InsertResult {
+  newValue: string
+  newCursorPos: number
+}

package/dist/assets/adapters/next/templates/init/utils/editor/insert-text-at-cursor.ts

@@ -0,0 +1,37 @@
+import type { InsertResult } from '@admin/utils/editor/insert-result'
+import type { EditorView } from '@codemirror/view'
+
+export function insertTextAtCursor(
+  view: EditorView | null,
+  currentValue: string,
+  opts: { before: string; after: string; placeholder: string }
+): InsertResult {
+  const { before, after, placeholder } = opts
+
+  if (view) {
+    const { from, to } = view.state.selection.main
+    const selected = view.state.sliceDoc(from, to)
+    const insert = selected || placeholder
+    const newText = `${before}${insert}${after}`
+
+    view.dispatch({
+      changes: { from, to, insert: newText },
+      selection: {
+        anchor: from + before.length,
+        head: from + before.length + insert.length
+      }
+    })
+
+    return {
+      newValue: currentValue.slice(0, from) + newText + currentValue.slice(to),
+      newCursorPos: from + before.length + insert.length
+    }
+  }
+
+  const insert = placeholder
+  const newText = `${before}${insert}${after}`
+  return {
+    newValue: currentValue + newText,
+    newCursorPos: currentValue.length + before.length + insert.length
+  }
+}