foliko 1.1.8 → 1.1.9

package/.agent/plugins/poster-plugin/src/components/frame.js

@@ -1,230 +0,0 @@
-/**
- * 装饰边框组件 - 多种风格
- */
-
-const paper = require('paper')
-
-/**
- * 创建边框
- */
-function createFrame(project, args) {
-  const {
-    x = 0,
-    y = 0,
-    width = 400,
-    height = 300,
-    style = 'simple', // simple, double, dashed, dotted, corner, vintage, modern, floral
-    color = '#000000',
-    borderWidth = 2,
-    radius = 0,
-    padding = 0,
-    opacity = 1,
-  } = args
-
-  const items = []
-  const effectiveX = x + padding
-  const effectiveY = y + padding
-  const effectiveWidth = width - padding * 2
-  const effectiveHeight = height - padding * 2
-
-  const strokeOpts = {
-    strokeColor: new paper.Color(color),
-    strokeWidth: borderWidth,
-  }
-
-  switch (style) {
-    case 'simple':
-      // 简单矩形
-      items.push(new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        radius: radius,
-        ...strokeOpts,
-      }))
-      break
-
-    case 'double':
-      // 双线边框
-      items.push(new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        radius: radius,
-        ...strokeOpts,
-      }))
-      items.push(new paper.Path.Rectangle({
-        point: [effectiveX + 8, effectiveY + 8],
-        size: [effectiveWidth - 16, effectiveHeight - 16],
-        radius: radius,
-        ...strokeOpts,
-      }))
-      break
-
-    case 'dashed':
-      // 虚线边框
-      const dashed = new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        radius: radius,
-        ...strokeOpts,
-      })
-      dashed.dashArray = [10, 5]
-      items.push(dashed)
-      break
-
-    case 'dotted':
-      // 点线边框
-      const dotted = new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        radius: radius,
-        strokeColor: new paper.Color(color),
-        strokeWidth: borderWidth,
-        dashArray: [2, 4],
-      })
-      items.push(dotted)
-      break
-
-    case 'corner':
-      // 四角装饰
-      const cornerSize = Math.min(30, effectiveWidth / 4, effectiveHeight / 4)
-      // 左上角
-      items.push(new paper.Path.Line(
-        [effectiveX, effectiveY + cornerSize],
-        [effectiveX, effectiveY],
-        { ...strokeOpts }
-      ))
-      items.push(new paper.Path.Line(
-        [effectiveX, effectiveY],
-        [effectiveX + cornerSize, effectiveY],
-        { ...strokeOpts }
-      ))
-      // 右上角
-      items.push(new paper.Path.Line(
-        [effectiveX + effectiveWidth - cornerSize, effectiveY],
-        [effectiveX + effectiveWidth, effectiveY],
-        { ...strokeOpts }
-      ))
-      items.push(new paper.Path.Line(
-        [effectiveX + effectiveWidth, effectiveY],
-        [effectiveX + effectiveWidth, effectiveY + cornerSize],
-        { ...strokeOpts }
-      ))
-      // 左下角
-      items.push(new paper.Path.Line(
-        [effectiveX, effectiveY + effectiveHeight - cornerSize],
-        [effectiveX, effectiveY + effectiveHeight],
-        { ...strokeOpts }
-      ))
-      items.push(new paper.Path.Line(
-        [effectiveX, effectiveY + effectiveHeight],
-        [effectiveX + cornerSize, effectiveY + effectiveHeight],
-        { ...strokeOpts }
-      ))
-      // 右下角
-      items.push(new paper.Path.Line(
-        [effectiveX + effectiveWidth - cornerSize, effectiveY + effectiveHeight],
-        [effectiveX + effectiveWidth, effectiveY + effectiveHeight],
-        { ...strokeOpts }
-      ))
-      items.push(new paper.Path.Line(
-        [effectiveX + effectiveWidth, effectiveY + effectiveHeight - cornerSize],
-        [effectiveX + effectiveWidth, effectiveY + effectiveHeight],
-        { ...strokeOpts }
-      ))
-      break
-
-    case 'vintage':
-      // 复古边框 - 双线+角装饰
-      const vintageOuter = new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        ...strokeOpts,
-      })
-      items.push(vintageOuter)
-      const vintageInner = new paper.Path.Rectangle({
-        point: [effectiveX + 6, effectiveY + 6],
-        size: [effectiveWidth - 12, effectiveHeight - 12],
-        ...strokeOpts,
-      })
-      items.push(vintageInner)
-      // 四角小方块
-      const cornerBlockSize = 8
-      const corners = [
-        [effectiveX, effectiveY],
-        [effectiveX + effectiveWidth - cornerBlockSize, effectiveY],
-        [effectiveX, effectiveY + effectiveHeight - cornerBlockSize],
-        [effectiveX + effectiveWidth - cornerBlockSize, effectiveY + effectiveHeight - cornerBlockSize],
-      ]
-      corners.forEach(([cx, cy]) => {
-        items.push(new paper.Path.Rectangle({
-          point: [cx, cy],
-          size: [cornerBlockSize, cornerBlockSize],
-          fillColor: new paper.Color(color),
-        }))
-      })
-      break
-
-    case 'modern':
-      // 现代边框 - 粗细交替
-      const modernPath = new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        radius: radius,
-        ...strokeOpts,
-      })
-      modernPath.dashArray = [20, 5, 5, 5]
-      items.push(modernPath)
-      break
-
-    case 'floral':
-      // 花纹边框 - 角装饰+边线
-      const floral = new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        ...strokeOpts,
-      })
-      items.push(floral)
-      // 四个角的花纹
-      const fCornerSize = Math.min(25, effectiveWidth / 6, effectiveHeight / 6)
-      const fCorners = [
-        { x: effectiveX, y: effectiveY, rotation: 0 },
-        { x: effectiveX + effectiveWidth - fCornerSize, y: effectiveY, rotation: 90 },
-        { x: effectiveX, y: effectiveY + effectiveHeight - fCornerSize, rotation: 270 },
-        { x: effectiveX + effectiveWidth - fCornerSize, y: effectiveY + effectiveHeight - fCornerSize, rotation: 180 },
-      ]
-      fCorners.forEach(({ x: fx, y: fy, rotation }) => {
-        const ornament = new paper.Path()
-        ornament.add(new paper.Point(fx + fCornerSize / 2, fy + fCornerSize))
-        ornament.add(new paper.Point(fx + fCornerSize, fy + fCornerSize / 2))
-        ornament.add(new paper.Point(fx + fCornerSize, fy + fCornerSize))
-        ornament.strokeColor = new paper.Color(color)
-        ornament.strokeWidth = borderWidth
-        ornament.rotate(rotation, new paper.Point(fx + fCornerSize, fy + fCornerSize))
-        items.push(ornament)
-      })
-      break
-
-    default:
-      items.push(new paper.Path.Rectangle({
-        point: [effectiveX, effectiveY],
-        size: [effectiveWidth, effectiveHeight],
-        radius: radius,
-        ...strokeOpts,
-      }))
-  }
-
-  // 应用透明度
-  if (opacity !== 1) {
-    items.forEach(item => {
-      item.opacity = opacity
-    })
-  }
-
-  return {
-    success: true,
-    type: 'frame',
-    items: items.map(i => i.id),
-  }
-}
-
-module.exports = createFrame

