@bernierllc/content-type-audio 1.2.2 → 1.5.0

package/__tests__/integration.test.ts

@@ -1,279 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { AudioContentTypeManager } from '../src/AudioContentTypeManager';
-import { AudioFormat } from '../src/types';
-import { ContentTypeRegistry } from '@bernierllc/content-type-registry';
-
-describe('Integration Tests', () => {
-  describe('AudioContentTypeManager with ContentTypeRegistry', () => {
-    it('should integrate with content type registry', () => {
-      const registry = new ContentTypeRegistry();
-      const manager = new AudioContentTypeManager();
-
-      manager.register(registry);
-
-      const result = registry.get('audio');
-      expect(result.success).toBe(true);
-      expect(result.data).toBeDefined();
-      expect(result.data?.id).toBe('audio');
-      expect(result.data?.name).toBe('Audio');
-    });
-
-    it('should find registered audio type by filter', () => {
-      const registry = new ContentTypeRegistry();
-      const manager = new AudioContentTypeManager();
-
-      manager.register(registry);
-
-      const result = registry.list({ baseType: 'audio' });
-      expect(result.success).toBe(true);
-      expect(result.data).toBeDefined();
-      expect(result.data).toHaveLength(1);
-      expect(result.data?.[0].id).toBe('audio');
-    });
-
-    it('should validate content using registered schema', () => {
-      const registry = new ContentTypeRegistry();
-      const manager = new AudioContentTypeManager();
-
-      manager.register(registry);
-
-      const content = manager.create({
-        filename: 'test.mp3',
-        mimeType: AudioFormat.MP3,
-        size: 1024 * 1024,
-        duration: 60,
-        bitrate: 128
-      });
-
-      const validation = manager.validate(content);
-      expect(validation.valid).toBe(true);
-    });
-  });
-
-  describe('End-to-end workflow', () => {
-    it('should handle complete audio content lifecycle', async () => {
-      // 1. Create manager
-      const manager = new AudioContentTypeManager({
-        maxFileSize: 10 * 1024 * 1024,
-        allowedFormats: [AudioFormat.MP3, AudioFormat.WAV],
-        requireMetadata: false
-      });
-
-      // 2. Register with registry
-      const registry = new ContentTypeRegistry();
-      manager.register(registry);
-
-      // 3. Create audio content
-      const audioContent = manager.create(
-        {
-          filename: 'podcast-episode.mp3',
-          mimeType: AudioFormat.MP3,
-          size: 5 * 1024 * 1024,
-          duration: 1800, // 30 minutes
-          bitrate: 192,
-          title: 'My Podcast Episode',
-          artist: 'Podcast Host'
-        },
-        {
-          filePath: '/storage/audio/podcast-episode.mp3',
-          streamingUrl: 'https://cdn.example.com/podcast-episode.mp3'
-        }
-      );
-
-      // 4. Validate content
-      const validation = manager.validate(audioContent);
-      expect(validation.valid).toBe(true);
-
-      // 5. Verify content structure
-      expect(audioContent.id).toBeDefined();
-      expect(audioContent.type).toBe('audio');
-      expect(audioContent.metadata.title).toBe('My Podcast Episode');
-      expect(audioContent.filePath).toBe('/storage/audio/podcast-episode.mp3');
-      expect(audioContent.streamingUrl).toBe('https://cdn.example.com/podcast-episode.mp3');
-    });
-
-    it('should handle multiple audio formats', async () => {
-      const manager = new AudioContentTypeManager();
-      const registry = new ContentTypeRegistry();
-      manager.register(registry);
-
-      const formats = [
-        AudioFormat.MP3,
-        AudioFormat.WAV,
-        AudioFormat.AAC,
-        AudioFormat.OGG,
-        AudioFormat.FLAC,
-        AudioFormat.M4A
-      ];
-
-      for (const format of formats) {
-        const content = manager.create({
-          filename: `test.${format.split('/')[1]}`,
-          mimeType: format,
-          size: 1024 * 1024,
-          duration: 60,
-          bitrate: 128
-        });
-
-        const validation = manager.validate(content);
-        expect(validation.valid).toBe(true);
-      }
-    });
-
-    it('should calculate accurate bitrate for real file scenarios', () => {
-      const manager = new AudioContentTypeManager();
-
-      // Scenario 1: MP3 at 128kbps, 3 minutes
-      const mp3Duration = 180; // 3 minutes
-      const mp3Size = Math.round((128 * 1000 * mp3Duration) / 8); // bytes
-      const mp3Bitrate = manager.calculateBitrate(mp3Size, mp3Duration);
-      expect(mp3Bitrate).toBeCloseTo(128, 1);
-
-      // Scenario 2: High quality WAV, 5 minutes
-      const wavDuration = 300; // 5 minutes
-      const wavSize = Math.round((1411 * 1000 * wavDuration) / 8); // CD quality
-      const wavBitrate = manager.calculateBitrate(wavSize, wavDuration);
-      expect(wavBitrate).toBeCloseTo(1411, 1);
-    });
-
-    it('should format and parse durations consistently', () => {
-      const manager = new AudioContentTypeManager();
-
-      const durations = [30, 90, 180, 1800, 3600, 5025];
-
-      for (const duration of durations) {
-        const formatted = manager.formatDuration(duration);
-        const parsed = manager.parseDuration(formatted);
-        expect(parsed).toBe(duration);
-      }
-    });
-  });
-
-  describe('Error handling', () => {
-    it('should handle validation errors gracefully', async () => {
-      const manager = new AudioContentTypeManager({
-        maxFileSize: 1024 * 1024, // 1MB
-        requireMetadata: true
-      });
-
-      const content = manager.create({
-        filename: 'large.mp3',
-        mimeType: AudioFormat.MP3,
-        size: 10 * 1024 * 1024, // 10MB (exceeds limit)
-        duration: 600,
-        bitrate: 192
-        // Missing title (required)
-      });
-
-      const validation = manager.validate(content);
-
-      expect(validation.valid).toBe(false);
-      expect(validation.errors).toBeDefined();
-      expect(validation.errors?.length).toBeGreaterThan(0);
-    });
-
-    it('should handle multiple validation errors', async () => {
-      const manager = new AudioContentTypeManager({
-        maxFileSize: 1024 * 1024,
-        allowedFormats: [AudioFormat.MP3],
-        requireMetadata: true
-      });
-
-      const content = manager.create({
-        filename: 'test.flac',
-        mimeType: AudioFormat.FLAC, // Not allowed
-        size: 10 * 1024 * 1024, // Too large
-        duration: 600,
-        bitrate: 192
-        // Missing title
-      });
-
-      const validation = manager.validate(content);
-
-      expect(validation.valid).toBe(false);
-      expect(validation.errors).toBeDefined();
-      expect(validation.errors?.length).toBeGreaterThanOrEqual(2);
-    });
-  });
-
-  describe('Configuration scenarios', () => {
-    it('should work with minimal configuration', async () => {
-      const manager = new AudioContentTypeManager();
-      const registry = new ContentTypeRegistry();
-
-      manager.register(registry);
-
-      const content = manager.create({
-        filename: 'test.mp3',
-        mimeType: AudioFormat.MP3,
-        size: 1024 * 1024,
-        duration: 60,
-        bitrate: 128
-      });
-
-      const validation = manager.validate(content);
-      expect(validation.valid).toBe(true);
-    });
-
-    it('should work with restrictive configuration', async () => {
-      const manager = new AudioContentTypeManager({
-        maxFileSize: 512 * 1024, // 512KB
-        allowedFormats: [AudioFormat.MP3],
-        requireMetadata: true
-      });
-
-      // Valid content
-      const validContent = manager.create({
-        filename: 'small.mp3',
-        mimeType: AudioFormat.MP3,
-        size: 256 * 1024,
-        duration: 30,
-        bitrate: 64,
-        title: 'Small Audio'
-      });
-
-      const validation = manager.validate(validContent);
-      expect(validation.valid).toBe(true);
-
-      // Invalid content (too large)
-      const invalidContent = manager.create({
-        filename: 'large.mp3',
-        mimeType: AudioFormat.MP3,
-        size: 1024 * 1024,
-        duration: 120,
-        bitrate: 128,
-        title: 'Large Audio'
-      });
-
-      const invalidValidation = manager.validate(invalidContent);
-      expect(invalidValidation.valid).toBe(false);
-    });
-
-    it('should work with permissive configuration', async () => {
-      const manager = new AudioContentTypeManager({
-        maxFileSize: 500 * 1024 * 1024, // 500MB
-        allowedFormats: Object.values(AudioFormat),
-        requireMetadata: false
-      });
-
-      // Very large file
-      const content = manager.create({
-        filename: 'huge.flac',
-        mimeType: AudioFormat.FLAC,
-        size: 100 * 1024 * 1024,
-        duration: 3600,
-        bitrate: 1411
-      });
-
-      const validation = manager.validate(content);
-      expect(validation.valid).toBe(true);
-    });
-  });
-});

