@visulima/storage 1.0.0-alpha.3 → 1.0.0-alpha.30

package/dist/transformer/audio-transformer.js

@@ -1,278 +1 @@
-import { Input, BufferSource, ALL_FORMATS, Output, BufferTarget, Conversion, Mp3OutputFormat, WavOutputFormat, OggOutputFormat, FlacOutputFormat, AdtsOutputFormat } from 'mediabunny';
-import BaseTransformer from '../packem_shared/BaseTransformer-C2gLib6v.js';
-import { isValidMediaType, getFormatFromContentType } from '../packem_shared/isValidMediaType-BeDgiObq.js';
-
-class AudioTransformer extends BaseTransformer {
-  /**
-   * Creates a new AudioTransformer instance.
-   * @param storage The storage backend for retrieving and storing audio files.
-   * @param config Configuration options for audio transformation including cache settings, codec defaults, and size limits.
-   */
-  constructor(storage, config = {}) {
-    const logger = config.logger || storage.logger;
-    const transformerConfig = {
-      cacheTtl: 3600,
-      // 1 hour
-      defaultBitrate: 128e3,
-      // 128 kbps
-      defaultCodec: "aac",
-      maxAudioSize: 100 * 1024 * 1024,
-      // 100MB
-      maxCacheSize: 100,
-      // Max 100 transformed audio files in cache
-      supportedFormats: ["mp3", "wav", "ogg", "aac", "flac", "m4a", "wma", "aiff"],
-      ...config
-    };
-    super(storage, transformerConfig, logger);
-  }
-  /**
-   * Resamples audio to different sample rate.
-   * @param fileId Unique identifier of the audio file to resample.
-   * @param options Resample options including target sample rate.
-   * @returns Promise resolving to transformed audio result.
-   */
-  async resample(fileId, options) {
-    return this.transform(fileId, [{ options, type: "resample" }]);
-  }
-  /**
-   * Changes number of channels (up/downmixing).
-   * @param fileId Unique identifier of the audio file to process.
-   * @param options Channel mix options including target number of channels.
-   * @returns Promise resolving to transformed audio result.
-   */
-  async mixChannels(fileId, options) {
-    return this.transform(fileId, [{ options, type: "channels" }]);
-  }
-  /**
-   * Converts audio format or codec.
-   * @param fileId Unique identifier of the audio file to convert.
-   * @param format Target audio format (e.g., "mp3", "wav", "ogg").
-   * @param options Additional transform options.
-   * @returns Promise resolving to transformed audio result.
-   */
-  async convertFormat(fileId, format, options = {}) {
-    return this.transform(fileId, [{ options: { ...options, format }, type: "format" }]);
-  }
-  /**
-   * Transcodes audio to different codec.
-   * @param fileId Unique identifier of the audio file to transcode.
-   * @param codec Target audio codec (e.g., "aac", "opus", "mp3").
-   * @param options Additional transform options.
-   * @returns Promise resolving to transformed audio result.
-   */
-  async transcode(fileId, codec, options = {}) {
-    return this.transform(fileId, [{ options: { ...options, codec }, type: "codec" }]);
-  }
-  /**
-   * Applies a custom transformation pipeline to an audio file.
-   * @param fileId Unique identifier of the audio file to transform.
-   * @param steps Array of transformation steps to apply in sequence.
-   * @returns Promise resolving to transformed audio result.
-   */
-  async transform(fileId, steps) {
-    const fileQuery = { id: fileId };
-    const cacheKey = this.generateCacheKey(fileId, steps);
-    if (this.cache) {
-      const cached = await Promise.resolve(this.cache.get(cacheKey));
-      if (cached) {
-        this.logger?.debug("Returning cached transformed audio for %s", fileId);
-        return cached;
-      }
-    }
-    const originalFile = await this.storage.get(fileQuery);
-    await this.validateAudio(originalFile);
-    const transformedBuffer = await this.applyTransformations(originalFile.content, steps);
-    const result = await this.createTransformResult(transformedBuffer, originalFile);
-    if (this.cache) {
-      this.cache.set(cacheKey, result);
-    }
-    return result;
-  }
-  /**
-   * Apply multiple transformations in sequence using Mediabunny
-   */
-  async applyTransformations(buffer, steps) {
-    const input = new Input({
-      formats: ALL_FORMATS,
-      source: new BufferSource(buffer)
-    });
-    const outputFormat = this.determineOutputFormat(steps);
-    const output = new Output({
-      format: outputFormat,
-      target: new BufferTarget()
-    });
-    const audioOptions = this.stepsToAudioOptions(steps);
-    const conversion = await Conversion.init({
-      audio: audioOptions,
-      input,
-      output
-    });
-    if (!conversion.isValid) {
-      const reasons = conversion.discardedTracks.map((track) => track.reason).join(", ");
-      throw new Error(`Audio transformation failed: ${reasons}`);
-    }
-    await conversion.execute();
-    return Buffer.from(output.target.buffer);
-  }
-  /**
-   * Convert transformation steps to Mediabunny audio options
-   * @param steps Array of audio transformation steps to convert
-   * @returns Mediabunny audio options object for conversion
-   * @private
-   */
-  // eslint-disable-next-line class-methods-use-this
-  stepsToAudioOptions(steps) {
-    const options = {};
-    for (const step of steps) {
-      switch (step.type) {
-        case "bitrate": {
-          const bitrateOptions = step.options;
-          if (bitrateOptions.bitrate) {
-            options.bitrate = bitrateOptions.bitrate;
-          }
-          break;
-        }
-        case "channels": {
-          const channelOptions = step.options;
-          if (channelOptions.numberOfChannels) {
-            options.numberOfChannels = channelOptions.numberOfChannels;
-          }
-          break;
-        }
-        case "codec": {
-          const codecOptions = step.options;
-          if (codecOptions.codec) {
-            options.codec = codecOptions.codec;
-          }
-          if (codecOptions.bitrate) {
-            options.bitrate = codecOptions.bitrate;
-          }
-          break;
-        }
-        case "resample": {
-          const resampleOptions = step.options;
-          if (resampleOptions.sampleRate) {
-            options.sampleRate = resampleOptions.sampleRate;
-          }
-          break;
-        }
-      }
-    }
-    return options;
-  }
-  /**
-   * Determine output format based on transformation steps
-   * @param steps Array of audio transformation steps
-   * @returns Mediabunny output format instance (defaults to MP3)
-   * @private
-   */
-  determineOutputFormat(steps) {
-    for (const step of steps) {
-      if (step.type === "format" && step.options.format) {
-        return this.formatStringToOutputFormat(step.options.format);
-      }
-    }
-    return new Mp3OutputFormat();
-  }
-  /**
-   * Convert format string to Mediabunny output format
-   * @param format Audio format string (aac, flac, mp3, ogg, wav)
-   * @returns Mediabunny output format instance
-   * @private
-   */
-  // eslint-disable-next-line class-methods-use-this
-  formatStringToOutputFormat(format) {
-    switch (format.toLowerCase()) {
-      case "aac": {
-        return new AdtsOutputFormat();
-      }
-      case "flac": {
-        return new FlacOutputFormat();
-      }
-      case "mp3": {
-        return new Mp3OutputFormat();
-      }
-      case "ogg": {
-        return new OggOutputFormat();
-      }
-      case "wav": {
-        return new WavOutputFormat();
-      }
-      default: {
-        return new Mp3OutputFormat();
-      }
-    }
-  }
-  /**
-   * Validate that the file is a supported audio file
-   * @param file The file to validate
-   * @returns Promise that resolves if validation passes
-   * @throws Error if file size exceeds limits, wrong content type, unsupported format, or invalid audio
-   * @private
-   */
-  async validateAudio(file) {
-    const fileSize = typeof file.size === "string" ? Number.parseInt(file.size, 10) : file.size;
-    if (this.config?.maxAudioSize && fileSize > this.config.maxAudioSize) {
-      throw new Error(`Audio size ${fileSize} exceeds maximum allowed size ${this.config.maxAudioSize}`);
-    }
-    if (!isValidMediaType(file.contentType, "audio")) {
-      throw new Error(`File is not audio: ${file.contentType}`);
-    }
-    const format = getFormatFromContentType(file.contentType);
-    if (this.config?.supportedFormats && format && !this.config.supportedFormats.includes(format)) {
-      throw new Error(`Unsupported audio format: ${format}`);
-    }
-    try {
-      const input = new Input({
-        formats: ALL_FORMATS,
-        source: new BufferSource(file.content)
-      });
-      const primaryTrack = await input.getPrimaryAudioTrack();
-      if (!primaryTrack) {
-        throw new Error("No audio track found");
-      }
-    } catch (error) {
-      throw new Error(`Invalid audio file: ${error}`);
-    }
-  }
-  /**
-   * Create transformation result with metadata
-   * @param buffer The transformed audio buffer
-   * @param originalFile The original file information
-   * @returns Audio transformation result with metadata
-   * @private
-   */
-  async createTransformResult(buffer, originalFile) {
-    const input = new Input({
-      formats: ALL_FORMATS,
-      source: new BufferSource(buffer)
-    });
-    const audioTrack = await input.getPrimaryAudioTrack();
-    const duration = await input.computeDuration();
-    return {
-      bitrate: this.config.defaultBitrate,
-      buffer,
-      duration,
-      format: "mp3",
-      // Default, would need to detect actual format
-      numberOfChannels: audioTrack?.numberOfChannels || 2,
-      originalFile,
-      sampleRate: audioTrack?.sampleRate || 44100,
-      size: buffer.length
-    };
-  }
-  /**
-   * Generate cache key for transformation
-   * @param fileId The file identifier
-   * @param steps Array of transformation steps
-   * @returns Unique cache key string
-   * @private
-   */
-  // eslint-disable-next-line class-methods-use-this
-  generateCacheKey(fileId, steps) {
-    const stepsKey = steps.map((step) => `${step.type}:${JSON.stringify(step.options)}`).join("|");
-    return `${fileId}:${stepsKey}`;
-  }
-}
-
-export { AudioTransformer as default };
+var l=Object.defineProperty;var u=(s,t)=>l(s,"name",{value:t,configurable:!0});import{Input as m,BufferSource as f,ALL_FORMATS as p,Output as w,BufferTarget as g,Conversion as y,Mp3OutputFormat as d,WavOutputFormat as b,OggOutputFormat as O,FlacOutputFormat as T,AdtsOutputFormat as F}from"mediabunny";import A from"../packem_shared/BaseTransformer-Fpcuz4kj.js";import{isValidMediaType as C,getFormatFromContentType as v}from"../packem_shared/isValidMediaType-B-2UKjZx.js";var x=Object.defineProperty,z=u((s,t)=>x(s,"name",{value:t,configurable:!0}),"d");class E extends A{static{u(this,"S")}static{z(this,"AudioTransformer")}constructor(t,e={}){const a=e.logger||t.logger,r={cacheTtl:3600,defaultBitrate:128e3,defaultCodec:"aac",maxAudioSize:100*1024*1024,maxCacheSize:100,supportedFormats:["mp3","wav","ogg","aac","flac","m4a","wma","aiff"],...e};super(t,r,a)}async resample(t,e){return this.transform(t,[{options:e,type:"resample"}])}async mixChannels(t,e){return this.transform(t,[{options:e,type:"channels"}])}async convertFormat(t,e,a={}){return this.transform(t,[{options:{...a,format:e},type:"format"}])}async transcode(t,e,a={}){return this.transform(t,[{options:{...a,codec:e},type:"codec"}])}async transform(t,e){const a={id:t},r=this.generateCacheKey(t,e);if(this.cache){const i=await Promise.resolve(this.cache.get(r));if(i)return this.logger?.debug("Returning cached transformed audio for %s",t),i}const o=await this.storage.get(a);await this.validateAudio(o);const c=await this.applyTransformations(o.content,e),n=await this.createTransformResult(c,o);return this.cache&&this.cache.set(r,n),n}async applyTransformations(t,e){const a=new m({formats:p,source:new f(t)}),r=this.determineOutputFormat(e),o=new w({format:r,target:new g}),c=this.stepsToAudioOptions(e),n=await y.init({audio:c,input:a,output:o});if(!n.isValid){const i=n.discardedTracks.map(h=>h.reason).join(", ");throw new Error(`Audio transformation failed: ${i}`)}return await n.execute(),Buffer.from(o.target.buffer)}stepsToAudioOptions(t){const e={};for(const a of t)switch(a.type){case"bitrate":{const r=a.options;r.bitrate&&(e.bitrate=r.bitrate);break}case"channels":{const r=a.options;r.numberOfChannels&&(e.numberOfChannels=r.numberOfChannels);break}case"codec":{const r=a.options;r.codec&&(e.codec=r.codec),r.bitrate&&(e.bitrate=r.bitrate);break}case"resample":{const r=a.options;r.sampleRate&&(e.sampleRate=r.sampleRate);break}}return e}determineOutputFormat(t){for(const e of t)if(e.type==="format"&&e.options.format)return this.formatStringToOutputFormat(e.options.format);return new d}formatStringToOutputFormat(t){switch(t.toLowerCase()){case"aac":return new F;case"flac":return new T;case"mp3":return new d;case"ogg":return new O;case"wav":return new b;default:return new d}}async validateAudio(t){const e=typeof t.size=="string"?Number.parseInt(t.size,10):t.size;if(this.config?.maxAudioSize&&e>this.config.maxAudioSize)throw new Error(`Audio size ${e} exceeds maximum allowed size ${this.config.maxAudioSize}`);if(!C(t.contentType,"audio"))throw new Error(`File is not audio: ${t.contentType}`);const a=v(t.contentType);if(this.config?.supportedFormats&&a&&!this.config.supportedFormats.includes(a))throw new Error(`Unsupported audio format: ${a}`);try{if(!await new m({formats:p,source:new f(t.content)}).getPrimaryAudioTrack())throw new Error("No audio track found")}catch(r){throw new Error(`Invalid audio file: ${r}`)}}async createTransformResult(t,e){const a=new m({formats:p,source:new f(t)}),r=await a.getPrimaryAudioTrack(),o=await a.computeDuration();return{bitrate:this.config.defaultBitrate,buffer:t,duration:o,format:"mp3",numberOfChannels:r?.numberOfChannels||2,originalFile:e,sampleRate:r?.sampleRate||44100,size:t.length}}generateCacheKey(t,e){const a=e.map(r=>`${r.type}:${JSON.stringify(r.options)}`).join("|");return`${t}:${a}`}}export{E as default};