@dan-uni/dan-any 1.4.8 → 2.0.0

package/src/ass-gen/util/index.ts

@@ -1,10 +0,0 @@
-export {
-  decimalColorToRGB,
-  formatColor,
-  getDecoratingColor,
-  hexColorToRGB,
-  isWhite,
-} from './color'
-export { DanmakuList2UniPool, UniPool2DanmakuLists } from './danconvert'
-export { arrayOfLength, assign, uniqueArray } from './lang'
-export { layoutDanmaku } from './layout'

package/src/ass-gen/util/lang.ts

@@ -1,35 +0,0 @@
-export const assign = <T extends object>(
-  source: T,
-  ...targets: Partial<T>[]
-): T => {
-  for (const target of targets) {
-    for (const key of Object.keys(target)) {
-      ;(source as any)[key] = target[key as keyof typeof target]
-    }
-  }
-
-  return source
-}
-
-export const arrayOfLength = <T>(length: number, defaultValue: T): T[] => {
-  // eslint-disable-next-line unicorn/no-new-array
-  const array = new Array(length)
-  for (let i = 0; i < length; i++) {
-    array[i] = defaultValue
-  }
-  return array
-}
-
-export const uniqueArray = <T>(array: T[]) => {
-  const duplicates: T[] = []
-  const result: T[] = []
-
-  for (const item of array) {
-    if (!duplicates.includes(item)) {
-      duplicates.push(item)
-      result.push(item)
-    }
-  }
-
-  return result
-}

package/src/ass-gen/util/layout.ts