package/.agent/plugins/poster-plugin/src/components/grid.js

@@ -1,130 +0,0 @@
-/**
- * 网格布局组件
- * 支持任意行列的网格布局
- */
-
-const paper = require('paper')
-
-/**
- * 创建网格布局组件
- * 
- * @param {Object} project - Paper.js 项目
- * @param {Object} canvas - 画布对象
- * @param {Object} params - 组件参数
- * @param {number} params.x - 起始X坐标
- * @param {number} params.y - 起始Y坐标
- * @param {number} params.width - 总宽度
- * @param {number} params.height - 总高度
- * @param {number} [params.columns=3] - 列数
- * @param {number} [params.rows=2] - 行数
- * @param {number} [params.gapX=20] - 水平间距
- * @param {number} [params.gapY=20] - 垂直间距
- * @param {string} [params.background] - 背景色
- * @param {string} [params.borderColor] - 边框颜色
- * @param {number} [params.borderWidth] - 边框宽度
- * @param {number} [params.radius=0] - 圆角
- * @param {string} [params.direction='row'] - 排列方向: row(行优先), column(列优先)
- */
-function createGrid(project, canvas, params) {
-  const {
-    x,
-    y,
-    width,
-    height,
-    columns = 3,
-    rows = 2,
-    gapX = 20,
-    gapY = 20,
-    background,
-    borderColor,
-    borderWidth = 1,
-    radius = 0,
-    direction = 'row'
-  } = params
-
-  const elements = []
-  
-  // 计算单元格尺寸
-  const totalGapX = gapX * (columns - 1)
-  const totalGapY = gapY * (rows - 1)
-  const cellWidth = (width - totalGapX) / columns
-  const cellHeight = (height - totalGapY) / rows
-  
-  // 绘制背景
-  if (background) {
-    const bg = new paper.Path.Rectangle({
-      point: [x, y],
-      size: [width, height],
-      radius: radius
-    })
-    bg.fillColor = new paper.Color(background)
-    if (project && project.activeLayer) {
-      project.activeLayer.addChild(bg)
-    }
-    elements.push({ type: 'rectangle', id: bg.id })
-  }
-  
-  // 绘制边框
-  if (borderColor && borderWidth > 0) {
-    const border = new paper.Path.Rectangle({
-      point: [x, y],
-      size: [width, height],
-      radius: radius
-    })
-    border.fillColor = new paper.Color('transparent')
-    border.strokeColor = new paper.Color(borderColor)
-    border.strokeWidth = borderWidth
-    if (project && project.activeLayer) {
-      project.activeLayer.addChild(border)
-    }
-    elements.push({ type: 'rectangle', id: border.id })
-  }
-  
-  // 生成网格位置信息
-  const cellPositions = []
-  const totalCells = columns * rows
-  
-  for (let i = 0; i < totalCells; i++) {
-    let col, row
-    
-    if (direction === 'row') {
-      col = i % columns
-      row = Math.floor(i / columns)
-    } else {
-      row = i % rows
-      col = Math.floor(i / rows)
-    }
-    
-    const cellX = x + col * (cellWidth + gapX)
-    const cellY = y + row * (cellHeight + gapY)
-    
-    cellPositions.push({
-      index: i,
-      column: col,
-      row: row,
-      x: cellX,
-      y: cellY,
-      width: cellWidth,
-      height: cellHeight,
-      centerX: cellX + cellWidth / 2,
-      centerY: cellY + cellHeight / 2
-    })
-  }
-  
-  // 返回网格布局信息
-  return {
-    success: true,
-    elements,
-    cellPositions,
-    cellWidth,
-    cellHeight,
-    columns,
-    rows,
-    totalCells,
-    totalWidth: width,
-    totalHeight: height,
-    type: 'grid'
-  }
-}
-
-module.exports = createGrid

