@allbluecn/web-app 0.6.3 → 0.7.0

package/src/components/tiptap/lib/pacer.ts

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { RateLimiter } from "@tanstack/pacer"
+import { useDebouncedCallback, useThrottledCallback } from "@tanstack/react-pacer"
+
+export const EDITOR_AUTO_SAVE_MS = 2000
+export const EDITOR_CHANGE_DEBOUNCE_MS = 500
+export const SEARCH_DEBOUNCE_MS = 300
+export const SCROLL_THROTTLE_MS = 150
+export const AI_RATE_LIMIT = {
+  chat: { max: 10, windowMs: 60_000 },
+  execute: { max: 5, windowMs: 60_000 },
+  generatePrototype: { max: 5, windowMs: 60_000 },
+  testProvider: { max: 10, windowMs: 60_000 },
+  detect: { max: 10, windowMs: 60_000 },
+  webSearch: { max: 20, windowMs: 60_000 },
+} as const
+
+export interface RateLimitConfig {
+  max: number
+  windowMs: number
+}
+
+export { useDebouncedCallback }
+export { useThrottledCallback }
+
+interface ServerFnRateLimitResult {
+  allowed: boolean
+  retryAfterMs: number
+}
+
+const limiterCache = new Map<
+  string,
+  { limiter: any; lastAccess: number }
+>()
+
+const CACHE_TTL_MS = 5 * 60 * 1000
+
+function purgeStaleEntries() {
+  const now = Date.now()
+  for (const [key, entry] of limiterCache) {
+    if (now - entry.lastAccess > CACHE_TTL_MS) {
+      entry.limiter.reset()
+      limiterCache.delete(key)
+    }
+  }
+}
+
+setInterval(purgeStaleEntries, 60_000)
+
+export function getRateLimiter(
+  key: string,
+  config: RateLimitConfig
+): any {
+  const existing = limiterCache.get(key)
+  if (existing) {
+    existing.lastAccess = Date.now()
+    return existing.limiter
+  }
+
+  const limiter = new RateLimiter(() => true, {
+    limit: config.max,
+    window: config.windowMs,
+  } as any)
+
+  limiterCache.set(key, { limiter, lastAccess: Date.now() })
+  return limiter
+}
+
+export function checkRateLimit(
+  key: string,
+  config: RateLimitConfig
+): ServerFnRateLimitResult {
+  const limiter = getRateLimiter(key, config)
+  const allowed = limiter.maybeExecute()
+  return {
+    allowed,
+    retryAfterMs: allowed ? 0 : (limiter as any).getMsUntilNextWindow?.() ?? 0,
+  }
+}

package/src/components/tiptap/lib/utils/attr.ts

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import type { Transaction } from "@tiptap/pm/state"
+import type { NodeWithPos } from "@tiptap/react"
+
+/**
+ * Update a single attribute on multiple nodes.
+ *
+ * @param tr - The transaction to mutate
+ * @param targets - Array of { node, pos }
+ * @param attrName - Attribute key to update
+ * @param next - New value OR updater function receiving previous value
+ *               Pass `undefined` to remove the attribute.
+ * @returns true if at least one node was updated, false otherwise
+ */
+export function updateNodesAttr<A extends string = string, V = unknown>(
+  tr: Transaction,
+  targets: readonly NodeWithPos[],
+  attrName: A,
+  next: V | ((prev: V | undefined) => V | undefined)
+): boolean {
+  if (!targets.length) return false
+
+  let changed = false
+
+  for (const { pos } of targets) {
+    const currentNode = tr.doc.nodeAt(pos)
+    if (!currentNode) continue
+
+    const prevValue = (currentNode.attrs as Record<string, unknown>)[
+      attrName
+    ] as V | undefined
+    const resolvedNext =
+      typeof next === "function"
+        ? (next as (p: V | undefined) => V | undefined)(prevValue)
+        : next
+
+    if (prevValue === resolvedNext) continue
+
+    const nextAttrs: Record<string, unknown> = { ...currentNode.attrs }
+    if (resolvedNext === undefined) {
+      delete nextAttrs[attrName]
+    } else {
+      nextAttrs[attrName] = resolvedNext
+    }
+
+    tr.setNodeMarkup(pos, undefined, nextAttrs)
+    changed = true
+  }
+
+  return changed
+}

