@codingfactory/mediables-vue 2.0.1

package/dist/utils/formatters.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Format a price as currency
+ */
+export declare function formatPrice(price: number | string, currency?: string, locale?: string): string;
+/**
+ * Alias for formatPrice for consistency with accounts payable module
+ */
+export declare const formatCurrency: typeof formatPrice;
+/**
+ * Format a number with locale-specific formatting
+ */
+export declare function formatNumber(value: number | string, locale?: string): string;
+/**
+ * Composable for formatting utilities
+ */
+/**
+ * Convert grams to pounds
+ */
+export declare function gramsToPounds(grams: number): number;
+/**
+ * Convert pounds to grams
+ */
+export declare function poundsToGrams(pounds: number): number;
+/**
+ * Format weight from grams to pounds and ounces display
+ */
+export declare function formatWeight(gramsValue: number | string | null | undefined, showUnit?: boolean, precision?: number): string;
+/**
+ * Format weight as pounds only (for input fields)
+ */
+export declare function formatWeightAsPounds(gramsValue: number | string | null | undefined, precision?: number): number;
+/**
+ * Parse weight input (supports both lbs and oz)
+ */
+export declare function parseWeightInput(input: string): number;
+export declare function useFormat(): {
+    formatPrice: typeof formatPrice;
+    formatCurrency: typeof formatPrice;
+    formatNumber: typeof formatNumber;
+    formatDate: typeof formatDate;
+    formatDateTime: typeof formatDateTime;
+    formatTime: typeof formatTime;
+    formatDuration: typeof formatDuration;
+    truncateText: typeof truncateText;
+    formatFileSize: typeof formatFileSize;
+    formatPhoneNumber: typeof formatPhoneNumber;
+    formatPickupAddress: typeof formatPickupAddress;
+    formatOperatingHours: typeof formatOperatingHours;
+    formatWeight: typeof formatWeight;
+    formatWeightAsPounds: typeof formatWeightAsPounds;
+    gramsToPounds: typeof gramsToPounds;
+    poundsToGrams: typeof poundsToGrams;
+    parseWeightInput: typeof parseWeightInput;
+};
+/**
+ * Format a date
+ */
+export declare function formatDate(dateString: string | Date | null, options?: Intl.DateTimeFormatOptions, locale?: string): string;
+/**
+ * Format a date with time
+ */
+export declare function formatDateTime(dateString: string | Date | null, locale?: string): string;
+/**
+ * Format just the time portion of a date
+ */
+export declare function formatTime(dateString: string | Date | null, locale?: string): string;
+/**
+ * Format a duration in milliseconds to human readable format
+ */
+export declare function formatDuration(milliseconds: number): string;
+/**
+ * Truncate text with ellipsis
+ */
+export declare function truncateText(text: string, maxLength?: number): string;
+/**
+ * Format a file size
+ */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * Format a phone number
+ */
+export declare function formatPhoneNumber(phoneNumber: string): string;
+/**
+ * Format a pickup location address for display
+ * @param {any} address - The address object from a pickup location
+ * @returns {string} - Formatted address string
+ */
+export declare function formatPickupAddress(address: unknown): string;
+/**
+ * Format operating hours for display
+ * @param {string|object} hoursData - The operating hours data (JSON string or object)
+ * @returns {string} - Formatted hours string
+ */
+export declare function formatOperatingHours(hoursData: unknown): string;
+interface FormattedAddress {
+    formatted: string;
+    street1?: string;
+    street2?: string;
+    city?: string;
+    state_code?: string;
+    postal_code?: string;
+    country_name?: string;
+}
+export declare function formatAddress(address: FormattedAddress | null | undefined): string[];
+export {};

package/dist/utils/isPresignedAwsUrl.d.ts