package/__tests__/utils.test.ts

@@ -1,142 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import {
-  parseDuration,
-  formatDuration,
-  calculateBitrate,
-  generateAudioId
-} from '../src/utils';
-
-describe('Audio Utilities', () => {
-  describe('parseDuration', () => {
-    it('should parse duration from seconds number', () => {
-      expect(parseDuration(123)).toBe(123);
-      expect(parseDuration(0)).toBe(0);
-      expect(parseDuration(3600)).toBe(3600);
-    });
-
-    it('should parse duration from seconds string', () => {
-      expect(parseDuration('123')).toBe(123);
-      expect(parseDuration('0')).toBe(0);
-      expect(parseDuration('3600')).toBe(3600);
-    });
-
-    it('should parse duration from mm:ss format', () => {
-      expect(parseDuration('1:30')).toBe(90); // 1m 30s
-      expect(parseDuration('23:45')).toBe(1425); // 23m 45s
-      expect(parseDuration('0:00')).toBe(0);
-      expect(parseDuration('59:59')).toBe(3599);
-    });
-
-    it('should parse duration from hh:mm:ss format', () => {
-      expect(parseDuration('1:23:45')).toBe(5025); // 1h 23m 45s
-      expect(parseDuration('0:23:45')).toBe(1425); // 23m 45s
-      expect(parseDuration('2:00:00')).toBe(7200); // 2h
-      expect(parseDuration('0:00:00')).toBe(0);
-    });
-
-    it('should handle invalid formats', () => {
-      expect(parseDuration('')).toBe(0);
-      expect(parseDuration('invalid')).toBe(0);
-    });
-  });
-
-  describe('formatDuration', () => {
-    it('should format duration under 1 hour as mm:ss', () => {
-      expect(formatDuration(90)).toBe('1:30');
-      expect(formatDuration(1425)).toBe('23:45');
-      expect(formatDuration(0)).toBe('0:00');
-      expect(formatDuration(59)).toBe('0:59');
-      expect(formatDuration(3599)).toBe('59:59');
-    });
-
-    it('should format duration over 1 hour as hh:mm:ss', () => {
-      expect(formatDuration(5025)).toBe('1:23:45');
-      expect(formatDuration(3600)).toBe('1:00:00');
-      expect(formatDuration(7200)).toBe('2:00:00');
-      expect(formatDuration(86400)).toBe('24:00:00');
-    });
-
-    it('should handle edge cases', () => {
-      expect(formatDuration(0)).toBe('0:00');
-      expect(formatDuration(1)).toBe('0:01');
-      expect(formatDuration(60)).toBe('1:00');
-      expect(formatDuration(3599.9)).toBe('59:59'); // Just under 1 hour
-      expect(formatDuration(3600.1)).toBe('1:00:00'); // Just over 1 hour
-    });
-
-    it('should handle floating point seconds', () => {
-      expect(formatDuration(90.5)).toBe('1:30');
-      expect(formatDuration(59.9)).toBe('0:59');
-    });
-
-    it('should pad single digit values', () => {
-      expect(formatDuration(65)).toBe('1:05');
-      expect(formatDuration(3665)).toBe('1:01:05');
-    });
-  });
-
-  describe('calculateBitrate', () => {
-    it('should calculate bitrate correctly', () => {
-      const fileSize = 5 * 1024 * 1024; // 5MB
-      const duration = 180; // 3 minutes
-
-      const bitrate = calculateBitrate(fileSize, duration);
-
-      expect(bitrate).toBeGreaterThan(0);
-      expect(bitrate).toBeCloseTo(233, 0); // ~233 kbps
-    });
-
-    it('should handle different file sizes and durations', () => {
-      expect(calculateBitrate(1024 * 1024, 60)).toBe(140); // 1MB, 1min = ~140kbps
-      expect(calculateBitrate(10 * 1024 * 1024, 300)).toBe(280); // 10MB, 5min = ~280kbps
-    });
-
-    it('should return 0 for zero duration', () => {
-      expect(calculateBitrate(1024 * 1024, 0)).toBe(0);
-    });
-
-    it('should handle very small files', () => {
-      expect(calculateBitrate(1024, 60)).toBe(0); // Rounds to 0
-    });
-
-    it('should handle very large files', () => {
-      const bitrate = calculateBitrate(100 * 1024 * 1024, 300); // 100MB, 5min
-      expect(bitrate).toBeGreaterThan(0);
-      expect(bitrate).toBeCloseTo(2796, 0);
-    });
-  });
-
-  describe('generateAudioId', () => {
-    it('should generate unique IDs', () => {
-      const id1 = generateAudioId();
-      const id2 = generateAudioId();
-
-      expect(id1).not.toBe(id2);
-    });
-
-    it('should start with audio_ prefix', () => {
-      const id = generateAudioId();
-      expect(id).toMatch(/^audio_/);
-    });
-
-    it('should have correct format', () => {
-      const id = generateAudioId();
-      expect(id).toMatch(/^audio_\d+_[a-z0-9]+$/);
-    });
-
-    it('should generate multiple unique IDs', () => {
-      const ids = new Set();
-      for (let i = 0; i < 100; i++) {
-        ids.add(generateAudioId());
-      }
-      expect(ids.size).toBe(100);
-    });
-  });
-});

