王明 / Food-Labeling-Management-Platform

  import type {
    MonochromeImageData,
    SystemTemplateElementBase,
    SystemTemplateTextAlign,
  } from './types/printer'
  
  declare const plus: any
  
  const DESIGN_DPI = 96
  const DEFAULT_THRESHOLD = 180
  const TEXT_PADDING_DOTS = 6
  
  function normalizePrinterLikeText (str: string): string {
    return String(str || '')
      .normalize('NFKC')
      .replace(/[\u2018\u2019]/g, '\'')
      .replace(/[\u201C\u201D]/g, '"')
      .replace(/[\u2013\u2014]/g, '-')
  }
  
  type BitmapPatchItem = {
    type: 'bitmap'
    x: number
    y: number
    image: MonochromeImageData
  }
  
  function clamp (value: number, min: number, max: number): number {
    return Math.max(min, Math.min(max, Math.round(value)))
  }
  
  function ensureMultipleOf8 (value: number): number {
    const safe = Math.max(8, Math.round(value || 0))
    return safe % 8 === 0 ? safe : safe + (8 - (safe % 8))
  }
  
  function pxToDots (value: number, dpi: number): number {
    return Math.max(0, Math.round((Number(value) || 0) * dpi / DESIGN_DPI))
  }
  
  function normalizeBase64Payload (source: string): string {
    const value = String(source || '').trim()
    if (!value) return ''
    if (value.startsWith('data:image/')) {
      const index = value.indexOf(',')
      return index >= 0 ? value.slice(index + 1) : ''
    }
    if (/^[A-Za-z0-9+/=\r\n]+$/.test(value) && value.length > 128) {
      return value.replace(/\s+/g, '')
    }
    return ''
  }
  
  function resolveLocalImagePath (source: string): string {
    let path = String(source || '').trim()
    if (!path) return ''
    if (path.startsWith('file://')) {
      path = path.replace(/^file:\/\//, '')
    }
    // #ifdef APP-PLUS
    try {
      const converted = plus.io.convertLocalFileSystemURL(path)
      if (converted) path = converted
    } catch (_) {}
    // #endif
    try {
      path = decodeURIComponent(path)
    } catch (_) {}
    return path
  }
  
  function getAndroidGraphics () {
    // #ifdef APP-PLUS
    try {
      if (typeof plus === 'undefined' || String(plus.os?.name || '').toLowerCase() !== 'android') return null
      return {
        Bitmap: plus.android.importClass('android.graphics.Bitmap'),
        BitmapFactory: plus.android.importClass('android.graphics.BitmapFactory'),
        BitmapConfig: plus.android.importClass('android.graphics.Bitmap$Config'),
        Canvas: plus.android.importClass('android.graphics.Canvas'),
        Paint: plus.android.importClass('android.graphics.Paint'),
        Color: plus.android.importClass('android.graphics.Color'),
        Typeface: plus.android.importClass('android.graphics.Typeface'),
        Base64: plus.android.importClass('android.util.Base64'),
      }
    } catch (error) {
      console.error('getAndroidGraphics failed', error)
      return null
    }
    // #endif
    // #ifndef APP-PLUS
    return null
    // #endif
  }
  
  function bitmapToMonochromeImage (
    bitmap: any,
    threshold = DEFAULT_THRESHOLD
  ): MonochromeImageData {
    const bitmapWidth = Number(bitmap.getWidth ? bitmap.getWidth() : 0)
    const bitmapHeight = Number(bitmap.getHeight ? bitmap.getHeight() : 0)
    const width = ensureMultipleOf8(bitmapWidth)
    const height = Math.max(1, bitmapHeight)
    const pixels: number[] = new Array(width * height).fill(0)
  
    for (let y = 0; y < height; y++) {
      for (let x = 0; x < width; x++) {
        if (x >= bitmapWidth) {
          pixels[y * width + x] = 0
          continue
        }
        const color = Number(bitmap.getPixel(x, y))
        const alpha = (color >>> 24) & 0xff
        const red = (color >>> 16) & 0xff
        const green = (color >>> 8) & 0xff
        const blue = color & 0xff
        const gray = red * 0.299 + green * 0.587 + blue * 0.114
        pixels[y * width + x] = alpha <= 10 || gray > threshold ? 0 : 1
      }
    }
  
    return { width, height, pixels }
  }
  
  function splitTextLines (text: string, paint: any, maxWidth: number): string[] {
    const lines: string[] = []
    const rawLines = String(text || '').replace(/\r/g, '').split('\n')
  
    const pushLongWordByChars = (word: string) => {
      let buf = ''
      for (let i = 0; i < word.length; i++) {
        const ch = word.charAt(i)
        const trial = buf + ch
        if (buf && Number(paint.measureText(trial)) > maxWidth) {
          lines.push(buf)
          buf = ch
        } else {
          buf = trial
        }
      }
      return buf
    }
  
    rawLines.forEach((segment) => {
      if (!segment) {
        lines.push('')
        return
      }
      if (!segment.trim()) {
        lines.push(segment)
        return
      }
  
      const words = segment.trim().split(/\s+/)
      let current = ''
      for (const word of words) {
        const trial = current ? `${current} ${word}` : word
        if (Number(paint.measureText(trial)) <= maxWidth) {
          current = trial
        } else {
          if (current) lines.push(current)
          if (Number(paint.measureText(word)) <= maxWidth) {
            current = word
          } else {
            current = pushLongWordByChars(word)
          }
        }
      }
      if (current) lines.push(current)
    })
  
    return lines.length > 0 ? lines : ['']
  }
  
  export function shouldRasterizeTextElement (text: string, type: string): boolean {
    const normalizedType = String(type || '').toUpperCase()
    const normalizedText = normalizePrinterLikeText(text)
    if (!normalizedText) return false
    /**
     * TEXT_PRICE：d320fax 等走 TSC 内置字体时常丢整行（￥、小数点、数字组合）。
     * 只要非空一律走位图，与画布一致；App 端 createTextBitmapPatch 失败时再回退 TSC。
     */
    if (normalizedType === 'TEXT_PRICE') return true
    if (/[€£¥￥éÉáàâäãåæçèêëìíîïñòóôöõøùúûüýÿœšž]/.test(normalizedText)) return true
    return /[^\x20-\x7E]/.test(normalizedText)
  }
  
  export function createTextBitmapPatch (params: {
    element: SystemTemplateElementBase
    text: string
    dpi: number
    align: SystemTemplateTextAlign
  }): BitmapPatchItem | null {
    const graphics = getAndroidGraphics()
    if (!graphics) return null
  
    const { element, text, dpi, align } = params
    const config = element.config || {}
    const Bitmap = graphics.Bitmap
    const BitmapConfig = graphics.BitmapConfig
    const Canvas = graphics.Canvas
    const Paint = graphics.Paint
    const Color = graphics.Color
    const Typeface = graphics.Typeface
  
    const contentWidth = Math.max(8, pxToDots(element.width, dpi))
    const width = ensureMultipleOf8(contentWidth + TEXT_PADDING_DOTS * 2)
    const height = Math.max(16, pxToDots(element.height, dpi) + TEXT_PADDING_DOTS * 2)
    const bitmap = Bitmap.createBitmap(width, height, BitmapConfig.ARGB_8888)
    const canvas = new Canvas(bitmap)
    canvas.drawColor(Color.WHITE)
  
    const paint = new Paint()
    paint.setAntiAlias(true)
    paint.setDither(true)
    paint.setColor(Color.BLACK)
    paint.setSubpixelText(true)
    const fontSizeDots = Math.max(14, pxToDots(Number(config.fontSize || 14), dpi))
    paint.setTextSize(fontSizeDots)
    const isBold = String(config.fontWeight || '').toLowerCase() === 'bold' || String(element.type || '').toUpperCase() === 'TEXT_PRICE'
    paint.setFakeBoldText(isBold)
    paint.setTypeface(isBold ? Typeface.DEFAULT_BOLD : Typeface.DEFAULT)
  
    const maxTextWidth = Math.max(8, contentWidth)
    const lines = splitTextLines(text, paint, maxTextWidth)
    const fontMetrics = paint.getFontMetrics()
    const lineHeight = Math.max(
      fontSizeDots + 2,
      Math.ceil(Math.abs(Number(fontMetrics.top)) + Math.abs(Number(fontMetrics.bottom)) + 2)
    )
    const totalHeight = lines.length * lineHeight
    const isCenteredVertically = String(element.type || '').toUpperCase() === 'TEXT_PRICE'
    const topOffset = isCenteredVertically
      ? Math.max(TEXT_PADDING_DOTS, Math.floor((height - totalHeight) / 2))
      : TEXT_PADDING_DOTS
  
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i]
      const lineWidth = Number(paint.measureText(line))
      let drawX = TEXT_PADDING_DOTS
      if (align === 'center') {
        drawX = TEXT_PADDING_DOTS + Math.max(0, Math.round((maxTextWidth - lineWidth) / 2))
      } else if (align === 'right') {
        drawX = TEXT_PADDING_DOTS + Math.max(0, Math.round(maxTextWidth - lineWidth))
      }
      const baseline = topOffset + i * lineHeight - Number(fontMetrics.top)
      canvas.drawText(line, drawX, baseline, paint)
    }
  
    const image = bitmapToMonochromeImage(bitmap)
    try {
      bitmap.recycle && bitmap.recycle()
    } catch (_) {}
  
    return {
      type: 'bitmap',
      x: Math.max(0, pxToDots(element.x, dpi) - TEXT_PADDING_DOTS),
      y: Math.max(0, pxToDots(element.y, dpi) - TEXT_PADDING_DOTS),
      image,
    }
  }
  
  function decodeSourceBitmap (source: string, graphics: ReturnType<typeof getAndroidGraphics>) {
    if (!graphics) return null
    const rawSource = String(source || '').trim()
    if (!rawSource) return null
  
    const base64Payload = normalizeBase64Payload(rawSource)
    if (base64Payload) {
      const bytes = graphics.Base64.decode(base64Payload, 0)
      return graphics.BitmapFactory.decodeByteArray(bytes, 0, bytes.length)
    }
  
    const localPath = resolveLocalImagePath(rawSource)
    if (!localPath) return null
    return graphics.BitmapFactory.decodeFile(localPath)
  }
  
  export function createImageBitmapPatch (params: {
    element: SystemTemplateElementBase
    dpi: number
  }): BitmapPatchItem | null {
    const graphics = getAndroidGraphics()
    if (!graphics) return null
  
    const { element, dpi } = params
    const config = element.config || {}
    const sourceBitmap = decodeSourceBitmap(String(config.src || config.data || config.url || ''), graphics)
    if (!sourceBitmap) return null
  
    const Bitmap = graphics.Bitmap
    const BitmapConfig = graphics.BitmapConfig
    const Canvas = graphics.Canvas
    const Paint = graphics.Paint
    const Color = graphics.Color
  
    const width = ensureMultipleOf8(Math.max(8, pxToDots(element.width, dpi)))
    const height = Math.max(8, pxToDots(element.height, dpi))
    const outputBitmap = Bitmap.createBitmap(width, height, BitmapConfig.ARGB_8888)
    const canvas = new Canvas(outputBitmap)
    canvas.drawColor(Color.WHITE)
  
    const sourceWidth = Number(sourceBitmap.getWidth ? sourceBitmap.getWidth() : 0)
    const sourceHeight = Number(sourceBitmap.getHeight ? sourceBitmap.getHeight() : 0)
    const scaleMode = String(config.scaleMode || 'contain').toLowerCase()
  
    let targetWidth = width
    let targetHeight = height
    let targetLeft = 0
    let targetTop = 0
  
    if (sourceWidth > 0 && sourceHeight > 0 && scaleMode !== 'fill') {
      const ratio = scaleMode === 'cover'
        ? Math.max(width / sourceWidth, height / sourceHeight)
        : Math.min(width / sourceWidth, height / sourceHeight)
      targetWidth = Math.max(1, Math.round(sourceWidth * ratio))
      targetHeight = Math.max(1, Math.round(sourceHeight * ratio))
      targetLeft = Math.round((width - targetWidth) / 2)
      targetTop = Math.round((height - targetHeight) / 2)
    }
  
    const scaledBitmap = Bitmap.createScaledBitmap(sourceBitmap, targetWidth, targetHeight, true)
    const paint = new Paint()
    paint.setAntiAlias(true)
    paint.setFilterBitmap(true)
    canvas.drawBitmap(scaledBitmap, targetLeft, targetTop, paint)
  
    const image = bitmapToMonochromeImage(outputBitmap, Number(config.threshold || DEFAULT_THRESHOLD))
  
    try {
      scaledBitmap?.recycle && scaledBitmap.recycle()
    } catch (_) {}
    try {
      sourceBitmap?.recycle && sourceBitmap.recycle()
    } catch (_) {}
    try {
      outputBitmap?.recycle && outputBitmap.recycle()
    } catch (_) {}
  
    return {
      type: 'bitmap',
      x: pxToDots(element.x, dpi),
      y: pxToDots(element.y, dpi),
      image,
    }
  }