package/src/components/tiptap/lib/utils/constants.ts

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+export const MAX_FILE_SIZE = 5 * 1024 * 1024 // 5MB
+
+export const MAC_SYMBOLS: Record<string, string> = {
+  mod: "⌘",
+  command: "⌘",
+  meta: "⌘",
+  ctrl: "⌃",
+  control: "⌃",
+  alt: "⌥",
+  option: "⌥",
+  shift: "⇧",
+  backspace: "Del",
+  delete: "⌦",
+  enter: "⏎",
+  escape: "⎋",
+  capslock: "⇪",
+} as const
+
+export const SR_ONLY = {
+  position: "absolute",
+  width: "1px",
+  height: "1px",
+  padding: 0,
+  margin: "-1px",
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  borderWidth: 0,
+} as const

package/src/components/tiptap/lib/utils/math.ts

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+/**
+ * Clamps a value between min and max bounds
+ */
+export function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(value, max))
+}

package/src/components/tiptap/lib/utils/node.ts

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import type { Node as PMNode } from "@tiptap/pm/model"
+import { Selection, TextSelection } from "@tiptap/pm/state"
+import type { Editor } from "@tiptap/react"
+
+/**
+ * Moves the focus to the next node in the editor
+ * @param editor - The editor instance
+ * @returns boolean indicating if the focus was moved
+ */
+export function focusNextNode(editor: Editor) {
+  const { state, view } = editor
+  const { doc, selection } = state
+
+  const nextSel = Selection.findFrom(selection.$to, 1, true)
+  if (nextSel) {
+    view.dispatch(state.tr.setSelection(nextSel).scrollIntoView())
+    return true
+  }
+
+  const paragraphType = state.schema.nodes.paragraph
+  if (!paragraphType) {
+    console.warn("No paragraph node type found in schema.")
+    return false
+  }
+
+  const end = doc.content.size
+  const para = paragraphType.create()
+  let tr = state.tr.insert(end, para)
+
+  // Place the selection inside the new paragraph
+  const $inside = tr.doc.resolve(end + 1)
+  tr = tr.setSelection(TextSelection.near($inside)).scrollIntoView()
+  view.dispatch(tr)
+  return true
+}
+
+/**
+ * Checks if a value is a valid number (not null, undefined, or NaN)
+ * @param value - The value to check
+ * @returns boolean indicating if the value is a valid number
+ */
+export function isValidPosition(pos: number | null | undefined): pos is number {
+  return typeof pos === "number" && pos >= 0
+}
+
+/**
+ * Finds a node at the specified position with error handling
+ * @param editor The Tiptap editor instance
+ * @param position The position in the document to find the node
+ * @returns The node at the specified position, or null if not found
+ */
+export function findNodeAtPosition(editor: Editor, position: number) {
+  try {
+    const node = editor.state.doc.nodeAt(position)
+    if (!node) {
+      console.warn(`No node found at position ${position}`)
+      return null
+    }
+    return node
+  } catch (error) {
+    console.error(`Error getting node at position ${position}:`, error)
+    return null
+  }
+}
+
+/**
+ * Finds the position and instance of a node in the document
+ * @param props Object containing editor, node (optional), and nodePos (optional)
+ * @param props.editor The Tiptap editor instance
+ * @param props.node The node to find (optional if nodePos is provided)
+ * @param props.nodePos The position of the node to find (optional if node is provided)
+ * @returns An object with the position and node, or null if not found
+ */
+export function findNodePosition(props: {
+  editor: Editor | null
+  node?: PMNode | null
+  nodePos?: number | null
+}): { pos: number; node: PMNode } | null {
+  const { editor, node, nodePos } = props
+
+  if (!editor || !editor.state?.doc) return null
+
+  // Zero is valid position
+  const hasValidNode = node !== undefined && node !== null
+  const hasValidPos = isValidPosition(nodePos)
+
+  if (!hasValidNode && !hasValidPos) {
+    return null
+  }
+
+  // First search for the node in the document if we have a node
+  if (hasValidNode) {
+    let foundPos = -1
+    let foundNode: PMNode | null = null
+
+    editor.state.doc.descendants((currentNode, pos) => {
+      if (currentNode === node) {
+        foundPos = pos
+        foundNode = currentNode
+        return false
+      }
+      return true
+    })
+
+    if (foundPos !== -1 && foundNode !== null) {
+      return { pos: foundPos, node: foundNode }
+    }
+  }
+
+  // If we have a valid position, use findNodeAtPosition
+  if (hasValidPos) {
+    const nodeAtPos = findNodeAtPosition(editor, nodePos!)
+    if (nodeAtPos) {
+      return { pos: nodePos!, node: nodeAtPos }
+    }
+  }
+
+  return null
+}

