danmu/dist/engine.d.ts

Flexible, cross-platform, powerful danmu library.

import { type Nullable } from 'aidly';
import { Track } from './track';
import { Container } from './container';
import { FacileDanmaku } from './danmaku/facile';
import type {
  EachCallback,
  PushOptions,
  PushFlexOptions,
  DanmakuType,
  RenderOptions,
  EngineOptions,
} from './types';
export declare class Engine<T> {
  private _options;
  rows: number;
  container: Container;
  tracks: Array<Track<T>>;
  private _fx;
  private _sets;
  private _retryMap;
  private _addDestroyQueue;
  private _managerPluginSystem?;
  constructor(_options: EngineOptions);
  /**
   * @internal
   */
  _setManagerPluginSystem(
    managerPluginSystem: NonNullable<typeof this._managerPluginSystem>,
  ): void;
  len(): {
    stash: number;
    flexible: number;
    view: number;
    all: number;
  };
  add(
    data: T | FacileDanmaku<T>,
    options: Required<PushOptions<T>>,
    isUnshift?: boolean,
  ): void;
  updateOptions(newOptions: Partial<EngineOptions>): void;
  clear(type?: Nullable<DanmakuType>): void;
  each(fn: EachCallback<T>): void;
  asyncEach(fn: EachCallback<T>): Promise<void | undefined>;
  format(): void;
  renderFlexibleDanmaku(
    data: T,
    options: Required<PushFlexOptions<T>>,
    { hooks, statuses, danmakuPlugin }: RenderOptions<T>,
  ): boolean;
  renderFacileDanmaku({
    hooks,
    statuses,
    danmakuPlugin,
  }: RenderOptions<T>): void;
  private _consumeFacileDanmaku;
  private _setAction;
  private _create;
  private _calculateSpeed;
  private _getTrackRandom;
  private _getTrack;
  private _collisionPrediction;
}