@vunk/plus 1.10.1 → 1.10.3

package/shared/audioToFrames/src/audio/StreamingFeatureExtractorService.d.ts

@@ -1,125 +0,0 @@
-/**
- * @file StreamingFeatureExtractorService.ts
- *
- * 流式音频特征提取服务模块。
- * 1. 支持将长音频分割为5秒的chunk进行增量特征提取，显著降低首帧视频延迟。
- * 2. 每个chunk独立提取特征，处理完成后立即通过回调通知上层。
- * 3. 所有chunk处理完成后自动合并特征，输出完整特征序列。
- *
- * @author Zhonghan Li
- */
-/**
- * 创建AudioContext的兼容函数，处理Safari的限制。
- * 在Safari中，AudioContext需要在用户交互后才能创建。
- */
-export declare function createAudioContext(): Promise<AudioContext>;
-/**
- * 特征提取结果接口
- */
-export interface FeatureExtractionResult {
-    features: Float32Array;
-    dimensions: number[];
-}
-/**
- * 单个chunk的特征提取结果结构体。
- */
-export interface ChunkFeatureResult {
-    /** chunk索引（从0开始） */
-    chunkIndex: number;
-    /** 特征数据（Float32Array） */
-    features: Float32Array;
-    /** 特征维度信息 [帧数, 序列长度, mel频带数] */
-    dimensions: number[];
-    /** chunk起始时间（秒） */
-    startTimeSeconds: number;
-    /** chunk结束时间（秒） */
-    endTimeSeconds: number;
-}
-/**
- * 流式特征提取回调接口定义。
- */
-export interface StreamingCallbacks {
-    /**
-     * 单个chunk处理完成时回调。
-     * @param result 当前chunk的特征结果。
-     */
-    onChunkComplete?: (result: ChunkFeatureResult) => void;
-    /**
-     * 进度更新回调。
-     * @param completed 已完成的chunk数。
-     * @param total 总chunk数。
-     */
-    onProgress?: (completed: number, total: number) => void;
-    /**
-     * 全部chunk处理完成时回调。
-     * @param totalDimensions 合并后特征的维度信息。
-     */
-    onComplete?: (totalDimensions: number[]) => void;
-    /**
-     * 处理出错时回调。
-     * @param error 错误信息。
-     */
-    onError?: (error: string) => void;
-}
-/**
- * 流式音频特征提取服务类。
- * 支持将长音频分块并行处理，实时回调chunk结果，最终合并输出全部特征。
- */
-export declare class StreamingFeatureExtractorService {
-    private queue;
-    /** 回调函数集合 */
-    private callbacks;
-    /** 存储每个chunk的处理结果，用于最终合并 */
-    private chunkResults;
-    /** 音频总chunk数 */
-    private totalChunks;
-    /** 已完成的chunk数 */
-    private completedChunks;
-    /** 已处理的总帧数累加器 */
-    private totalFramesProcessed;
-    /** 当前是否有任务在运行 */
-    private isRunning;
-    /** 当前处理的音频缓冲区 */
-    private audioBuffer;
-    /** 音频上下文实例，用于创建AudioBuffer */
-    private audioContext;
-    /** 复用的Worker实例，以提高性能 */
-    private worker;
-    /**
-     * 创建AudioBuffer的兼容方法，处理Safari的限制。
-     * @param numberOfChannels 声道数
-     * @param length 缓冲区长度
-     * @param sampleRate 采样率
-     * @returns AudioBuffer实例
-     */
-    private createAudioBuffer;
-    /**
-     * 使用Worker处理AudioBuffer，提取特征
-     * @param audioBuffer 输入的AudioBuffer
-     * @returns Promise<FeatureExtractionResult>
-     */
-    private processWithWorker;
-    /**
-     * 启动流式音频特征提取。
-     * @param audioBuffer 输入的音频缓冲区。
-     * @param callbacks 处理过程中的回调函数集合。
-     */
-    processStreaming(audioBuffer: AudioBuffer, callbacks: StreamingCallbacks): Promise<void>;
-    /**
-     * 处理单个音频chunk，提取特征并回调。
-     * @param chunkIndex chunk的索引（从0开始）。
-     */
-    private processChunk;
-    /**
-     * 所有chunk处理完成后，合并特征并调用onComplete。
-     */
-    private finalize;
-    /**
-     * 清理内部状态和资源。
-     */
-    private cleanup;
-    /**
-     * 停止当前的流式处理。
-     */
-    stop(): void;
-}