@@ -1,242 +0,0 @@
-import type { UniPool } from '../..'
-import type { CanvasCtx, Danmaku, SubtitleStyle } from '../types'
-
-import { DanmakuType, FontSize } from '../types'
-import { DanmakuList2UniPool, UniPool2DanmakuLists } from './danconvert'
-import { arrayOfLength } from './lang'
-
-// 计算一个矩形移进屏幕的时间（头进屏幕到尾巴进屏幕）
-const computeScrollInTime = (
-  rectWidth: number,
-  screenWidth: number,
-  scrollTime: number,
-) => {
-  const speed = (screenWidth + rectWidth) / scrollTime
-  return rectWidth / speed
-}
-
-// 计算一个矩形在屏幕上的时间（头进屏幕到头离开屏幕）
-const computeScrollOverTime = (
-  rectWidth: number,
-  screenWidth: number,
-  scrollTime: number,
-) => {
-  const speed = (screenWidth + rectWidth) / scrollTime
-  return screenWidth / speed
-}
-
-interface ScrollGrid {
-  start: number
-  end: number
-  width: number
-}
-
-type FixGrid = number
-
-interface DanmakuGrids {
-  // [DanmakuType.SCROLL]: ScrollGrid[];
-  // [DanmakuType.TOP]: FixGrid[];
-  // [DanmakuType.BOTTOM]: FixGrid[];
-  1: ScrollGrid[] // DanmakuType.SCROLL
-  3: FixGrid[] // DanmakuType.TOP
-  2: FixGrid[] // DanmakuType.BOTTOM
-}
-
-const splitGrids = ({
-  fontSize,
-  padding,
-  playResY,
-  bottomSpace,
-}: {
-  fontSize: number[]
-  padding: number[]
-  playResY: number
-  bottomSpace: number
-}): DanmakuGrids => {
-  const defaultFontSize = fontSize[FontSize.NORMAL]
-  const paddingTop = padding[0]
-  const paddingBottom = padding[2]
-  const linesCount = Math.floor(
-    (playResY - bottomSpace) / (defaultFontSize + paddingTop + paddingBottom),
-  )
-
-  // 首先以通用的字号把屏幕的高度分成若干行，字幕只允许落在一个行里
-  return {
-    // 每一行里的数字是当前在这一行里的最后一条弹幕区域（算入padding）的右边离开屏幕的时间，
-    // 这个时间和下一条弹幕的左边离开屏幕的时间相比较，能确定在整个弹幕的飞行过程中是否会相撞（不同长度弹幕飞行速度不同）|,
-    // 当每一条弹幕加到一行里时，就会把这个时间算出来，获取新的弹幕时就可以判断哪一行是允许放的就放进去
-    1: arrayOfLength(linesCount, {
-      start: 0,
-      end: 0,
-      width: 0,
-    }),
-    // 对于固定的弹幕，每一行里都存放弹幕的消失时间，只要这行的弹幕没消失就不能放新弹幕进来
-    3: arrayOfLength(linesCount, 0),
-    2: arrayOfLength(linesCount, 0),
-  }
-}
-
-export const measureTextWidthConstructor = (canvasContext: CanvasCtx) => {
-  const supportTextMeasure = !!canvasContext.measureText('中')
-
-  if (supportTextMeasure) {
-    return (
-      fontName: string,
-      fontSize: number,
-      bold: boolean,
-      text: string,
-    ) => {
-      canvasContext.font = `${bold ? 'bold' : 'normal'} ${fontSize}px ${fontName}`
-      const textWidth = canvasContext.measureText(text).width
-      return Math.round(textWidth)
-    }
-  }
-
-  console.warn(
-    '[Warn] node-canvas is installed without text measure support, layout may not be correct',
-  )
-  return (_fontName: string, fontSize: number, _bold: boolean, text: string) =>
-    text.length * fontSize
-}
-
-// 找到能用的行
-const resolveAvailableFixGrid = (grids: FixGrid[], time: number) => {
-  for (const [i, grid] of grids.entries()) {
-    if (grid <= time) {
-      return i
-    }
-  }
-
-  return -1
-}
-
-const resolveAvailableScrollGrid = (
-  grids: ScrollGrid[],
-  rectWidth: number,
-  screenWidth: number,
-  time: number,
-  duration: number,
-) => {
-  for (const [i, previous] of grids.entries()) {
-    // 对于滚动弹幕，要算两个位置：
-    //
-    // 1. 前一条弹幕的尾巴进屏幕之前，后一条弹幕不能开始出现
-    // 2. 前一条弹幕的尾巴离开屏幕之前，后一条弹幕的头不能离开屏幕
-    const previousInTime =
-      previous.start +
-      computeScrollInTime(previous.width, screenWidth, duration)
-    const currentOverTime =
-      time + computeScrollOverTime(rectWidth, screenWidth, duration)
-
-    if (time >= previousInTime && currentOverTime >= previous.end) {
-      return i
-    }
-  }
-
-  return -1
-}
-
-const initializeLayout = (config: SubtitleStyle, canvasCtx: CanvasCtx) => {
-  const {
-    playResX,
-    playResY,
-    fontName,
-    fontSize,
-    bold,
-    padding,
-    scrollTime,
-    fixTime,
-    bottomSpace,
-  } = config
-  const [paddingTop, paddingRight, paddingBottom, paddingLeft] = padding
-
-  const defaultFontSize = fontSize[FontSize.NORMAL]
-  const grids = splitGrids(config)
-  const gridHeight = defaultFontSize + paddingTop + paddingBottom
-
-  return (danmaku: Danmaku) => {
-    const targetGrids = grids[danmaku.type as keyof DanmakuGrids]
-    const danmakuFontSize = fontSize[danmaku.fontSizeType]
-    const rectWidth =
-      measureTextWidthConstructor(canvasCtx)(
-        fontName,
-        danmakuFontSize,
-        bold,
-        danmaku.content,
-      ) +
-      paddingLeft +
-      paddingRight
-    const verticalOffset =
-      paddingTop + Math.round((defaultFontSize - danmakuFontSize) / 2)
-
-    if (danmaku.type === DanmakuType.SCROLL) {
-      const scrollGrids = targetGrids as ScrollGrid[]
-      const gridNumber = resolveAvailableScrollGrid(
-        scrollGrids,
-        rectWidth,
-        playResX,
-        danmaku.time,
-        scrollTime,
-      )
-      if (gridNumber < 0) {
-        // console.warn(`[Warn] Collision ${danmaku.time}: ${danmaku.content}`)
-        return null
-      }
-      targetGrids[gridNumber] = {
-        width: rectWidth,
-        start: danmaku.time,
-        end: danmaku.time + scrollTime,
-      }
-
-      const top = gridNumber * gridHeight + verticalOffset
-      const start = playResX + paddingLeft
-      const end = -rectWidth
-
-      return { ...danmaku, top, start, end }
-    } else {
-      const gridNumber = resolveAvailableFixGrid(
-        targetGrids as FixGrid[],
-        danmaku.time,
-      )
-      if (gridNumber < 0) {
-        // console.warn(`[Warn] Collision ${danmaku.time}: ${danmaku.content}`)
-        return null
-      }
-      if (danmaku.type === DanmakuType.TOP) {
-        targetGrids[gridNumber] = danmaku.time + fixTime
-
-        const top = gridNumber * gridHeight + verticalOffset
-        // 固定弹幕横向按中心点计算
-        const left = Math.round(playResX / 2)
-
-        return { ...danmaku, top, left }
-      }
-
-      targetGrids[gridNumber] = danmaku.time + fixTime
-
-      // 底部字幕的格子是留出`bottomSpace`的位置后从下往上算的
-      const top =
-        playResY -
-        bottomSpace -
-        gridHeight * gridNumber -
-        gridHeight +
-        verticalOffset
-      const left = Math.round(playResX / 2)
-
-      return { ...danmaku, top, left }
-    }
-  }
-}
-
-export const layoutDanmaku = (
-  inputList: UniPool,
-  config: SubtitleStyle,
-  canvasCtx: CanvasCtx,
-): UniPool => {
-  const list = [...UniPool2DanmakuLists(inputList)].toSorted(
-    (x, y) => x.time - y.time,
-  )
-  const layout = initializeLayout(config, canvasCtx)
-
-  return DanmakuList2UniPool(list.map(layout).filter((danmaku) => !!danmaku))
-}