package/src/components/tiptap/lib/utils/platform.ts

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { MAC_SYMBOLS } from "./constants"
+
+export function cn(
+  ...classes: (string | boolean | undefined | null)[]
+): string {
+  return classes.filter(Boolean).join(" ")
+}
+
+/**
+ * Determines if the current platform is macOS
+ * @returns boolean indicating if the current platform is Mac
+ */
+export function isMac(): boolean {
+  return (
+    typeof navigator !== "undefined" &&
+    navigator.platform.toLowerCase().includes("mac")
+  )
+}
+
+/**
+ * Formats a shortcut key based on the platform (Mac or non-Mac)
+ * @param key - The key to format (e.g., "ctrl", "alt", "shift")
+ * @param isMacPlatform - Boolean indicating if the platform is Mac
+ * @param capitalize - Whether to capitalize the key (default: true)
+ * @returns Formatted shortcut key symbol
+ */
+export const formatShortcutKey = (
+  key: string,
+  isMacPlatform: boolean,
+  capitalize: boolean = true
+) => {
+  if (isMacPlatform) {
+    const lowerKey = key.toLowerCase()
+    return MAC_SYMBOLS[lowerKey] || (capitalize ? key.toUpperCase() : key)
+  }
+
+  return capitalize ? key.charAt(0).toUpperCase() + key.slice(1) : key
+}
+
+/**
+ * Parses a shortcut key string into an array of formatted key symbols
+ * @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+ * @param delimiter - The delimiter used to split the keys (default: "+")
+ * @param capitalize - Whether to capitalize the keys (default: true)
+ * @returns Array of formatted shortcut key symbols
+ */
+export const parseShortcutKeys = (props: {
+  shortcutKeys: string | undefined
+  delimiter?: string
+  capitalize?: boolean
+}) => {
+  const { shortcutKeys, delimiter = "+", capitalize = true } = props
+
+  if (!shortcutKeys) return []
+
+  return shortcutKeys
+    .split(delimiter)
+    .map((key) => key.trim())
+    .map((key) => formatShortcutKey(key, isMac(), capitalize))
+}

package/src/components/tiptap/lib/utils/schema.ts

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import type { Editor } from "@tiptap/react"
+
+/**
+ * Checks if a mark exists in the editor schema
+ * @param markName - The name of the mark to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the mark exists in the schema
+ */
+export const isMarkInSchema = (
+  markName: string,
+  editor: Editor | null
+): boolean => {
+  if (!editor?.schema) return false
+  return editor.schema.spec.marks.get(markName) !== undefined
+}
+
+/**
+ * Checks if a node exists in the editor schema
+ * @param nodeName - The name of the node to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the node exists in the schema
+ */
+export const isNodeInSchema = (
+  nodeName: string,
+  editor: Editor | null
+): boolean => {
+  if (!editor?.schema) return false
+  return editor.schema.spec.nodes.get(nodeName) !== undefined
+}
+
+/**
+ * Checks if one or more extensions are registered in the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionNames - A single extension name or an array of names to check
+ * @returns True if at least one of the extensions is available, false otherwise
+ */
+export function isExtensionAvailable(
+  editor: Editor | null,
+  extensionNames: string | string[]
+): boolean {
+  if (!editor) return false
+
+  const names = Array.isArray(extensionNames)
+    ? extensionNames
+    : [extensionNames]
+
+  const found = names.some((name) =>
+    editor.extensionManager.extensions.some((ext) => ext.name === name)
+  )
+
+  if (!found) {
+    console.warn(
+      `None of the extensions [${names.join(", ")}] were found in the editor schema. Ensure they are included in the editor configuration.`
+    )
+  }
+
+  return found
+}