package/shared/audioToFrames/src/audio/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * @file 音频处理服务模块导出
- * @author Zhonghan Li
- */
-export * from './StreamingFeatureExtractorService';

package/shared/audioToFrames/src/audio/index.mjs

@@ -1,375 +0,0 @@
-import { w as workerConfig } from '../../../config.mjs';
-import { C as CHUNK_DURATION_SECONDS, a as NUM_SEQUENCE_FRAMES, N as NUM_MEL_BINS } from '../../../constants.mjs';
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// src/lib/_AsyncQueueEntry.ts
-var _AsyncQueueEntry = class _AsyncQueueEntry {
-  constructor(queue) {
-    __publicField(this, "promise");
-    __publicField(this, "resolve");
-    __publicField(this, "reject");
-    __publicField(this, "queue");
-    __publicField(this, "signal", null);
-    __publicField(this, "signalListener", null);
-    this.queue = queue;
-    this.promise = new Promise((resolve, reject) => {
-      this.resolve = resolve;
-      this.reject = reject;
-    });
-  }
-  setSignal(signal) {
-    if (signal.aborted) return this;
-    this.signal = signal;
-    this.signalListener = () => {
-      const index = this.queue["promises"].indexOf(this);
-      if (index !== -1) this.queue["promises"].splice(index, 1);
-      this.reject(new Error("Request aborted manually"));
-    };
-    this.signal.addEventListener("abort", this.signalListener);
-    return this;
-  }
-  use() {
-    this.dispose();
-    this.resolve();
-    return this;
-  }
-  abort() {
-    this.dispose();
-    this.reject(new Error("Request aborted manually"));
-    return this;
-  }
-  dispose() {
-    if (this.signal) {
-      this.signal.removeEventListener("abort", this.signalListener);
-      this.signal = null;
-      this.signalListener = null;
-    }
-  }
-};
-__name(_AsyncQueueEntry, "AsyncQueueEntry");
-var AsyncQueueEntry = _AsyncQueueEntry;
-
-// src/lib/AsyncQueue.ts
-var _AsyncQueue = class _AsyncQueue {
-  constructor() {
-    /**
-     * The promises array
-     */
-    __publicField(this, "promises", []);
-  }
-  /**
-   * The amount of entries in the queue, including the head.
-   * @seealso {@link queued} for the queued count.
-   */
-  get remaining() {
-    return this.promises.length;
-  }
-  /**
-   * The amount of queued entries.
-   * @seealso {@link remaining} for the count with the head.
-   */
-  get queued() {
-    return this.remaining === 0 ? 0 : this.remaining - 1;
-  }
-  /**
-   * Waits for last promise and queues a new one
-   * @example
-   * ```typescript
-   * const queue = new AsyncQueue();
-   * async function request(url, options) {
-   *     await queue.wait({ signal: options.signal });
-   *     try {
-   *         const result = await fetch(url, options);
-   *         // Do some operations with 'result'
-   *     } finally {
-   *         // Remove first entry from the queue and resolve for the next entry
-   *         queue.shift();
-   *     }
-   * }
-   *
-   * request(someUrl1, someOptions1); // Will call fetch() immediately
-   * request(someUrl2, someOptions2); // Will call fetch() after the first finished
-   * request(someUrl3, someOptions3); // Will call fetch() after the second finished
-   * ```
-   */
-  wait(options) {
-    const entry = new AsyncQueueEntry(this);
-    if (this.promises.length === 0) {
-      this.promises.push(entry);
-      return Promise.resolve();
-    }
-    this.promises.push(entry);
-    if (options?.signal) entry.setSignal(options.signal);
-    return entry.promise;
-  }
-  /**
-   * Unlocks the head lock and transfers the next lock (if any) to the head.
-   */
-  shift() {
-    if (this.promises.length === 0) return;
-    if (this.promises.length === 1) {
-      this.promises.shift();
-      return;
-    }
-    this.promises.shift();
-    this.promises[0].use();
-  }
-  /**
-   * Aborts all the pending promises.
-   * @note To avoid race conditions, this does **not** unlock the head lock.
-   */
-  abortAll() {
-    if (this.queued === 0) return;
-    for (let i = 1; i < this.promises.length; ++i) {
-      this.promises[i].abort();
-    }
-    this.promises.length = 1;
-  }
-};
-__name(_AsyncQueue, "AsyncQueue");
-var AsyncQueue = _AsyncQueue;
-
-async function createAudioContext() {
-  const AudioContextClass = window.AudioContext || window.webkitAudioContext;
-  if (!AudioContextClass) {
-    throw new Error("\u60A8\u7684\u6D4F\u89C8\u5668\u4E0D\u652F\u6301Web Audio API");
-  }
-  const audioContext = new AudioContextClass();
-  if (audioContext.state === "suspended") {
-    await audioContext.resume();
-  }
-  return audioContext;
-}
-class StreamingFeatureExtractorService {
-  constructor() {
-    this.queue = new AsyncQueue();
-    /** 回调函数集合 */
-    this.callbacks = {};
-    /** 存储每个chunk的处理结果，用于最终合并 */
-    this.chunkResults = [];
-    /** 音频总chunk数 */
-    this.totalChunks = 0;
-    /** 已完成的chunk数 */
-    this.completedChunks = 0;
-    /** 已处理的总帧数累加器 */
-    this.totalFramesProcessed = 0;
-    /** 当前是否有任务在运行 */
-    this.isRunning = false;
-    /** 当前处理的音频缓冲区 */
-    this.audioBuffer = null;
-    /** 音频上下文实例，用于创建AudioBuffer */
-    this.audioContext = null;
-    /** 复用的Worker实例，以提高性能 */
-    this.worker = null;
-  }
-  /**
-   * 创建AudioBuffer的兼容方法，处理Safari的限制。
-   * @param numberOfChannels 声道数
-   * @param length 缓冲区长度
-   * @param sampleRate 采样率
-   * @returns AudioBuffer实例
-   */
-  async createAudioBuffer(numberOfChannels, length, sampleRate) {
-    try {
-      return new AudioBuffer({
-        numberOfChannels,
-        length,
-        sampleRate
-      });
-    } catch {
-      if (!this.audioContext) {
-        const AudioContextClass = window.AudioContext || window.webkitAudioContext;
-        this.audioContext = new AudioContextClass();
-      }
-      return this.audioContext.createBuffer(
-        numberOfChannels,
-        length,
-        sampleRate
-      );
-    }
-  }
-  /**
-   * 使用Worker处理AudioBuffer，提取特征
-   * @param audioBuffer 输入的AudioBuffer
-   * @returns Promise<FeatureExtractionResult>
-   */
-  async processWithWorker(audioBuffer) {
-    if (!this.worker) {
-      throw new Error("Worker not initialized");
-    }
-    return new Promise((resolve, reject) => {
-      const cleanup = () => {
-        if (this.worker) {
-          this.worker.removeEventListener("message", handleMessage);
-          this.worker.removeEventListener("error", handleError);
-        }
-      };
-      function handleMessage(event) {
-        cleanup();
-        if (event.data.status === "success") {
-          resolve(event.data.payload);
-        } else {
-          reject(new Error(event.data.error || "Unknown worker error"));
-        }
-      }
-      function handleError(error) {
-        cleanup();
-        reject(error);
-      }
-      this.worker.addEventListener("message", handleMessage);
-      this.worker.addEventListener("error", handleError);
-      const leftChannel = audioBuffer.getChannelData(0);
-      const rightChannel = audioBuffer.numberOfChannels > 1 ? audioBuffer.getChannelData(1) : void 0;
-      const message = {
-        leftChannel,
-        rightChannel,
-        sampleRate: audioBuffer.sampleRate
-      };
-      const transferList = [leftChannel.buffer, rightChannel?.buffer].filter(Boolean);
-      this.worker.postMessage(message, transferList);
-    });
-  }
-  /**
-   * 启动流式音频特征提取。
-   * @param audioBuffer 输入的音频缓冲区。
-   * @param callbacks 处理过程中的回调函数集合。
-   */
-  async processStreaming(audioBuffer, callbacks) {
-    await this.queue.wait();
-    if (this.isRunning) {
-      throw new Error("\u53E6\u4E00\u4E2A\u97F3\u9891\u6B63\u5728\u5904\u7406\u4E2D\uFF0C\u8BF7\u7A0D\u5019\u3002");
-    }
-    this.isRunning = true;
-    this.audioBuffer = audioBuffer;
-    this.callbacks = callbacks;
-    this.chunkResults = [];
-    this.completedChunks = 0;
-    this.totalFramesProcessed = 0;
-    if (!this.worker) {
-      this.worker = new Worker(
-        /* @vite-ignore */
-        `${workerConfig.path}/feature.worker.js`,
-        { type: "module" }
-      );
-    }
-    const durationSeconds = audioBuffer.duration;
-    this.totalChunks = Math.ceil(durationSeconds / CHUNK_DURATION_SECONDS);
-    try {
-      for (let chunkIndex = 0; chunkIndex < this.totalChunks; chunkIndex++) {
-        if (!this.isRunning)
-          break;
-        await this.processChunk(chunkIndex);
-      }
-      if (this.isRunning) {
-        await this.finalize();
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      this.callbacks.onError?.(errorMessage);
-    } finally {
-      await this.queue.shift();
-      this.cleanup();
-    }
-  }
-  /**
-   * 处理单个音频chunk，提取特征并回调。
-   * @param chunkIndex chunk的索引（从0开始）。
-   */
-  async processChunk(chunkIndex) {
-    if (!this.audioBuffer || !this.worker)
-      return;
-    const startTimeSeconds = chunkIndex * CHUNK_DURATION_SECONDS;
-    const endTimeSeconds = Math.min(
-      (chunkIndex + 1) * CHUNK_DURATION_SECONDS,
-      this.audioBuffer.duration
-    );
-    const startSample = Math.floor(
-      startTimeSeconds * this.audioBuffer.sampleRate
-    );
-    const endSample = Math.floor(endTimeSeconds * this.audioBuffer.sampleRate);
-    const chunkLength = endSample - startSample;
-    const chunkBuffer = await this.createAudioBuffer(
-      this.audioBuffer.numberOfChannels,
-      chunkLength,
-      this.audioBuffer.sampleRate
-    );
-    for (let channel = 0; channel < this.audioBuffer.numberOfChannels; channel++) {
-      const sourceData = this.audioBuffer.getChannelData(channel);
-      const chunkData = chunkBuffer.getChannelData(channel);
-      chunkData.set(sourceData.subarray(startSample, endSample));
-    }
-    const result = await this.processWithWorker(chunkBuffer);
-    const chunkResult = {
-      chunkIndex,
-      features: result.features,
-      dimensions: result.dimensions,
-      startTimeSeconds,
-      endTimeSeconds
-    };
-    this.totalFramesProcessed += chunkResult.dimensions[0];
-    this.chunkResults[chunkIndex] = chunkResult;
-    this.completedChunks++;
-    this.callbacks.onChunkComplete?.(chunkResult);
-    this.callbacks.onProgress?.(this.completedChunks, this.totalChunks);
-    this.chunkResults[chunkIndex] = null;
-  }
-  /**
-   * 所有chunk处理完成后，合并特征并调用onComplete。
-   */
-  async finalize() {
-    if (this.completedChunks === 0) {
-      this.callbacks.onError?.("No chunks were processed.");
-      return;
-    }
-    const totalDimensions = [
-      this.totalFramesProcessed,
-      NUM_SEQUENCE_FRAMES,
-      NUM_MEL_BINS
-    ];
-    this.callbacks.onComplete?.(totalDimensions);
-  }
-  /**
-   * 清理内部状态和资源。
-   */
-  cleanup() {
-    this.isRunning = false;
-    this.audioBuffer = null;
-    if (this.worker) {
-      this.worker.terminate();
-      this.worker = null;
-    }
-    this.chunkResults.forEach((chunk) => {
-      if (chunk && chunk.features) {
-        chunk.features = null;
-      }
-    });
-    this.chunkResults = [];
-    this.callbacks = {};
-    this.completedChunks = 0;
-    this.totalChunks = 0;
-    this.totalFramesProcessed = 0;
-  }
-  /**
-   * 停止当前的流式处理。
-   */
-  stop() {
-    if (this.isRunning) {
-      this.isRunning = false;
-      if (this.worker) {
-        this.worker.terminate();
-        this.worker = null;
-      }
-      this.callbacks = {};
-      this.chunkResults = [];
-      this.totalChunks = 0;
-      this.completedChunks = 0;
-      this.totalFramesProcessed = 0;
-    }
-  }
-}
-
-export { StreamingFeatureExtractorService, createAudioContext };

package/shared/audioToFrames/src/config.d.ts

@@ -1,4 +0,0 @@
-declare const workerConfig: {
-    path: string;
-};
-export { workerConfig, };

package/shared/audioToFrames/src/core/constants.d.ts

@@ -1,17 +0,0 @@
-/**
- * @file 共享常量
- *
- * 存储在多个服务中使用的常量，避免重复定义
- *
- * @author Zhonghan Li
- */
-/** Mel 滤波器组的数量 */
-export declare const NUM_MEL_BINS = 80;
-/** 用于后续处理的序列帧数（每个块包含的帧数） */
-export declare const NUM_SEQUENCE_FRAMES = 4;
-/** 每个chunk的时长（秒） */
-export declare const CHUNK_DURATION_SECONDS = 5;
-/** 上下文窗口中的总块数 */
-export declare const WINDOW_NUM_CHUNKS = 32;
-/** 上下文窗口的单边块数（半径） */
-export declare const WINDOW_NUM_CHUNKS_HALF: number;

package/shared/audioToFrames/src/core/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * @file 核心服务模块导出
- * @author Zhonghan Li
- */
-export * from './constants';
-export * from './utils';

package/shared/audioToFrames/src/core/index.mjs

@@ -1,24 +0,0 @@
-export { C as CHUNK_DURATION_SECONDS, N as NUM_MEL_BINS, a as NUM_SEQUENCE_FRAMES, W as WINDOW_NUM_CHUNKS, b as WINDOW_NUM_CHUNKS_HALF } from '../../../constants.mjs';
-
-function normalizeError(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  return "Unknown error occurred";
-}
-function createErrorHandler(context, _fallbackMessage = "Operation failed") {
-  return function(error) {
-    const errorMessage = normalizeError(error);
-    const fullMessage = `${context}: ${errorMessage}`;
-    console.error(fullMessage);
-    throw new Error(fullMessage);
-  };
-}
-function isNonNull(value) {
-  return value !== null && value !== void 0;
-}
-
-export { createErrorHandler, isNonNull, normalizeError };

package/shared/audioToFrames/src/core/utils.d.ts

@@ -1,26 +0,0 @@
-/**
- * @file 共享工具函数
- *
- * 提供基础错误处理工具函数
- *
- * @author Zhonghan Li
- */
-/**
- * 标准化错误对象
- * @param error 原始错误
- * @returns 标准化的错误消息
- */
-export declare function normalizeError(error: unknown): string;
-/**
- * 创建错误处理包装器
- * @param context 错误上下文
- * @param fallbackMessage 备用错误消息
- * @returns 错误处理函数
- */
-export declare function createErrorHandler(context: string, _fallbackMessage?: string): (error: unknown) => never;
-/**
- * 检查值是否为非空
- * @param value 要检查的值
- * @returns 类型守卫结果
- */
-export declare function isNonNull<T>(value: T | null | undefined): value is T;