package/.agent/plugins/poster-plugin/src/components/highlightText.js

@@ -1,145 +0,0 @@
-/**
- * 高亮文字组件 - 荧光笔效果
- */
-
-const paper = require('paper')
-const { getFontFallbackChain, validateFont } = require('../fonts')
-
-/**
- * 创建高亮文字
- */
-function createHighlightText(project, args) {
-  const {
-    x = 0,
-    y = 0,
-    text = '',
-    fontSize = 48,
-    fontFamily,
-    color = '#000000',
-    highlightColor = '#ffff00',
-    highlightStyle = 'marker', // marker, underline, background, stroke
-    highlightWidth = 20,
-    strokeWidth = 2,
-    shadow,
-    opacity = 1,
-  } = args
-
-  const items = []
-
-  // 创建文字以获取尺寸
-  const textItem = new paper.PointText({
-    point: [x, y + fontSize],
-    content: text,
-    fontSize,
-    fontFamily: getFontFallbackChain(fontFamily, text).join(', '),
-    fillColor: new paper.Color(color),
-    justification: 'left',
-  })
-
-  const textBounds = textItem.bounds
-
-  // 根据样式添加高亮
-  switch (highlightStyle) {
-    case 'marker':
-      // 荧光笔效果 - 倾斜的矩形
-      const markerHeight = fontSize * 0.8
-      const marker = new paper.Path.Rectangle({
-        point: [textBounds.x - 5, textBounds.y + fontSize * 0.3],
-        size: [textBounds.width + 10, markerHeight],
-      })
-      marker.fillColor = new paper.Color(highlightColor)
-      marker.opacity = 0.5
-      marker.rotate(-5, marker.bounds.center)
-      if (shadow) {
-        marker.shadowColor = new paper.Color(shadow.color || '#000000')
-        marker.shadowBlur = shadow.blur || 5
-        marker.shadowOffset = new paper.Point(shadow.offsetX || 2, shadow.offsetY || 2)
-      }
-      if (opacity !== 1) marker.opacity *= opacity
-      items.push(marker)
-      break
-
-    case 'underline':
-      // 下划线
-      const underlineY = textBounds.y + fontSize + 5
-      const underline = new paper.Path.Line(
-        [textBounds.x, underlineY],
-        [textBounds.x + textBounds.width, underlineY]
-      )
-      underline.strokeColor = new paper.Color(highlightColor)
-      underline.strokeWidth = highlightWidth
-      underline.strokeCap = 'round'
-      if (shadow) {
-        underline.shadowColor = new paper.Color(shadow.color || '#000000')
-        underline.shadowBlur = shadow.blur || 5
-        underline.shadowOffset = new paper.Point(shadow.offsetX || 2, shadow.offsetY || 2)
-      }
-      if (opacity !== 1) underline.opacity = opacity
-      items.push(underline)
-      break
-
-    case 'background':
-      // 背景色块
-      const padding = 8
-      const bg = new paper.Path.Rectangle({
-        point: [textBounds.x - padding, textBounds.y - 5],
-        size: [textBounds.width + padding * 2, fontSize + 10],
-        radius: 4,
-      })
-      bg.fillColor = new paper.Color(highlightColor)
-      bg.opacity = 0.6
-      if (shadow) {
-        bg.shadowColor = new paper.Color(shadow.color || '#000000')
-        bg.shadowBlur = shadow.blur || 5
-        bg.shadowOffset = new paper.Point(shadow.offsetX || 2, shadow.offsetY || 2)
-      }
-      if (opacity !== 1) bg.opacity *= opacity
-      items.push(bg)
-      break
-
-    case 'stroke':
-      // 描边效果
-      textItem.strokeColor = new paper.Color(highlightColor)
-      textItem.strokeWidth = strokeWidth
-      if (shadow) {
-        textItem.shadowColor = new paper.Color(shadow.color || '#000000')
-        textItem.shadowBlur = shadow.blur || 5
-        textItem.shadowOffset = new paper.Point(shadow.offsetX || 2, shadow.offsetY || 2)
-      }
-      if (opacity !== 1) textItem.opacity = opacity
-      items.push(textItem)
-      break
-
-    case 'neon':
-      // 霓虹效果
-      textItem.strokeColor = new paper.Color(highlightColor)
-      textItem.strokeWidth = strokeWidth * 2
-      const neonClone = textItem.clone()
-      neonClone.strokeWidth = strokeWidth * 4
-      neonClone.strokeColor = new paper.Color(highlightColor)
-      neonClone.fillColor = null
-      neonClone.opacity = 0.3
-      if (opacity !== 1) {
-        textItem.opacity = opacity
-        neonClone.opacity *= opacity
-      }
-      items.push(neonClone)
-      items.push(textItem)
-      break
-  }
-
-  // 如果不是 stroke 样式，需要重新添加文字
-  if (highlightStyle !== 'stroke' && highlightStyle !== 'neon') {
-    if (opacity !== 1) textItem.opacity = opacity
-    items.push(textItem)
-  }
-
-  return {
-    success: true,
-    type: 'highlightText',
-    items: items.map(i => i.id),
-    bounds: textBounds,
-  }
-}
-
-module.exports = createHighlightText