package/src/index.test.ts

@@ -1,157 +0,0 @@
-import { createCanvas } from 'canvas'
-import { describe, expect, it } from 'vitest'
-
-import { UniPool } from './index'
-
-const xml = `<i>
-<chatserver>chat.bilibili.com</chatserver>
-<chatid>1156756312</chatid>
-<mission>0</mission>
-<maxlimit>2947</maxlimit>
-<state>0</state>
-<real_name>0</real_name>
-<source>k-v</source>
-<d p="13.213,1,25,16777215,1686314041,3,ff41173d,1335658005672492032">喜欢</d>
-<d p="13.213,1,25,16777215,1686590010,0,296b35b5,1337972999512832512">来了 哈哈~~</d>
-<d p="13.246,1,25,16777215,1686276875,0,5664cfc4,1335346233459549696">就是</d>
-<d p="13.266,1,25,16777215,1686283375,0,c7e6646f,1335400761013670912">什么鬼？</d>
-<d p="13.284,1,25,16777215,1686291338,0,38662881,1335467554877267456">哇哦</d>
-<d p="13.306,1,25,16777215,1686268410,0,4c01de10,1335275224983600896">试试</d>
-<d p="13.331,1,25,16777215,1686948453,3,56a3c5d5,1340979831550069760">不喜欢</d>
-<d p="13.374,1,25,16777215,1686300770,3,647fe355,1335546672880933888">不喜欢</d>
-<d p="13.376,1,25,16777215,1686297921,0,469d94b8,1335522778300134400">哦豁</d>
-<d p="13.419,1,25,8700107,1686268005,0,be402447,1335271828100244224">太酷啦</d>
-<d p="13.419,1,25,16777215,1686316828,3,7ffb6619,1335681385016736768">喜欢</d>
-<d p="13.459,1,25,16777215,1686299729,0,45834405,1335537942797634048">一般，不好看</d>
-<d p="13.462,1,25,16777215,1686302133,0,3cab672c,1335558106620590080">哈哈哈</d>
-<d p="13.481,1,25,16777215,1686297342,0,ce67fafd,1335517923728804864">？</d>
-<d p="13.499,1,25,16777215,1686301548,3,2848bf1c,1335553202649003264">不喜欢</d>
-</i>`
-describe('转化自', () => {
-  it('bili(xml)[双向]', () => {
-    const pool = UniPool.fromBiliXML(xml)
-    console.info(xml)
-    console.info(pool)
-    console.info(pool.toBiliXML())
-    console.info(pool.toBiliXML({ avoidSenderIDWithAt: true }))
-    const imp = UniPool.import(xml)
-    expect(imp.fmt).toBe('bili.xml')
-    expect(imp.pool).toEqual(pool)
-    const imp2 = UniPool.import(xml, undefined, 'test-bili.xml')
-    expect(imp2).toEqual(imp)
-  })
-  it('artplayer(json)', () => {
-    const json = {
-      danmuku: [
-        {
-          text: 'artplayer测试弹幕', // 弹幕文本
-          time: 10, // 弹幕时间, 默认为当前播放器时间
-          mode: 0, // 弹幕模式: 0: 滚动(默认)，1: 顶部，2: 底部
-          color: '#FFFFFF', // 弹幕颜色，默认为白色
-          border: false, // 弹幕是否有描边, 默认为 false
-          style: { border: '10rem' }, // 弹幕自定义样式, 默认为空对象
-        },
-      ],
-    }
-    const pool = UniPool.fromArtplayer(json, 'playerid-test', 'acfun')
-    console.info(json)
-    console.info(pool)
-    const imp = UniPool.import(json)
-    expect(imp.fmt).toBe('artplayer.json')
-    // 该适配器ctime始终为now，无法双向测试
-    // expect(imp.pool).toEqual(pool)
-    UniPool.import(json, undefined, 'test-artplayer.json')
-    // expect(imp2).toEqual(imp)
-  })
-  it('ass[双向]', () => {
-    const canvas = createCanvas(50, 50)
-    const pool = UniPool.fromBiliXML(xml)
-    const ass = pool.toASS(canvas.getContext('2d'))
-    console.info(ass)
-    console.info(UniPool.fromASS(ass))
-    const imp = UniPool.import(ass)
-    expect(imp.fmt).toBe('common.ass')
-    expect(imp.pool).toEqual(pool)
-    const imp2 = UniPool.import(ass, undefined, 'test-common.ass')
-    expect(imp2).toEqual(imp)
-  })
-  it('pb[双向]', () => {
-    const pool = UniPool.fromBiliXML(xml)
-    const pb = pool.toPb()
-    console.info(UniPool.fromPb(pb))
-    const imp = UniPool.import(pb)
-    expect(imp.fmt).toBe('danuni.binpb')
-    expect(imp.pool).toEqual(pool)
-    const imp2 = UniPool.import(pb, undefined, 'test-danuni.binpb')
-    expect(imp2).toEqual(imp)
-  })
-  it('DDPlay[双向]', () => {
-    const pool = UniPool.fromBiliXML(xml)
-    const ddplay = pool.toDDPlay()
-    console.info(UniPool.fromDDPlay(ddplay, '1'))
-    const imp = UniPool.import(ddplay)
-    expect(imp.fmt).toBe('ddplay.json')
-    // 该适配器ctime始终为now，无法双向测试
-    UniPool.import(ddplay, undefined, 'test-ddplay.json')
-    // expect(imp2).toEqual(imp)
-  })
-  it('min[双向]', () => {
-    const pool = UniPool.fromBiliXML(xml)
-    const min = pool.minify()
-    console.info(min)
-    const imp = UniPool.import(min)
-    expect(imp.fmt).toBe('danuni.min.json')
-    // 该适配器ctime始终为now，无法双向测试
-    // expect(imp.pool).toEqual(pool)
-    UniPool.import(min, undefined, 'test-danuni.min.json')
-    // expect(imp2).toEqual(imp)
-  })
-})
-
-describe('共通值', () => {
-  const pool = UniPool.fromBiliXML(xml)
-  it('获取shared', () => {
-    console.info(pool.getMost('SOID'))
-    console.info(pool.shared)
-    expect(pool.getShared('SOID')).toBe(pool.shared.SOID)
-  })
-  it('获取most', () => {
-    console.info(pool.getMost('senderID'))
-    console.info(pool.most)
-    expect(pool.getMost('senderID').val).toBe(pool.most.senderID)
-  })
-  it('按pool分组', () => {
-    console.info(pool.split('pool'))
-  })
-})
-
-describe('其它', () => {
-  const pool = UniPool.fromBiliXML(xml)
-  it('最小化', () => {
-    console.info(pool.minify())
-  })
-  it('合并范围内重复', () => {
-    console.info(pool.merge(10).minify())
-  })
-  it('禁止DMID生成', () => {
-    console.info(
-      UniPool.fromBiliXML(xml, {
-        dmid: false,
-      }),
-    )
-  })
-  it('自定义DMID生成长度', () => {
-    console.info(
-      UniPool.fromBiliXML(xml, {
-        dmid: 64,
-      }),
-    )
-  })
-  it('自定义DMID生成器', () => {
-    console.info(
-      UniPool.fromBiliXML(xml, {
-        dmid: (dan) => dan.ctime.toString() + Math.random(),
-      }),
-    )
-  })
-})