package/jest.config.cjs

@@ -1,32 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-module.exports = {
-  preset: 'ts-jest',
-  // Use fixed environment to handle Node.js v25+ localStorage issue
-  testEnvironment: '<rootDir>/../../../jest-environment-node-fixed.cjs',
-  roots: ['<rootDir>/__tests__'],
-  testMatch: ['**/__tests__/**/*.test.ts'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-    '!src/index.ts'
-  ],
-  coverageThreshold: {
-    global: {
-      branches: 83,
-      functions: 90,
-      lines: 90,
-      statements: 90
-    }
-  },
-  moduleFileExtensions: ['ts', 'js', 'json'],
-  transform: {
-    '^.+\\.ts$': 'ts-jest'
-  }
-};

package/src/AudioContentTypeManager.ts

@@ -1,238 +0,0 @@
-/*
-Copyright (c) 2025 Bernier LLC
-
-This file is licensed to the client under a limited-use license.
-The client may use and modify this code *only within the scope of the project it was delivered for*.
-Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
-*/
-
-import { z } from 'zod';
-import {
-  ContentTypeRegistry,
-  BaseContentType,
-  type ContentTypeDefinition
-} from '@bernierllc/content-type-registry';
-import { AudioContentSchema } from './schemas';
-import {
-  AudioFormat,
-  AudioContentTypeConfig,
-  AudioMetadata,
-  AudioContentType,
-  AudioValidationResult,
-  PackageResult
-} from './types';
-import {
-  parseDuration,
-  formatDuration,
-  calculateBitrate,
-  generateAudioId
-} from './utils';
-
-/**
- * Audio content type manager
- */
-export class AudioContentTypeManager {
-  private config: AudioContentTypeConfig;
-
-  constructor(config?: Partial<AudioContentTypeConfig>) {
-    this.config = {
-      baseType: 'audio',
-      editor: 'file-upload-with-player',
-      storage: 'file',
-      publishing: 'streaming-url',
-      maxFileSize: 100 * 1024 * 1024, // 100MB
-      allowedFormats: Object.values(AudioFormat),
-      requireMetadata: false,
-      ...config
-    };
-  }
-
-  /**
-   * Register audio content type with registry
-   */
-  register(registry: ContentTypeRegistry): void {
-    const definition: ContentTypeDefinition = {
-      id: 'audio',
-      name: 'Audio',
-      description: 'Base audio content type with file upload and streaming',
-      baseType: BaseContentType.AUDIO,
-      icon: '🎵',
-      schema: this.getSchema(),
-      editor: {
-        component: this.config.editor,
-        settings: {
-          maxFileSize: this.config.maxFileSize,
-          allowedFormats: this.config.allowedFormats,
-          requireMetadata: this.config.requireMetadata
-        }
-      },
-      storage: {
-        method: this.config.storage
-      },
-      publishing: {
-        methods: [this.config.publishing],
-        defaultMethod: this.config.publishing
-      },
-      metadata: {
-        version: '1.0.0',
-        author: 'Bernier LLC'
-      }
-    };
-
-    registry.register(definition);
-  }
-
-  /**
-   * Get Zod schema for audio content type
-   */
-  getSchema(): z.ZodSchema {
-    return AudioContentSchema;
-  }
-
-  /**
-   * Validate audio content
-   */
-  validate(content: unknown): AudioValidationResult {
-    try {
-      const schema = this.getSchema();
-      const validated = schema.parse(content) as AudioContentType;
-
-      // Additional validation
-      const errors: string[] = [];
-
-      // Check file size
-      if (this.config.maxFileSize && validated.metadata.size > this.config.maxFileSize) {
-        errors.push(
-          `File size ${validated.metadata.size} exceeds maximum ${this.config.maxFileSize}`
-        );
-      }
-
-      // Check allowed formats
-      if (
-        this.config.allowedFormats &&
-        !this.config.allowedFormats.includes(validated.metadata.mimeType)
-      ) {
-        errors.push(`Audio format ${validated.metadata.mimeType} not allowed`);
-      }
-
-      // Check metadata requirements
-      if (this.config.requireMetadata && !validated.metadata.title) {
-        errors.push('Title is required');
-      }
-
-      if (errors.length > 0) {
-        return {
-          valid: false,
-          errors,
-          metadata: validated.metadata
-        };
-      }
-
-      return {
-        valid: true,
-        metadata: validated.metadata
-      };
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        return {
-          valid: false,
-          errors: error.errors.map((e) => `${e.path.join('.')}: ${e.message}`)
-        };
-      }
-
-      return {
-        valid: false,
-        errors: [error instanceof Error ? error.message : 'Unknown validation error']
-      };
-    }
-  }
-
-  /**
-   * Create audio content type instance
-   */
-  create(
-    metadata: AudioMetadata,
-    options?: {
-      filePath?: string;
-      fileUrl?: string;
-      streamingUrl?: string;
-    }
-  ): AudioContentType {
-    const content: AudioContentType = {
-      id: generateAudioId(),
-      type: 'audio',
-      metadata,
-      createdAt: new Date(),
-      updatedAt: new Date()
-    };
-
-    if (options?.filePath) {
-      content.filePath = options.filePath;
-    }
-    if (options?.fileUrl) {
-      content.fileUrl = options.fileUrl;
-    }
-    if (options?.streamingUrl) {
-      content.streamingUrl = options.streamingUrl;
-    }
-
-    return content;
-  }
-
-  /**
-   * Parse audio duration from various formats
-   */
-  parseDuration(duration: string | number): number {
-    return parseDuration(duration);
-  }
-
-  /**
-   * Format duration to human-readable string
-   */
-  formatDuration(seconds: number): string {
-    return formatDuration(seconds);
-  }
-
-  /**
-   * Calculate bitrate from file size and duration
-   */
-  calculateBitrate(fileSize: number, duration: number): number {
-    return calculateBitrate(fileSize, duration);
-  }
-}
-
-/**
- * Wrapper for validation with error handling
- */
-export function validateAudio(
-  manager: AudioContentTypeManager,
-  content: unknown
-): PackageResult<AudioValidationResult> {
-  try {
-    const result = manager.validate(content);
-    if (result.valid) {
-      return {
-        success: true,
-        data: result
-      };
-    } else {
-      const errorMessage = result.errors?.join(', ');
-      if (errorMessage) {
-        return {
-          success: false,
-          data: result,
-          error: errorMessage
-        };
-      }
-      return {
-        success: false,
-        data: result
-      };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error'
-    };
-  }
-}