@bernierllc/content-type-audio 1.0.1

package/jest.config.cjs

@@ -0,0 +1,32 @@
+/*
+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',
+  testEnvironment: 'node',
+  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
+    }
+  },
+  coverageReporters: ['text', 'lcov', 'html'],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest'
+  }
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@bernierllc/content-type-audio",
+  "version": "1.0.1",
+  "description": "Base audio content type with file upload, local storage, and streaming URL capabilities",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "keywords": [
+    "audio",
+    "content-type",
+    "media",
+    "streaming",
+    "file-upload",
+    "mp3",
+    "wav",
+    "content-management"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@bernierllc/content-type-registry": "^1.0.3",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bernierllc": {
+    "integration": {
+      "neverhub": "optional",
+      "logger": "planned"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "test:run": "jest --runInBand",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src __tests__ --ext .ts",
+    "clean": "rm -rf dist"
+  }
+}

package/src/AudioContentTypeManager.ts

@@ -0,0 +1,238 @@
+/*
+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'
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+/*
+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.
+*/
+
+// Export types
+export {
+  AudioFormat,
+  type AudioMetadata,
+  type AudioContentTypeConfig,
+  type AudioContentType,
+  type AudioValidationResult,
+  type PackageResult
+} from './types';
+
+// Export schemas
+export { AudioContentSchema, type AudioContent } from './schemas';
+
+// Export utilities
+export {
+  parseDuration,
+  formatDuration,
+  calculateBitrate,
+  generateAudioId
+} from './utils';
+
+// Export manager
+export { AudioContentTypeManager, validateAudio } from './AudioContentTypeManager';

package/src/schemas.ts

@@ -0,0 +1,42 @@
+/*
+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 { AudioFormat } from './types';
+
+/**
+ * Zod schema for audio content type validation
+ */
+export const AudioContentSchema = z.object({
+  id: z.string(),
+  type: z.literal('audio'),
+  metadata: z.object({
+    filename: z.string(),
+    mimeType: z.nativeEnum(AudioFormat),
+    size: z.number().positive(),
+    duration: z.number().nonnegative(),
+    bitrate: z.number().positive(),
+    sampleRate: z.number().positive().optional(),
+    channels: z.number().int().min(1).max(8).optional(),
+    title: z.string().optional(),
+    artist: z.string().optional(),
+    album: z.string().optional(),
+    year: z.number().int().min(1900).max(2100).optional(),
+    coverArt: z.string().optional()
+  }),
+  filePath: z.string().optional(),
+  fileUrl: z.string().url().optional(),
+  streamingUrl: z.string().url().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+
+/**
+ * Type inferred from schema
+ */
+export type AudioContent = z.infer<typeof AudioContentSchema>;

package/src/types.ts

@@ -0,0 +1,82 @@
+/*
+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.
+*/
+
+/**
+ * Audio format enumeration
+ */
+export enum AudioFormat {
+  MP3 = 'audio/mpeg',
+  WAV = 'audio/wav',
+  AAC = 'audio/aac',
+  OGG = 'audio/ogg',
+  FLAC = 'audio/flac',
+  M4A = 'audio/mp4'
+}
+
+/**
+ * Audio metadata interface
+ */
+export interface AudioMetadata {
+  filename: string;
+  mimeType: AudioFormat;
+  size: number;           // bytes
+  duration: number;       // seconds
+  bitrate: number;        // kbps
+  sampleRate?: number;    // Hz
+  channels?: number;      // 1 = mono, 2 = stereo
+  title?: string;
+  artist?: string;
+  album?: string;
+  year?: number;
+  coverArt?: string;      // URL or base64
+}
+
+/**
+ * Audio content type configuration
+ */
+export interface AudioContentTypeConfig {
+  baseType: 'audio';
+  editor: 'file-upload-with-player';
+  storage: 'file' | 'cloud' | 'custom';
+  publishing: 'streaming-url' | 'download' | 'custom';
+  maxFileSize?: number;           // bytes, default: 100MB
+  allowedFormats?: AudioFormat[]; // default: all formats
+  requireMetadata?: boolean;      // default: false
+}
+
+/**
+ * Audio content type interface
+ */
+export interface AudioContentType {
+  id: string;
+  type: 'audio';
+  metadata: AudioMetadata;
+  filePath?: string;      // for local storage
+  fileUrl?: string;       // for cloud storage
+  streamingUrl?: string;  // for publishing
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+/**
+ * Audio validation result
+ */
+export interface AudioValidationResult {
+  valid: boolean;
+  errors?: string[];
+  metadata?: Partial<AudioMetadata>;
+}
+
+/**
+ * Package result interface for error handling
+ */
+export interface PackageResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}

package/src/utils.ts

@@ -0,0 +1,80 @@
+/*
+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.
+*/
+
+/**
+ * Parse audio duration from various formats
+ * @param duration - Duration as string ("1:23:45", "23:45", "123") or number
+ * @returns Duration in seconds
+ */
+export function parseDuration(duration: string | number): number {
+  if (typeof duration === 'number') {
+    return duration;
+  }
+
+  // Parse formats: "1:23:45", "23:45", "123"
+  const parts = duration.split(':').map(Number);
+
+  // Check if all parts are valid numbers
+  if (parts.some(part => isNaN(part))) {
+    return 0;
+  }
+
+  if (parts.length === 1) {
+    const part = parts[0];
+    return part !== undefined ? part : 0; // seconds
+  } else if (parts.length === 2) {
+    const part0 = parts[0];
+    const part1 = parts[1];
+    return (part0 !== undefined && part1 !== undefined) ? part0 * 60 + part1 : 0; // mm:ss
+  } else if (parts.length === 3) {
+    const part0 = parts[0];
+    const part1 = parts[1];
+    const part2 = parts[2];
+    return (part0 !== undefined && part1 !== undefined && part2 !== undefined)
+      ? part0 * 3600 + part1 * 60 + part2
+      : 0; // hh:mm:ss
+  }
+
+  return 0;
+}
+
+/**
+ * Format duration to human-readable string
+ * @param seconds - Duration in seconds
+ * @returns Formatted string (e.g., "1:23:45" or "23:45")
+ */
+export function formatDuration(seconds: number): string {
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  const secs = Math.floor(seconds % 60);
+
+  if (hours > 0) {
+    return `${hours}:${String(minutes).padStart(2, '0')}:${String(secs).padStart(2, '0')}`;
+  }
+  return `${minutes}:${String(secs).padStart(2, '0')}`;
+}
+
+/**
+ * Calculate bitrate from file size and duration
+ * @param fileSize - File size in bytes
+ * @param duration - Duration in seconds
+ * @returns Bitrate in kbps
+ */
+export function calculateBitrate(fileSize: number, duration: number): number {
+  if (duration === 0) return 0;
+  // (fileSize in bytes * 8 bits/byte) / (duration in seconds) / 1000 = kbps
+  return Math.round((fileSize * 8) / duration / 1000);
+}
+
+/**
+ * Generate unique ID for audio content
+ * @returns Unique identifier
+ */
+export function generateAudioId(): string {
+  return `audio_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
+}