@@ -0,0 +1,67 @@
+import type { ImageApiResponse } from '../types/image';
+/**
+ * Checks if a URL is an AWS pre-signed URL by detecting the X-Amz-Signature parameter.
+ * Used to prevent URL manipulation that would invalidate AWS SigV4 signatures.
+ *
+ * @param url - The URL to check
+ * @returns boolean - True if the URL contains an AWS signature
+ */
+export declare const isPresignedAwsUrl: (url: string | null | undefined) => boolean;
+/**
+ * Sanitizes a URL by ensuring it's properly formatted.
+ * Handles relative URLs, ensures HTTPS for AWS/S3 URLs, and more.
+ *
+ * @param url - The URL to sanitize
+ * @returns string - A sanitized URL that's safe to use
+ */
+export declare const sanitizeUrl: (url: string | null | undefined) => string;
+/**
+ * Returns a display-safe image URL that preserves AWS pre-signed URL signatures.
+ * Only adds cache-busting to non-AWS URLs.
+ *
+ * @param url - The original image URL
+ * @param cacheBuster - Optional custom cache buster string (defaults to timestamp in base36)
+ * @returns string - URL safe for image display
+ */
+export declare const getSafeImageUrl: (url: string | null | undefined, cacheBuster?: string) => string;
+/**
+ * Vue composable function to get a safe image URL with built-in reactivity
+ *
+ * @param imageUrl - Reactive or static image URL
+ * @param cacheBuster - Optional cache buster
+ * @returns Safe URL string
+ */
+export declare const useSafeImageUrl: (imageUrl: string | null | undefined, cacheBuster?: string) => string;
+/**
+ * Gets the best image URL based on desired size and availability
+ * Uses a smart selection algorithm that:
+ * 1. Prefers conversion URLs if they exist (thumb, preview)
+ * 2. Falls back to original_url if no conversions
+ * 3. Makes sure all URLs are safely handled for AWS signatures
+ *
+ * @param image - The image object from the API
+ * @param preferredSize - Preferred size ('thumb', 'preview', or 'original')
+ * @returns The best available image URL, safely handled
+ */
+export declare const getBestImageUrl: (image: ImageApiResponse | null | undefined, preferredSize?: "thumb" | "preview" | "original") => string;
+/**
+ * Gets a thumbnail URL for an image, optimized for grid/list views
+ *
+ * @param image - The image object from the API
+ * @returns Safe thumbnail URL
+ */
+export declare const getThumbUrl: (image: ImageApiResponse | null | undefined) => string;
+/**
+ * Gets a preview URL for an image, optimized for preview displays
+ *
+ * @param image - The image object from the API
+ * @returns Safe preview URL
+ */
+export declare const getPreviewUrl: (image: ImageApiResponse | null | undefined) => string;
+/**
+ * Gets the original URL for an image at full resolution
+ *
+ * @param image - The image object from the API
+ * @returns Safe original URL
+ */
+export declare const getOriginalUrl: (image: ImageApiResponse | null | undefined) => string;

package/dist/utils/media-helpers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Media helper utilities
+ * Provides utility functions for working with media objects throughout the application
+ */
+import type { Media } from '~/types/media';
+/**
+ * Get the thumbnail URL for a media object with proper type safety
+ * This is a utility version of the composable for use in non-component contexts
+ *
+ * @param media - The media object
+ * @param fallback - Fallback URL if no thumbnail is available
+ * @returns The thumbnail URL or fallback
+ */
+export declare function getThumbnailUrl(media?: Media | null, fallback?: string): string;
+/**
+ * Check if a media object has a valid thumbnail
+ * @param media - The media object to check
+ * @returns True if the media has a thumbnail URL
+ */
+export declare function hasThumbnail(media?: Media | null): boolean;
+/**
+ * Get all available conversion URLs for a media object
+ * @param media - The media object
+ * @returns Object containing all conversion URLs
+ */
+export declare function getConversionUrls(media?: Media | null): Record<string, string>;
+/**
+ * Create a Media object from partial data
+ * Useful for creating mock media objects or handling API responses
+ *
+ * @param partial - Partial media data
+ * @returns A complete Media object with defaults
+ */
+export declare function createMediaObject(partial: Partial<Media>): Media;

package/dist/utils/normalisePricing.d.ts

@@ -0,0 +1,11 @@
+export interface PricingDTO {
+    base_price: number;
+    final_price: number;
+    sale_price: number | null;
+    currency: string;
+    discount_amount: number;
+    discount_percentage: number;
+    show_discount: boolean;
+    [k: string]: unknown;
+}
+export declare function normalisePricingResponse(raw: unknown): Promise<PricingDTO>;

package/dist/utils/recipe-generator.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Video Recipe Generator
+ *
+ * Generates export recipes for server-side video processing
+ * Converts editor state into FFmpeg-compatible instructions
+ */
+import type { VideoRecipe, VideoEditorState } from '../types/video';
+/**
+ * Generate a complete video recipe from editor state
+ */
+export declare function generateRecipe(editor: VideoEditorState): VideoRecipe;
+/**
+ * Calculate total export duration from recipe
+ */
+export declare function calculateExportDuration(recipe: VideoRecipe): number;
+/**
+ * Generate FFmpeg command from recipe
+ */
+export declare function generateFFmpegCommand(recipe: VideoRecipe): string;
+/**
+ * Validate recipe structure
+ */
+export declare function validateRecipe(recipe: VideoRecipe): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Merge multiple recipes (for collaborative editing)
+ */
+export declare function mergeRecipes(base: VideoRecipe, updates: Partial<VideoRecipe>): VideoRecipe;
+/**
+ * Create a simple recipe for basic trim operation
+ */
+export declare function createTrimRecipe(mediaUuid: string, startTime: number, endTime: number, duration: number): VideoRecipe;

package/dist/utils/string.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Convert a string to camel case.
+ * Example: 'hello-world' -> 'helloWorld'
+ */
+export declare function camelCase(str: string): string;
+/**
+ * Convert a string to kebab case.
+ * Example: 'helloWorld' -> 'hello-world'
+ */
+export declare function kebabCase(str: string): string;
+/**
+ * Convert a string to title case.
+ * Example: 'hello-world' -> 'Hello World'
+ */
+export declare function titleCase(str: string, preserveUppercase?: boolean): string;
+/**
+ * Convert a string to pascal case.
+ * Example: 'hello-world' -> 'HelloWorld'
+ */
+export declare function pascalCase(str: string): string;
+/**
+ * Convert a string to snake case.
+ * Example: 'helloWorld' -> 'hello_world'
+ */
+export declare function snakeCase(str: string): string;
+/**
+ * Generate a URL-friendly slug.
+ */
+export declare function slugify(str: string): string;