package/.agent/plugins/poster-plugin/src/components/icon.js

@@ -1,94 +0,0 @@
-/**
- * 图标组件 - 支持 emoji、图片图标
- */
-
-const paper = require('paper')
-const { loadImageAsRaster } = require('../utils/imageLoader')
-
-/**
- * 创建图标
- */
-async function createIcon(project, args) {
-  const {
-    x = 0,
-    y = 0,
-    size = 64,
-    icon, // emoji 或 图片URL
-    color,
-    backgroundColor,
-    borderColor,
-    borderWidth = 0,
-    radius = 0,
-    shadow,
-    opacity = 1,
-  } = args
-
-  const items = []
-
-  // 背景
-  if (backgroundColor || borderColor) {
-    const bg = new paper.Path.Rectangle({
-      point: [x, y],
-      size: [size, size],
-      radius: radius,
-    })
-
-    if (backgroundColor) {
-      bg.fillColor = new paper.Color(backgroundColor)
-    }
-
-    if (borderColor) {
-      bg.strokeColor = new paper.Color(borderColor)
-      bg.strokeWidth = borderWidth
-    }
-
-    if (shadow) {
-      bg.shadowColor = new paper.Color(shadow.color || '#000000')
-      bg.shadowBlur = shadow.blur || 5
-      bg.shadowOffset = new paper.Point(shadow.offsetX || 2, shadow.offsetY || 2)
-    }
-
-    if (opacity !== 1) {
-      bg.opacity = opacity
-    }
-
-    items.push(bg)
-  }
-
-  // 图标内容
-  if (icon) {
-    // 判断是否为图片路径（本地文件、http、data URL）
-    const isImagePath = icon.startsWith('http') || icon.startsWith('data:') ||
-                        (icon.match(/\.(png|jpg|jpeg|gif|svg|webp|bmp)$/i) && !icon.match(/[\u4e00-\u9fa5]/))
-
-    if (isImagePath) {
-      // 图片图标 - 使用 imageLoader
-      const padding = backgroundColor ? 8 : 0
-      const iconSize = size - padding * 2
-      const { raster } = await loadImageAsRaster(project, icon, { x: x + padding, y: y + padding, width: iconSize, height: iconSize }, opacity)
-      items.push(raster)
-    } else {
-      // Emoji 或文字图标
-      const fontSize = Math.min(size * 0.6, 64)
-      const textItem = new paper.PointText({
-        point: [x + size / 2, y + size / 2 + fontSize / 3],
-        content: icon,
-        fontSize,
-        justification: 'center',
-      })
-      if (color) {
-        textItem.fillColor = new paper.Color(color)
-      }
-      if (opacity !== 1) textItem.opacity = opacity
-      items.push(textItem)
-    }
-  }
-
-  return {
-    success: true,
-    type: 'icon',
-    items: items.map(i => i.id),
-  }
-}
-
-module.exports = createIcon