@llc3233149/core 0.9.0

package/src/text-editor.ts

@@ -0,0 +1,349 @@
+import type { SkiaRenderer } from './renderer'
+import type { SceneNode } from './scene-graph'
+import type { Rect } from './types'
+import type { CanvasKit, Paragraph } from 'canvaskit-wasm'
+
+export interface TextCaret {
+  x: number
+  y0: number
+  y1: number
+}
+
+export interface TextEditorState {
+  nodeId: string
+  text: string
+  cursor: number
+  selectionAnchor: number | null
+  paragraph: Paragraph | null
+}
+
+export class TextEditor {
+  private ck: CanvasKit
+  private renderer: SkiaRenderer | null = null
+  private _state: TextEditorState | null = null
+  caretVisible = true
+
+  constructor(ck: CanvasKit) {
+    this.ck = ck
+  }
+
+  private prepareMove(extend: boolean): TextEditorState | null {
+    const s = this._state
+    if (!s) return null
+    if (extend && s.selectionAnchor === null) s.selectionAnchor = s.cursor
+    if (!extend) s.selectionAnchor = null
+    return s
+  }
+
+  get state(): TextEditorState | null {
+    return this._state
+  }
+
+  get isActive(): boolean {
+    return this._state !== null
+  }
+
+  get nodeId(): string | null {
+    return this._state?.nodeId ?? null
+  }
+
+  setRenderer(renderer: SkiaRenderer | null): void {
+    this.renderer = renderer
+  }
+
+  start(node: SceneNode): void {
+    this._state = {
+      nodeId: node.id,
+      text: node.text,
+      cursor: node.text.length,
+      selectionAnchor: null,
+      paragraph: null
+    }
+    this.rebuildParagraph(node)
+  }
+
+  stop(): { nodeId: string; text: string } | null {
+    if (!this._state) return null
+    const result = { nodeId: this._state.nodeId, text: this._state.text }
+    this._state.paragraph?.delete()
+    this._state = null
+    return result
+  }
+
+  rebuildParagraph(node: SceneNode): void {
+    const s = this._state
+    if (!s || !this.renderer) return
+    s.paragraph?.delete()
+    s.paragraph = this.renderer.buildParagraph(node)
+  }
+
+  hasSelection(): boolean {
+    const s = this._state
+    return s !== null && s.selectionAnchor !== null && s.selectionAnchor !== s.cursor
+  }
+
+  getSelectionRange(): [number, number] | null {
+    const s = this._state
+    if (!s || s.selectionAnchor === null || s.selectionAnchor === s.cursor) return null
+    const lo = Math.min(s.cursor, s.selectionAnchor)
+    const hi = Math.max(s.cursor, s.selectionAnchor)
+    return [lo, hi]
+  }
+
+  getSelectedText(): string {
+    const range = this.getSelectionRange()
+    if (!range || !this._state) return ''
+    return this._state.text.slice(range[0], range[1])
+  }
+
+  selectAll(): void {
+    const s = this._state
+    if (!s) return
+    s.selectionAnchor = 0
+    s.cursor = s.text.length
+  }
+
+  selectWord(pos: number): void {
+    const s = this._state
+    if (!s) return
+    const text = s.text
+    let start = pos
+    let end = pos
+    while (start > 0 && !isWordBoundary(text[start - 1])) start--
+    while (end < text.length && !isWordBoundary(text[end])) end++
+    s.selectionAnchor = start
+    s.cursor = end
+  }
+
+  setCursorAt(x: number, y: number, extend = false): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    const pos = s.paragraph.getGlyphPositionAtCoordinate(x, y).pos
+    if (extend) {
+      if (s.selectionAnchor === null) s.selectionAnchor = s.cursor
+    } else {
+      s.selectionAnchor = null
+    }
+    s.cursor = pos
+  }
+
+  selectLine(pos: number): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    const lineNum = s.paragraph.getLineNumberAt(pos)
+    if (lineNum < 0) return
+    const metrics = s.paragraph.getLineMetricsAt(lineNum)
+    if (!metrics) return
+    s.selectionAnchor = metrics.startIndex
+    s.cursor = metrics.endExcludingWhitespaces
+  }
+
+  selectWordAt(x: number, y: number): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    const pos = s.paragraph.getGlyphPositionAtCoordinate(x, y).pos
+    this.selectWord(pos)
+  }
+
+  selectLineAt(x: number, y: number): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    const pos = s.paragraph.getGlyphPositionAtCoordinate(x, y).pos
+    this.selectLine(pos)
+  }
+
+  insert(text: string, node: SceneNode): void {
+    const s = this._state
+    if (!s) return
+    const range = this.getSelectionRange()
+    if (range) {
+      s.text = s.text.slice(0, range[0]) + text + s.text.slice(range[1])
+      s.cursor = range[0] + text.length
+    } else {
+      s.text = s.text.slice(0, s.cursor) + text + s.text.slice(s.cursor)
+      s.cursor += text.length
+    }
+    s.selectionAnchor = null
+    this.rebuildParagraph(node)
+  }
+
+  backspace(node: SceneNode): void {
+    const s = this._state
+    if (!s) return
+    const range = this.getSelectionRange()
+    if (range) {
+      s.text = s.text.slice(0, range[0]) + s.text.slice(range[1])
+      s.cursor = range[0]
+    } else if (s.cursor > 0) {
+      s.text = s.text.slice(0, s.cursor - 1) + s.text.slice(s.cursor)
+      s.cursor--
+    }
+    s.selectionAnchor = null
+    this.rebuildParagraph(node)
+  }
+
+  delete(node: SceneNode): void {
+    const s = this._state
+    if (!s) return
+    const range = this.getSelectionRange()
+    if (range) {
+      s.text = s.text.slice(0, range[0]) + s.text.slice(range[1])
+      s.cursor = range[0]
+    } else if (s.cursor < s.text.length) {
+      s.text = s.text.slice(0, s.cursor) + s.text.slice(s.cursor + 1)
+    }
+    s.selectionAnchor = null
+    this.rebuildParagraph(node)
+  }
+
+  moveLeft(extend = false): void {
+    const s = this._state
+    if (!s) return
+    if (!extend && this.hasSelection()) {
+      const range = this.getSelectionRange()
+      if (range) s.cursor = range[0]
+      s.selectionAnchor = null
+      return
+    }
+    this.prepareMove(extend)
+    if (s.cursor > 0) s.cursor--
+  }
+
+  moveRight(extend = false): void {
+    const s = this._state
+    if (!s) return
+    if (!extend && this.hasSelection()) {
+      const range = this.getSelectionRange()
+      if (range) s.cursor = range[1]
+      s.selectionAnchor = null
+      return
+    }
+    this.prepareMove(extend)
+    if (s.cursor < s.text.length) s.cursor++
+  }
+
+  moveUp(extend = false): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    this.prepareMove(extend)
+    const caret = this.getCaretRect()
+    if (!caret) return
+    const fontSize = s.paragraph.getLineMetrics()[0]?.height ?? 14
+    s.cursor = s.paragraph.getGlyphPositionAtCoordinate(caret.x, caret.y0 - fontSize / 2).pos
+  }
+
+  moveDown(extend = false): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    this.prepareMove(extend)
+    const caret = this.getCaretRect()
+    if (!caret) return
+    const fontSize = s.paragraph.getLineMetrics()[0]?.height ?? 14
+    s.cursor = s.paragraph.getGlyphPositionAtCoordinate(caret.x, caret.y1 + fontSize / 2).pos
+  }
+
+  moveToLineStart(extend = false): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    this.prepareMove(extend)
+    const lineNum = s.paragraph.getLineNumberAt(s.cursor)
+    if (lineNum < 0) return
+    const metrics = s.paragraph.getLineMetricsAt(lineNum)
+    if (metrics) s.cursor = metrics.startIndex
+  }
+
+  moveToLineEnd(extend = false): void {
+    const s = this._state
+    if (!s?.paragraph) return
+    this.prepareMove(extend)
+    const lineNum = s.paragraph.getLineNumberAt(s.cursor)
+    if (lineNum < 0) return
+    const metrics = s.paragraph.getLineMetricsAt(lineNum)
+    if (metrics) s.cursor = metrics.endExcludingWhitespaces
+  }
+
+  moveWordLeft(extend = false): void {
+    const s = this.prepareMove(extend)
+    if (!s) return
+    let pos = s.cursor
+    while (pos > 0 && isWordBoundary(s.text[pos - 1])) pos--
+    while (pos > 0 && !isWordBoundary(s.text[pos - 1])) pos--
+    s.cursor = pos
+  }
+
+  moveWordRight(extend = false): void {
+    const s = this.prepareMove(extend)
+    if (!s) return
+    let pos = s.cursor
+    while (pos < s.text.length && !isWordBoundary(s.text[pos])) pos++
+    while (pos < s.text.length && isWordBoundary(s.text[pos])) pos++
+    s.cursor = pos
+  }
+
+  getCaretRect(): TextCaret | null {
+    const s = this._state
+    if (!s?.paragraph) return null
+
+    const text = s.text
+    const cursor = s.cursor
+
+    if (text.length === 0) {
+      const metrics = s.paragraph.getLineMetrics()
+      if (metrics.length === 0) return null
+      const line = metrics[0]
+      return { x: line.left, y0: 0, y1: line.height }
+    }
+
+    let lo: number
+    let hi: number
+    let useRight = false
+
+    if (cursor === 0) {
+      lo = 0
+      hi = 1
+    } else if (cursor >= text.length) {
+      lo = text.length - 1
+      hi = text.length
+      useRight = true
+    } else {
+      lo = cursor
+      hi = cursor + 1
+    }
+
+    const rects = s.paragraph.getRectsForRange(
+      lo,
+      hi,
+      this.ck.RectHeightStyle.Max,
+      this.ck.RectWidthStyle.Tight
+    )
+    if (rects.length === 0) return null
+    const [left, top, right, bottom] = rects[0].rect
+    return {
+      x: useRight ? right : left,
+      y0: top,
+      y1: bottom
+    }
+  }
+
+  getSelectionRects(): Rect[] {
+    const s = this._state
+    if (!s?.paragraph) return []
+    const range = this.getSelectionRange()
+    if (!range) return []
+
+    const rects = s.paragraph.getRectsForRange(
+      range[0],
+      range[1],
+      this.ck.RectHeightStyle.Max,
+      this.ck.RectWidthStyle.Tight
+    )
+    return rects.map((r) => {
+      const [left, top, right, bottom] = r.rect
+      return { x: left, y: top, width: right - left, height: bottom - top }
+    })
+  }
+}
+
+function isWordBoundary(ch: string): boolean {
+  return /\s|[.,;:!?()[\]{}"'`<>/\\|@#$%^&*~+=\-_]/.test(ch)
+}

package/src/tools/ai-adapter.ts

@@ -0,0 +1,144 @@
+/**
+ * Adapter: tool definitions → Vercel AI SDK `tool()` objects.
+ *
+ * Converts ParamDef types to valibot schemas and wraps execute
+ * functions with FigmaAPI instantiation.
+ */
+
+import type { FigmaAPI } from '../figma-api'
+import type { ToolDef, ParamDef, ParamType } from './schema'
+import type * as valibot from 'valibot'
+
+export interface AIAdapterOptions {
+  getFigma: () => FigmaAPI
+  onBeforeExecute?: (def: ToolDef) => void
+  onAfterExecute?: (def: ToolDef, result: unknown, args: Record<string, unknown>) => void
+  onFlashNodes?: (nodeIds: string[]) => void
+}
+
+function extractIdsFromArray(arr: unknown[]): string[] {
+  const ids: string[] = []
+  for (const item of arr) {
+    if (item && typeof item === 'object' && 'id' in item && typeof item.id === 'string') {
+      ids.push(item.id)
+    }
+  }
+  return ids
+}
+
+export function extractNodeIds(result: unknown): string[] {
+  if (!result || typeof result !== 'object') return []
+  if ('deleted' in result && typeof result.deleted === 'string') return []
+  const ids: string[] = []
+  if ('id' in result && typeof result.id === 'string') ids.push(result.id)
+  if ('selection' in result && Array.isArray(result.selection)) ids.push(...extractIdsFromArray(result.selection))
+  if ('results' in result && Array.isArray(result.results)) ids.push(...extractIdsFromArray(result.results))
+  return ids
+}
+
+export function toolsToAI(
+  tools: ToolDef[],
+  options: AIAdapterOptions,
+  deps: {
+    v: typeof valibot
+    valibotSchema: (schema: any) => any
+    tool: (opts: any) => any
+  }
+): Record<string, any> {
+  const { v, valibotSchema, tool } = deps
+  const result: Record<string, any> = {}
+
+  for (const def of tools) {
+    const shape: Record<string, unknown> = {}
+    for (const [key, param] of Object.entries(def.params)) {
+      shape[key] = paramToValibot(v, param)
+    }
+
+    const rawSchema = valibotSchema(v.object(shape as any))
+    // Gemini requires enum fields to have type:"string". valibot's picklist()
+    // emits {"enum":[...]} without a type, causing 400 errors. Patch it.
+    if (rawSchema.jsonSchema && typeof rawSchema.jsonSchema === 'object') {
+      patchEnumType(rawSchema.jsonSchema as Record<string, unknown>)
+    }
+
+    const toolOpts: Record<string, unknown> = {
+      description: def.description,
+      inputSchema: rawSchema,
+      execute: async (args: Record<string, unknown>) => {
+        options.onBeforeExecute?.(def)
+        let execResult: unknown
+        try {
+          execResult = await def.execute(options.getFigma(), args as any)
+          if (def.mutates && options.onFlashNodes) {
+            const ids = extractNodeIds(execResult)
+            if (ids.length > 0) options.onFlashNodes(ids)
+          }
+          return execResult
+        } catch (err) {
+          return { error: err instanceof Error ? err.message : String(err) }
+        } finally {
+          options.onAfterExecute?.(def, execResult, args)
+        }
+      }
+    }
+
+    if (def.name === 'export_image') {
+      toolOpts.toModelOutput = ({ output }: { output: unknown }) => {
+        if (output && typeof output === 'object' && 'base64' in output && 'mimeType' in output) {
+          const r = output as { base64: string; mimeType: string }
+          return {
+            type: 'content' as const,
+            value: [{ type: 'media' as const, mediaType: r.mimeType, data: r.base64 }]
+          }
+        }
+        return { type: 'json' as const, value: output as Record<string, unknown> }
+      }
+    }
+
+    result[def.name] = tool(toolOpts)
+  }
+
+  return result
+}
+
+/** Recursively add type:"string" to any schema node that has enum but no type. */
+function patchEnumType(schema: Record<string, unknown>): void {
+  if (Array.isArray(schema.enum) && !schema.type) {
+    schema.type = 'string'
+  }
+  if (schema.properties && typeof schema.properties === 'object') {
+    for (const prop of Object.values(schema.properties as Record<string, Record<string, unknown>>)) {
+      patchEnumType(prop)
+    }
+  }
+  if (schema.items && typeof schema.items === 'object') {
+    patchEnumType(schema.items as Record<string, unknown>)
+  }
+}
+
+function paramToValibot(v: typeof valibot, param: ParamDef): unknown {
+  const typeMap: Record<ParamType, () => unknown> = {
+    string: () => (param.enum ? v.picklist(param.enum as [string, ...string[]]) : v.string()),
+    number: () => {
+      const pipes: unknown[] = [v.number()]
+      if (param.min !== undefined) pipes.push(v.minValue(param.min))
+      if (param.max !== undefined) pipes.push(v.maxValue(param.max))
+      return pipes.length > 1 ? v.pipe(...(pipes as [any, any, ...any[]])) : v.number()
+    },
+    boolean: () => v.boolean(),
+    color: () => v.pipe(v.string(), v.description('Color value (hex like #ff0000 or #ff000080)')),
+    'string[]': () => v.pipe(v.array(v.string()), v.minLength(1))
+  }
+
+  let schema = typeMap[param.type]()
+
+  if (param.description && param.type !== 'color') {
+    schema = v.pipe(schema as any, v.description(param.description))
+  }
+
+  if (!param.required) {
+    schema = v.optional(schema as any, param.default as any)
+  }
+
+  return schema
+}