package/dist/utils/unwrapApiResponse.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Robustly unwrap an Axios / ofetch response.
+ * Always returns the inner payload (array | object).
+ */
+export declare function unwrapApiResponse<T = any>(raw: unknown): T;

package/dist/utils/uuid.d.ts

@@ -0,0 +1,30 @@
+/**
+ * UUID generation utility that works across all browsers and environments
+ * Falls back to a timestamp-based UUID v4-like implementation if crypto.randomUUID is not available
+ */
+/**
+ * Generate a UUID v4 compliant string
+ * First tries native crypto.randomUUID, then falls back to a custom implementation
+ */
+export declare function generateUUID(): string;
+/**
+ * Generate a short ID (non-UUID compliant but useful for temporary IDs)
+ * Useful for component keys, temporary IDs, etc.
+ */
+export declare function generateShortId(): string;
+/**
+ * Validate if a string is a valid UUID v4
+ */
+export declare function isValidUUID(uuid: string): boolean;
+/**
+ * Generate a namespaced UUID (deterministic based on input)
+ * Useful for creating consistent IDs based on input data
+ */
+export declare function generateNamespacedUUID(namespace: string, name: string): string;
+/**
+ * Create a UUID generator with a specific prefix
+ * Useful for debugging and identifying UUID sources
+ */
+export declare function createPrefixedUUIDGenerator(prefix: string): () => string;
+export declare const uuid: typeof generateUUID;
+export declare const shortId: typeof generateShortId;

package/dist/utils/validators.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Validate an email address
+ */
+export declare function isValidEmail(email: string): boolean;
+/**
+ * Validate a password (minimum 8 characters, at least one letter and one number)
+ */
+export declare function isValidPassword(password: string): boolean;
+/**
+ * Validate a phone number
+ */
+export declare function isValidPhoneNumber(phoneNumber: string): boolean;
+/**
+ * Validate a credit card number using Luhn algorithm
+ */
+export declare function isValidCreditCard(cardNumber: string): boolean;
+/**
+ * Validate a credit card expiration date (MM/YY format)
+ */
+export declare function isValidExpiryDate(expiryDate: string): boolean;
+/**
+ * Validate a CVV (3-4 digits)
+ */
+export declare function isValidCVV(cvv: string): boolean;
+/**
+ * Validate a postal code (US or Canada)
+ */
+export declare function isValidPostalCode(postalCode: string, countryCode?: string): boolean;

package/dist/utils/video-export.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Export bridge between our editor and Mediables video engine
+ * Converts our timeline/recipe format to Mediables composition
+ */
+import type { VideoRecipe } from '../types/video';
+import { MediablesCompositionAdapter } from '../video-engine/adapters/MediablesCompositionAdapter';
+import { type ExportOptions } from '../video-engine/adapters/ExportManager';
+import { RenderQueue } from '../video-engine/adapters/RenderQueue';
+/**
+ * Export video with advanced options using ExportManager
+ */
+export declare function exportWithMediablesEngine(recipe: VideoRecipe, videoUrl: string, options?: {
+    quality?: string;
+    frameRate?: number;
+    width?: number;
+    height?: number;
+    onProgress?: (percent: number) => void;
+    preset?: string;
+    watermark?: ExportOptions['watermark'];
+}): Promise<Blob>;
+/**
+ * Export video with preset configuration
+ */
+export declare function exportWithPreset(recipe: VideoRecipe, presetId: string, options?: {
+    onProgress?: (percent: number) => void;
+    watermark?: ExportOptions['watermark'];
+}): Promise<Blob>;
+/**
+ * Create a render queue for batch exports
+ */
+export declare function createRenderQueue(options?: {
+    maxConcurrent?: number;
+    persistHistory?: boolean;
+}): RenderQueue;
+/**
+ * Add export job to render queue
+ */
+export declare function queueExport(queue: RenderQueue, recipe: VideoRecipe, name: string, options?: ExportOptions): Promise<string>;
+/**
+ * Create a composition for real-time playback
+ * Returns an adapter that can be controlled programmatically
+ */
+export declare function createComposition(recipe: VideoRecipe, options?: {
+    width?: number;
+    height?: number;
+    fps?: number;
+}): Promise<MediablesCompositionAdapter>;
+/**
+ * Export preview using our existing canvas
+ * MediaRecorder-based preview export has been intentionally removed.
+ */
+export declare function exportPreview(canvas: HTMLCanvasElement, duration: number): Promise<Blob>;
+/**
+ * Helper to convert seconds to frames
+ */
+export declare function secondsToFrames(seconds: number, fps?: number): number;
+/**
+ * Helper to convert frames to seconds
+ */
+export declare function framesToSeconds(frames: number, fps?: number): number;