react-native-ensys-camera-x 1.0.7

package/lib/module/localization.js

@@ -0,0 +1,1064 @@
+"use strict";
+
+import React, { createContext, useContext, useEffect, useMemo, useState } from 'react';
+import { I18nManager, NativeModules, StyleSheet } from 'react-native';
+import { DEFAULT_LOCALE, isRtlLocale, normalizeLocale, resolveLocaleTranslations } from "./locales.js";
+
+/**
+ * Translations for many languages at once, keyed by language identifier.
+ *
+ * Keys are BCP-47 tags in whatever spelling the host already uses — `fr`,
+ * `pt-BR`, `zh_CN`, `zh-Hant` all work, and lookup is case- and
+ * separator-insensitive. Register the whole set once and switch languages with
+ * {@link setCameraLanguage}.
+ *
+ * ```ts
+ * const bundles: CameraTranslationBundles = {
+ *   fr: { send: 'Envoyer', cancel: 'Annuler' },
+ *   ar: { send: 'إرسال', cancel: 'إلغاء' },
+ * };
+ * ```
+ */
+
+/**
+ * Whatever a host's `subscribe` happens to hand back. Functions, RN's
+ * `EmitterSubscription` (`remove`), and Rx-style subscriptions (`unsubscribe`)
+ * are all accepted so the provider can usually be a one-line adapter over an
+ * i18n library the host already has; returning nothing is fine too.
+ */
+
+/**
+ * A live view of the host app's active language. Bind one once at startup and
+ * every plugin surface — React Native screens *and* the native Android camera —
+ * follows the host from then on, with no further calls on language change.
+ *
+ * The host stays the single source of truth: the plugin only reads this, never
+ * the device locale, and keeps no language state of its own beyond the last
+ * value read here.
+ *
+ * ```ts
+ * configureCameraPlugin({
+ *   language: {
+ *     get: () => i18n.language,
+ *     subscribe: (onChange) => {
+ *       i18n.on('languageChanged', onChange);
+ *       return () => i18n.off('languageChanged', onChange);
+ *     },
+ *   },
+ *   translations: myBundles,
+ * });
+ * ```
+ */
+
+export const defaultTranslations = {
+  all: 'All',
+  photos: 'Photos',
+  videos: 'Videos',
+  documents: 'Documents',
+  cancel: 'Cancel',
+  done: 'Done',
+  ok: 'OK',
+  use: 'Use',
+  trim: 'Trim',
+  selectCover: 'Select cover',
+  add: 'Add',
+  addMore: 'Add more',
+  addMorePlus: '+ Add more',
+  mediaCounter: '{0} / {1}',
+  trimRangeLabel: '{0}  –  {1}',
+  durationZero: '0:00',
+  fileSizeBytes: '{0} B',
+  fileSizeKb: '{0} KB',
+  fileSizeMb: '{0} MB',
+  fileSizeGb: '{0} GB',
+  dateFormatPattern: 'MMM dd, yyyy',
+  openSettings: 'Open Settings',
+  close: 'Close',
+  back: 'Back',
+  send: 'Send',
+  save: 'Save',
+  delete: 'Delete',
+  deleteFile: 'Delete file',
+  clear: 'Clear',
+  clearFilter: 'Clear applied filter',
+  filterClearSuffix: '{0} (Clear)',
+  audio: 'Audio',
+  document: 'Document',
+  openingCamera: 'Opening camera...',
+  initializingCamera: 'Initializing camera...',
+  gallery: 'Gallery',
+  selectedCount: '{0} selected',
+  openGallery: 'Open gallery',
+  openWith: 'Open with',
+  libraryEmptyTitle: 'Nothing here yet',
+  libraryEmptyMessage: 'Tap the + button to capture photos and videos with the camera',
+  share: 'Share',
+  photoMode: 'Photo',
+  videoMode: 'Video',
+  recording: 'Recording',
+  shutterCapture: 'Capture',
+  shutterHoldToRecord: 'Capture. Hold to record video',
+  holdForVideo: 'Hold for video, tap for photo',
+  slideUpToLock: 'Slide up to lock',
+  slideToCancel: 'Slide to cancel',
+  cancelRecording: 'Cancel',
+  releaseToCancel: 'Release to cancel',
+  recordingLocked: 'Recording locked · Tap to stop',
+  flashOn: 'Flash on',
+  flashOff: 'Flash off',
+  flashAuto: 'Flash auto',
+  switchCamera: 'Switch camera',
+  toggleFlashlight: 'Toggle flashlight',
+  pointCameraAtBarcode: 'Point the camera at a QR code or barcode',
+  closeScanner: 'Close scanner',
+  permissionRequiredTitle: 'Permission required',
+  permissionRequiredMessage: 'Camera and media access are needed to use the camera. Please enable the permissions for this app in Settings.',
+  permissionCameraRequiredMessage: 'Camera access is needed to use the camera. Please enable it for this app in Settings.',
+  permissionMediaRequiredTitle: 'Gallery access required',
+  permissionMediaRequiredMessage: 'Photo and video access is needed to browse your gallery. Please enable it for this app in Settings.',
+  permissionRationaleCameraPersistentMessage: 'This app needs camera access to take photos and record video. When the system asks, choose "While using the app" so you are not asked again each time you reopen the app.',
+  permissionContinue: 'Continue',
+  permissionRationaleCameraTitle: 'Camera Permission Required',
+  permissionRationaleCameraMessage: 'This app needs camera access to take photos and record videos.',
+  permissionRationaleStorageTitle: 'Storage Permission Required',
+  permissionRationaleStorageMessage: 'This app needs storage access to save photos and videos to your gallery.',
+  permissionRationaleMicrophoneTitle: 'Microphone Permission Required',
+  permissionRationaleMicrophoneMessage: 'This app needs microphone access to record audio with videos.',
+  permissionGrant: 'Grant',
+  permissionDeny: 'Deny',
+  cameraUnavailable: 'Camera not available on this device',
+  cameraNotFound: 'No camera found. Check device settings.',
+  cameraInitializationFailed: 'Failed to initialize camera. Please try again.',
+  cameraPermissionDenied: 'Camera permission denied',
+  cameraPermissionRequired: 'Camera permission is required to use this feature',
+  tapToScan: 'Tap to scan',
+  preparingVideo: 'Preparing video...',
+  selectionTooShort: 'Selection too short',
+  trimming: 'Trimming...',
+  trimFailed: 'Trim failed',
+  cropping: 'Cropping...',
+  cropFailed: 'Crop failed',
+  savingCover: 'Saving cover...',
+  couldNotSetCover: 'Could not set cover',
+  coverUpdated: 'Cover updated',
+  saving: 'Saving...',
+  savedToGallery: 'Saved to gallery',
+  failedToSaveMedia: 'Failed to save media',
+  sending: 'Sending...',
+  failedToSendMedia: 'Failed to send media',
+  couldNotSaveEditsSendingOriginal: 'Could not save edits, sending original',
+  sendFailed: 'Send failed',
+  sendFailedWithMessage: 'Send failed: {0}',
+  addTextTitle: 'Add text',
+  addTextButton: 'Add',
+  typeTextHint: 'Type text',
+  sizeLabel: 'Size: {0}',
+  drawOnImage: 'Draw on the image',
+  preparing: 'Preparing...',
+  couldNotPrepareEditsForCropping: 'Could not prepare edits for cropping',
+  useTwoFingersToResizeOrRotate: 'Use two fingers to resize or rotate',
+  operationTimedOut: 'Operation timed out',
+  audioMuted: 'Audio muted',
+  audioOn: 'Audio on',
+  compressVideo: 'Compress Video',
+  originalVideo: 'Original video',
+  compressImage: 'Compress Image',
+  originalImage: 'Original image',
+  compressionProfile: 'Compression',
+  profileRecommended: 'Recommended',
+  compressionAlreadyMinimal: 'Already as small as it gets — keeping the original',
+  compressEstimatedSize: '{0} (~{1})',
+  compressOriginalSize: '{0} ({1})',
+  compressSizeRange: '{0} – {1}',
+  compressedToSize: 'Compressed to {0} ({1}% smaller)',
+  compressedToSizeOnly: 'Compressed to {0}',
+  compressionFailed: 'Compression failed',
+  compressingSecondsLeft: 'Compressing ({0}s left)',
+  finalizingCompression: 'Finalizing...',
+  compressActiveLabel: '{0}% quality',
+  compressSmallerByPercent: 'Smaller by {0}%',
+  selectedOption: '{0}, selected',
+  moreOptions: 'More options',
+  exportBy: 'Save As',
+  exportActiveDesc: 'Save format: {0}',
+  originalFormat: 'Original',
+  exportingMedia: 'Saving…',
+  convertingSecondsLeft: 'Exporting ({0}s left)',
+  exportFailed: 'Export failed',
+  exportedTo: 'Exported as {0}',
+  exportedToFormat: 'Exported as {0} ({1})',
+  exportedAudioDropped: 'Exported as {0} — {1} cannot carry this audio track, so audio was removed',
+  convertGifExportMessage: 'Exporting this GIF to another format will remove its animation and save it as a still image.',
+  convertGifCompressMessage: 'Compressing this GIF will remove its animation and save it as a still image.',
+  convertGifTitle: 'Convert GIF to image?',
+  keepAnimation: 'Keep animation',
+  convertToImage: 'Convert',
+  clearAppliedFilter: 'Clear applied filter',
+  toggleAudio: 'Toggle audio',
+  trimVideo: 'Trim video',
+  rotate90Degrees: 'Rotate 90 degrees',
+  cropAspectRatio: 'Aspect ratio',
+  cropAspectFree: 'Free',
+  noStickersAvailable: 'No stickers available',
+  noEmojisAvailable: 'No emojis available',
+  filterClearLabel: '{0} (Clear)',
+  emptyFile: '(empty file)',
+  previewTruncated: 'preview truncated',
+  unsupportedPreviewKind: 'Unsupported preview kind: {0}',
+  fileNotPreviewableText: 'File is not previewable text',
+  couldNotOpenPdf: 'Could not open PDF: {0}',
+  cannotOpenDocumentStream: 'Cannot open document stream',
+  couldNotReadFile: 'Could not read file: {0}',
+  webViewUnavailable: 'WebView unavailable: {0}',
+  notDecodableImage: 'Not a decodable image',
+  couldNotDecodeImage: 'Could not decode image: {0}',
+  documentPreviewUnavailable: 'Document preview unavailable',
+  filterNone: 'None',
+  filterAuto: 'Auto',
+  filterGray: 'Gray',
+  filterNegative: 'Negative',
+  filterBright: 'Bright',
+  filterContrast: 'Contrast',
+  filterSharpen: 'Sharpen',
+  filterFilm: 'Film',
+  filterTint: 'Tint',
+  filterVignette: 'Vignette',
+  filterSoft: 'Soft',
+  filterDark: 'Dark',
+  filterLight: 'Light',
+  filterDesaturate: 'Desaturate',
+  filterEnhance: 'Enhance',
+  filterCinematic: 'Cinematic',
+  filterBW: 'B&W',
+  filterSepia: 'Sepia',
+  filterVintage: 'Vintage',
+  filterCool: 'Cool',
+  filterWarm: 'Warm',
+  filterSaturate: 'Saturate',
+  filterFade: 'Fade',
+  filterVivid: 'Vivid',
+  filterNormal75: 'Normal (75%)',
+  categoryClassic: 'Classic',
+  categoryFaces: 'Faces',
+  categoryLove: 'Love',
+  categoryCelebration: 'Celebration',
+  categoryAnimals: 'Animals',
+  categoryFood: 'Food',
+  categoryVibes: 'Vibes',
+  categorySmileys: 'Smileys',
+  categoryPeople: 'People',
+  categoryAnimalsAndNature: 'Animals & Nature',
+  categoryFoodAndDrink: 'Food & Drink',
+  categoryActivities: 'Activities',
+  categoryTravelAndPlaces: 'Travel & Places',
+  categoryObjects: 'Objects',
+  categorySymbols: 'Symbols',
+  categoryFlags: 'Flags',
+  categoryRecent: 'Recent',
+  uploadProgressTitle: 'Upload Progress',
+  uploadProgressDescription: 'Displays progress of background uploads',
+  uploadStatusTitle: 'Upload Status',
+  uploadStatusDescription: 'Notifies when a background upload completes or fails',
+  uploadInterruptedTitle: 'Upload interrupted',
+  uploadInterruptedMessage: 'A previous upload stopped before completing (file {0} of {1}).',
+  uploadRetrying: 'Retrying file {0} of {1} (attempt {2} of {3})...',
+  uploadCompletedTitle: 'Upload completed',
+  uploadCompletedMessage: 'Successfully uploaded {0} file(s).',
+  uploadFailedTitle: 'Upload failed',
+  uploadFailedMessage: 'Uploaded {0} of {1} file(s) - {2} failed. {3}',
+  uploadingFileProgress: 'Uploading file {0} of {1} ({2}%)',
+  preparingFilesProgress: 'Preparing files... ({0}%)',
+  uploadingMediaTitle: 'Uploading media',
+  validationSelectionLimitNonNegativeInteger: 'Selection limit must be a non-negative integer',
+  validationInitialCameraInvalid: 'Initial camera must be either "back" or "front"',
+  validationMediaTypesInvalid: 'Media type must be one of: "all", "photo", "video"',
+  validationHoldToRecordDelayInvalid: 'Hold-to-record delay must be a non-negative number of milliseconds (0 = system long-press timeout)',
+  validationMinRecordDurationInvalid: 'Minimum recording duration must be a non-negative number of milliseconds',
+  validationUrisMustBeArray: 'Media URIs must be an array',
+  validationUrisCannotBeEmpty: 'Media URIs cannot be empty',
+  validationTooManyFiles: 'Cannot process more than {0} files at once',
+  validationInvalidUriAtIndex: 'Invalid URI at index {0}: {1}',
+  validationAlbumNameRequired: 'Album name must be a non-empty string',
+  validationAlbumNameTooLong: 'Album name cannot exceed {0} characters',
+  validationAlbumNameInvalidCharacters: 'Album name contains invalid characters: / : * ? " < > |',
+  validationCaptionMustBeString: 'Caption must be a string',
+  validationCaptionTooLong: 'Caption cannot exceed {0} characters',
+  validationDelayMustBeNumber: 'Delay must be a valid number',
+  validationDelayCannotBeNegative: 'Delay cannot be negative',
+  validationDelayTooLong: 'Delay cannot exceed {0} seconds',
+  validationStartTimeInvalid: 'Start time must be a non-negative number',
+  validationEndTimeInvalid: 'End time must be a non-negative number',
+  validationStartBeforeEnd: 'Start time must be less than end time',
+  validationTrimDurationTooLong: 'Trim duration cannot exceed {0} seconds',
+  validationUploadUrlRequired: 'Upload URL must be a non-empty string',
+  validationUploadUrlInvalid: 'Upload URL must be a valid URL',
+  validationFileTooLarge: '{0} is too large ({1}MB). Maximum allowed size is {2}MB',
+  validationAlbumIdRequired: 'Album ID must be a non-empty string',
+  validationAlbumIdTooLong: 'Album ID cannot exceed {0} characters',
+  validationDegreesMustBeNumber: 'Degrees must be a valid number',
+  validationDegreesInvalid: 'Degrees must be one of: 0, 90, 180, 270',
+  validationWidthPositive: 'Width must be a positive number',
+  validationHeightPositive: 'Height must be a positive number',
+  validationXNumber: 'X coordinate must be a number',
+  validationYNumber: 'Y coordinate must be a number',
+  validationFilterTypeInvalid: 'Invalid filter type: {0}. Valid options: {1}',
+  validationFlashModeInvalid: 'Invalid flash mode: {0}. Valid options: {1}',
+  validationFaceEffectInvalid: 'Invalid face effect: {0}. Valid options: {1}',
+  validationThemeInvalid: 'Invalid camera theme: {0}. Valid options: {1}',
+  errorCameraPermission: 'Camera permission is required to use this feature',
+  errorPleaseEnableCameraPermission: 'Please enable camera permission in settings',
+  errorMicrophonePermission: 'Microphone permission is required for video recording',
+  errorMicrophoneDeniedSilentVideo: 'Microphone access denied — this video will be recorded without sound',
+  errorStoragePermission: 'Storage permission is required to save media',
+  errorGalleryPermission: 'Gallery permission is required to browse your media',
+  errorInvalidUri: 'Invalid media file',
+  errorFileNotFound: 'Media file not found',
+  errorFileTooLarge: 'File is too large to process',
+  errorOperationCancelled: 'Operation was cancelled',
+  errorCameraUnavailable: 'Camera is not available on this device',
+  errorInsufficientStorage: 'Not enough storage space available',
+  errorStorageFullVideo: 'Not enough storage space to record a video.',
+  noticeStorageFullStopped: 'Storage is full — recording stopped.',
+  storageAlmostFullTitle: 'Storage almost full',
+  storageAlmostFullMessage: 'Storage space is almost full. The current recording will be finalized to prevent data loss.',
+  memoryCriticalTitle: 'Low memory',
+  memoryCriticalMessage: 'Your device is running critically low on memory. The current recording will be finalized to prevent crashes or data loss.',
+  next: 'Next',
+  errorRecordingFailed: 'Recording could not be saved. Please try again.',
+  errorNetworkUnavailable: 'Network connection is required',
+  errorUploadFailed: 'Failed to upload media',
+  errorMediaLoadFailed: 'Unable to open the selected media',
+  errorUnknown: 'An error occurred',
+  statusReady: 'Ready',
+  statusProcessingWithProgress: 'Processing... {0}%',
+  statusProcessing: 'Processing...',
+  statusSuccess: 'Completed successfully',
+  statusUnknown: 'Unknown status',
+  // ===== Multilingual coverage additions =====
+  unknown: 'Unknown',
+  untitled: 'Untitled',
+  preview: 'Preview',
+  media: 'Media',
+  image: 'Image',
+  video: 'Video',
+  deleteConfirmTitle: 'Delete this item?',
+  deleteConfirmMessage: 'Are you sure you want to delete this item? This action cannot be undone.',
+  notSecurelyErasedTitle: 'Removed, but not securely erased',
+  notSecurelyErasedMessage: 'This item was removed from your library, but its file data could not be fully overwritten. It may still be recoverable from device storage.',
+  deleteMedia: 'Delete media',
+  shareMedia: 'Share media',
+  toolFilter: 'Filter',
+  toolCrop: 'Crop',
+  toolText: 'Text',
+  toolEmoji: 'Emoji',
+  toolGrid: 'Grid',
+  emoji: 'Emoji',
+  stickers: 'Stickers',
+  toolGif: 'GIF',
+  gifPickerTitle: 'Add GIF',
+  gifSearchPlaceholder: 'Search GIFs',
+  gifTrending: 'Trending',
+  gifCategories: 'Categories',
+  noGifsFound: 'No GIFs found',
+  gifLoadError: "Couldn't load GIFs",
+  gifOfflineError: 'No internet connection',
+  gifNotConfigured: 'GIF picker is not set up',
+  gifRateLimited: 'Too many requests. Try again shortly.',
+  gifLoading: 'Loading GIFs…',
+  deleteGif: 'Delete GIF',
+  categoryGestures: 'Gestures',
+  playVideo: 'Play video',
+  pauseVideo: 'Pause video',
+  deleteSticker: 'Delete sticker',
+  closeEditor: 'Close editor',
+  download: 'Download',
+  selectedVideo: 'Selected video',
+  selectedPhoto: 'Selected photo',
+  removeSelectedItem: 'Remove selected item',
+  addMoreMedia: 'Add more media',
+  compressingPleaseWait: 'Compressing, please wait',
+  compressingEllipsis: 'Compressing…',
+  selectFilterTitle: 'Select Filter',
+  filterAccessibilityLabel: '{0} filter',
+  closeFilters: 'Close filters',
+  recordAudio: 'Record Audio',
+  browseAudio: 'Browse Audio',
+  camera: 'Camera',
+  closeActionsMenu: 'Close actions menu',
+  openActionsMenu: 'Open actions menu',
+  micPermanentlyDenied: 'Microphone permission permanently denied. Please enable it in Settings.',
+  micPermissionDenied: 'Microphone permission denied.',
+  micPermissionRequestFailed: 'Failed to request microphone permission.',
+  failedToStartRecording: 'Failed to start recording',
+  micPermissionNotGranted: 'Microphone permission not granted.',
+  recordingTooShort: 'Recording too short. Hold for at least 0.5 seconds.',
+  failedToSaveRecording: 'Failed to save recording',
+  requestingPermission: 'Requesting Permission',
+  allowMicAccess: 'Please allow microphone access to record audio.',
+  recordingError: 'Recording Error',
+  tryAgain: 'Try Again',
+  pausedBadge: 'PAUSED',
+  paused: 'Paused',
+  tapToStartRecording: 'Tap the button below to start recording',
+  discard: 'Discard',
+  pause: 'Pause',
+  resume: 'Resume',
+  savingRecording: 'Saving recording…',
+  micRationaleMessage: 'This app needs microphone access to record audio.',
+  unknownSize: 'Unknown size',
+  noAppToOpenFile: 'No app available to open this file.',
+  couldNotOpenFile: 'Could not open this file.',
+  pageCountSingular: '{0} page',
+  pageCountPlural: '{0} pages',
+  fileCouldNotBePreviewed: 'This file could not be previewed.',
+  noInAppPreview: 'No in-app preview for this format.',
+  openNamed: 'Open {0}',
+  open: 'Open',
+  opening: 'Opening…',
+  compressing: 'Compressing...',
+  errorProcessPhoto: 'Failed to process captured photo.',
+  errorCapturePhoto: 'Failed to capture photo. Please try again.',
+  uploadErrorCouldNotOpenStream: 'Could not open the file to upload',
+  uploadErrorCouldNotOpenFile: 'Could not open file: {0}',
+  uploadErrorServerCode: 'Server returned error code: {0}',
+  uploadErrorNetwork: 'Network error: {0}',
+  powerPointPresentationTitle: 'PowerPoint presentation',
+  couldNotOpenPresentation: 'Could not open presentation: {0}',
+  couldNotReadPowerPoint: 'Could not read PowerPoint presentation: {0}',
+  couldNotOpenDocument: 'Could not open document: {0}',
+  couldNotConvertDocument: 'Could not convert document: {0}',
+  officeBinaryPreviewNote: 'Text preview shown below — open in PowerPoint, Google Slides, or WPS Office for full formatting and images.',
+  unableToExtractBinaryText: 'Unable to extract text from this binary file. Open in PowerPoint for the best experience.',
+  openInOfficeAppNote: 'Open this file in PowerPoint, Google Slides, or WPS Office for the best viewing experience.',
+  previewTruncatedRowsCols: 'Preview truncated — showing first {0} rows / {1} columns',
+  previewTruncatedRows: 'Preview truncated — showing first {0} rows',
+  previewTruncatedChapters: 'Preview truncated — first {0} chapters',
+  previewTruncatedNotice: 'Preview truncated',
+  powerPointNoSlides: 'No slides',
+  unknownDate: 'Unknown date',
+  aspectRatioOriginal: 'Original',
+  aspectRatioFull: 'Full',
+  aspectRatioOriginalShort: 'Original',
+  gifBadge: 'GIF',
+  textFontSample: 'Aa',
+  slideNumberLabel: 'SLIDE {0}',
+  docTypePowerpoint: 'PowerPoint Presentation',
+  docTypeWord: 'Word Document',
+  docTypeExcel: 'Excel Spreadsheet',
+  docTypeOffice: 'Office Document',
+  compressActiveDesc: 'Quality: {0}%',
+  convertGifMessage: 'Editing this GIF will remove its animation and save it as a still image.',
+  convertGifCropMessage: 'Cropping this GIF will remove its animation and save it as a still image.',
+  couldNotDecodeImageGeneric: 'Could not decode image',
+  memoryWarningMessage: 'Low memory detected. Background operations are being reduced to keep recording stable.',
+  savingEdits: 'Saving edits...',
+  textCancel: 'Cancel text',
+  textFont: 'Change font',
+  textAlignment: 'Change text alignment',
+  textBackground: 'Change text background',
+  textDone: 'Apply text',
+  // GIF picker / overlay (native MediaPreviewEditor). gifNotConfigured, gifRateLimited
+  // and gifLoadError already have defaults in the "Editor GIF picker" section above.
+  gifSearchHint: 'Search GIFs',
+  addingGif: 'Adding GIF…',
+  gifLoadFailed: "Couldn't load that GIF",
+  gifOffline: 'No internet connection',
+  gifTimeout: 'The request timed out',
+  gifServerError: 'The GIF service is unavailable',
+  gifNoResults: 'No GIFs found',
+  // Media library shell — details sheet, metadata rows and formatting units
+  mediaDetails: 'Media details',
+  photoDetails: 'Photo details',
+  videoDetails: 'Video details',
+  metaFileName: 'File name',
+  metaFileType: 'File type',
+  metaFileSize: 'File size',
+  metaDuration: 'Duration',
+  metaResolution: 'Resolution',
+  metaDate: 'Date',
+  metaPath: 'Path',
+  pixelsUnit: 'px',
+  viewDetails: 'View details',
+  fileTypeGeneric: 'FILE',
+  audioTypeGeneric: 'AUD',
+  // Full-screen viewer video controls
+  play: 'Play',
+  toggleVideoControls: 'Toggle video controls',
+  seekBackward: 'Rewind {0} seconds',
+  seekForward: 'Forward {0} seconds'
+};
+export const cameraLocalizationKeys = Object.freeze(Object.keys(defaultTranslations));
+function normalizeTranslations(translations) {
+  if (!translations) return {};
+  return cameraLocalizationKeys.reduce((acc, key) => {
+    const value = translations[key];
+    if (typeof value === 'string' && value.length > 0) {
+      acc[key] = value;
+    }
+    return acc;
+  }, {});
+}
+function formatMessage(message, args) {
+  return args.reduce((text, arg, index) => text.split(`{${index}}`).join(arg == null ? '' : String(arg)), message);
+}
+function resolveIsRtl(isRtl, locale) {
+  // Precedence: an explicit override, then the direction implied by the active
+  // language, then whatever direction the host app itself is running in.
+  if (typeof isRtl === 'boolean') return isRtl;
+  if (locale && normalizeLocale(locale).length > 0) return isRtlLocale(locale);
+  return I18nManager.isRTL;
+}
+
+/**
+ * Normalizes whatever a host's `subscribe` returned into a plain unsubscriber.
+ *
+ * Returning `undefined` for an unrecognized shape is deliberate: the binding
+ * still works, it simply cannot be released — better than calling an arbitrary
+ * method on a host object and guessing wrong.
+ */
+function toLanguageUnsubscribe(subscription) {
+  if (typeof subscription === 'function') return subscription;
+  if (typeof subscription !== 'object' || subscription === null) return undefined;
+  const remove = subscription.remove;
+  if (typeof remove === 'function') {
+    return () => remove.call(subscription);
+  }
+  const unsubscribe = subscription.unsubscribe;
+  if (typeof unsubscribe === 'function') {
+    return () => unsubscribe.call(subscription);
+  }
+  return undefined;
+}
+
+/**
+ * True when a value looks like a {@link CameraLanguageProvider} rather than a
+ * language tag. Lets a single `language` option accept either one.
+ */
+export function isCameraLanguageProvider(value) {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value;
+  return typeof candidate.get === 'function' && typeof candidate.subscribe === 'function';
+}
+class LocalizationManagerImpl {
+  bundles = {};
+  fallbackLocale = DEFAULT_LOCALE;
+  locale = '';
+  translations = {
+    ...defaultTranslations
+  };
+  isRtl = resolveIsRtl();
+  listeners = new Set();
+  /**
+   * The host's language authority, when one is bound. Held by identity so a
+   * re-bind of the same object is recognized as a no-op.
+   */
+
+  /** Releases {@link languageProvider}'s subscription. One at a time, always. */
+
+  /**
+   * Binds the host app's language provider — the plugin's language authority for
+   * as long as it stays bound.
+   *
+   * Leak- and duplicate-safe by construction: the previous subscription is always
+   * released before a new one is taken, and re-binding the *same* provider object
+   * only re-reads it, so a startup path that runs more than once (Fast Refresh, a
+   * remount, a second `configureCameraPlugin`) cannot stack listeners.
+   *
+   * @param options.resolve `false` for callers that are about to
+   *   {@link LocalizationManagerImpl.resolve} anyway, keeping a config change to a
+   *   single re-render and a single native push.
+   */
+  bindLanguageProvider(provider, options = {}) {
+    const shouldResolve = options.resolve !== false;
+    if (provider && provider === this.languageProvider) {
+      // Already bound: adopt whatever it reads now, in case the host changed
+      // language through a path that does not notify.
+      if (this.adoptProviderLocale() && shouldResolve) this.resolve();
+      return;
+    }
+    this.releaseLanguageProvider();
+    if (!provider) return;
+    this.languageProvider = provider;
+
+    // Adopt the CURRENT language before subscribing, so a provider bound at
+    // startup takes effect without waiting for a first change event, and so a
+    // provider that notifies synchronously on subscribe finds state in place.
+    const changed = this.adoptProviderLocale();
+    let subscription;
+    try {
+      subscription = provider.subscribe(next => {
+        this.handleProviderLanguageChange(next);
+      });
+    } catch {
+      // A provider that cannot be subscribed to still drives the language it
+      // reported above; it just will not push later changes.
+      subscription = undefined;
+    }
+    this.releaseProviderSubscription = toLanguageUnsubscribe(subscription);
+    if (changed && shouldResolve) this.resolve();
+  }
+
+  /** Detaches the bound provider, if any. The active language is left as-is. */
+  unbindLanguageProvider() {
+    this.releaseLanguageProvider();
+  }
+
+  /**
+   * Re-reads the bound provider and republishes if its language moved. The manual
+   * escape hatch for a host whose provider cannot notify.
+   */
+  syncLanguageFromProvider() {
+    if (!this.languageProvider) return;
+    if (this.adoptProviderLocale()) this.resolve();
+  }
+
+  /** The bound provider, for hosts that need to check whether auto-sync is on. */
+  getLanguageProvider() {
+    return this.languageProvider;
+  }
+  releaseLanguageProvider() {
+    const release = this.releaseProviderSubscription;
+    this.releaseProviderSubscription = undefined;
+    this.languageProvider = undefined;
+    if (!release) return;
+    try {
+      release();
+    } catch {
+      // Teardown is host-owned; a throwing unsubscriber must not break re-binding.
+    }
+  }
+  readProviderLocale() {
+    try {
+      return this.languageProvider?.get();
+    } catch {
+      // A throwing `get()` must not silently drop the plugin back to English.
+      return this.locale;
+    }
+  }
+
+  /**
+   * Pulls the provider's language into `locale`. Returns whether it moved, which
+   * is what lets callers skip a redundant re-render and native push.
+   */
+  adoptProviderLocale() {
+    const next = normalizeLocale(this.readProviderLocale());
+    if (next === this.locale) return false;
+    this.locale = next;
+    return true;
+  }
+  handleProviderLanguageChange(next) {
+    // The tag may arrive with the notification (i18next passes `lng`) or not at
+    // all, in which case `get()` is the authority.
+    const reported = typeof next === 'string' ? next : this.readProviderLocale();
+    const normalized = normalizeLocale(reported);
+    if (normalized === this.locale) return;
+    this.locale = normalized;
+    this.resolve();
+  }
+
+  /**
+   * Re-asserts a bound provider's language over any `locale` a config carried, so
+   * the host stays the single source of truth even when the two disagree.
+   */
+  assertLanguageAuthority() {
+    if (this.languageProvider) this.adoptProviderLocale();
+  }
+
+  /**
+   * Replaces the whole localization configuration. Anything omitted is cleared,
+   * which is what makes `setCameraLocalization({})` a reset.
+   *
+   * A bound language provider is the one exception: it is only touched when the
+   * config actually carries a `languageProvider` key. Otherwise a screen that
+   * pushes its own bundles would silently switch off auto-sync that was set up at
+   * startup. Pass `languageProvider: null` to detach on purpose.
+   */
+  setLocalization(config = {}) {
+    this.translateFn = config.translate;
+    this.hostTranslations = config.translations;
+    this.bundles = config.bundles ? {
+      ...config.bundles
+    } : {};
+    this.fallbackLocale = normalizeLocale(config.fallbackLocale) || DEFAULT_LOCALE;
+    this.locale = normalizeLocale(config.locale);
+    this.explicitIsRtl = config.isRtl;
+    if ('languageProvider' in config) {
+      this.bindLanguageProvider(config.languageProvider, {
+        resolve: false
+      });
+    }
+    this.assertLanguageAuthority();
+    this.resolve();
+  }
+
+  /**
+   * Merges a partial configuration into the current one. Use this to add bundles
+   * or change the language without re-sending everything else.
+   */
+  updateLocalization(config = {}) {
+    if ('translate' in config) this.translateFn = config.translate;
+    if ('translations' in config) this.hostTranslations = config.translations;
+    if (config.bundles) this.bundles = {
+      ...this.bundles,
+      ...config.bundles
+    };
+    if (config.fallbackLocale !== undefined) {
+      this.fallbackLocale = normalizeLocale(config.fallbackLocale) || DEFAULT_LOCALE;
+    }
+    if (config.locale !== undefined) this.locale = normalizeLocale(config.locale);
+    if ('isRtl' in config) this.explicitIsRtl = config.isRtl;
+    if ('languageProvider' in config) {
+      this.bindLanguageProvider(config.languageProvider, {
+        resolve: false
+      });
+    }
+    this.assertLanguageAuthority();
+    this.resolve();
+  }
+
+  /**
+   * Switches the active language, keeping registered bundles and callbacks.
+   *
+   * Remains available as a manual fallback while a provider is bound; the next
+   * change the provider reports simply wins, since the host owns the language.
+   */
+  setLanguage(locale) {
+    this.locale = normalizeLocale(locale);
+    this.resolve();
+  }
+
+  /**
+   * Rebuilds the resolved translation table and text direction, pushes both to
+   * the native camera, and notifies every subscribed component.
+   *
+   * Priority, lowest to highest: shipped English defaults, locale bundles along
+   * the fallback chain, the host's translate callback, then explicit overrides.
+   */
+  resolve() {
+    this.isRtl = resolveIsRtl(this.explicitIsRtl, this.locale);
+    const bundleTranslations = normalizeTranslations(resolveLocaleTranslations(this.locale, this.bundles, this.fallbackLocale));
+    const generatedTranslations = {};
+    if (this.translateFn) {
+      cameraLocalizationKeys.forEach(key => {
+        try {
+          const translated = this.translateFn?.(key);
+          if (typeof translated === 'string' && translated.length > 0) {
+            generatedTranslations[key] = translated;
+          }
+        } catch {
+          // Translation callbacks are host-owned; missing keys fall back below.
+        }
+      });
+    }
+    this.translations = {
+      ...defaultTranslations,
+      ...bundleTranslations,
+      ...generatedTranslations,
+      ...normalizeTranslations(this.hostTranslations)
+    };
+    try {
+      NativeModules.CustomCamera?.setLocalization?.(this.translations, this.isRtl, this.locale);
+    } catch {
+      // Native localization is best-effort for test, web, and non-Android contexts.
+    }
+    this.notifyListeners();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  getString(key, ...args) {
+    let text;
+    if (this.translateFn) {
+      try {
+        text = this.translateFn(key, ...args);
+      } catch {
+        text = undefined;
+      }
+    }
+    const message = typeof text === 'string' && text.length > 0 ? text : this.translations[key] || defaultTranslations[key] || String(key);
+    return formatMessage(message, args);
+  }
+  getIsRtl() {
+    return this.isRtl;
+  }
+
+  /** The active language, or `''` when the host has not set one. */
+  getLocale() {
+    return this.locale;
+  }
+
+  /** The language used to fill gaps in the active one. `'en'` unless changed. */
+  getFallbackLocale() {
+    return this.fallbackLocale;
+  }
+
+  /** Every locale the host has registered a bundle for. */
+  getAvailableLocales() {
+    return Object.keys(this.bundles);
+  }
+  getTextAlign() {
+    return this.isRtl ? 'right' : 'left';
+  }
+  getFlexDirection() {
+    return this.isRtl ? 'row-reverse' : 'row';
+  }
+  getTranslations() {
+    return this.translations;
+  }
+  notifyListeners() {
+    this.listeners.forEach(listener => listener());
+  }
+}
+export const LocalizationManager = new LocalizationManagerImpl();
+
+/**
+ * Hands the host app's language and translations to the plugin. This is the
+ * single integration point — call it once at startup, and either bind a
+ * `languageProvider` so later switches are picked up automatically or call
+ * {@link setCameraLanguage} on each change.
+ *
+ * ```ts
+ * setCameraLocalization({
+ *   bundles: myBundles,
+ *   // Bound once; every later host language change follows automatically.
+ *   languageProvider: {
+ *     get: () => i18n.language,
+ *     subscribe: (onChange) => {
+ *       i18n.on('languageChanged', onChange);
+ *       return () => i18n.off('languageChanged', onChange);
+ *     },
+ *   },
+ *   translate: (key) => i18n.t(`camera.${key}`),
+ * });
+ * ```
+ *
+ * Every field is optional and omitted fields are cleared, so `{}` restores the
+ * shipped English strings — with one deliberate exception: a language provider
+ * bound by {@link setCameraLanguageProvider} is kept unless the config explicitly
+ * carries `languageProvider`, so automatic synchronization set up once at startup
+ * cannot be switched off by a later config push.
+ */
+export function setCameraLocalization(config = {}) {
+  LocalizationManager.setLocalization(config);
+}
+
+/**
+ * Merges into the current configuration instead of replacing it. Handy for
+ * registering more bundles later, or changing one field on its own.
+ */
+export function updateCameraLocalization(config = {}) {
+  LocalizationManager.updateLocalization(config);
+}
+
+/**
+ * Turns on one-time automatic language synchronization: bind the host app's
+ * language once and every plugin surface follows it from then on.
+ *
+ * On each host language change the plugin re-resolves its translation table,
+ * re-renders every React Native screen and component, and pushes the new
+ * translations, locale, and RTL direction across the bridge to the native Android
+ * camera and editor — no further calls needed.
+ *
+ * Safe to call more than once: the same provider object re-binds without stacking
+ * a listener, a different one releases the previous subscription first, and `null`
+ * detaches (after which {@link setCameraLanguage} is the way to switch).
+ *
+ * ```ts
+ * // i18next
+ * setCameraLanguageProvider({
+ *   get: () => i18n.language,
+ *   subscribe: (onChange) => {
+ *     i18n.on('languageChanged', onChange);
+ *     return () => i18n.off('languageChanged', onChange);
+ *   },
+ * });
+ *
+ * // a plain store / context
+ * setCameraLanguageProvider({
+ *   get: () => store.getState().language,
+ *   subscribe: (onChange) => store.subscribe(onChange),
+ * });
+ * ```
+ */
+export function setCameraLanguageProvider(provider) {
+  LocalizationManager.bindLanguageProvider(provider);
+}
+
+/** Turns automatic synchronization back off. The active language is kept. */
+export function clearCameraLanguageProvider() {
+  LocalizationManager.unbindLanguageProvider();
+}
+
+/**
+ * Re-reads the bound language provider and republishes if it moved. Only needed
+ * for a host whose language can change without notifying — normally the
+ * subscription covers this.
+ */
+export function syncCameraLanguage() {
+  LocalizationManager.syncLanguageFromProvider();
+}
+
+/** The bound language provider, or `undefined` when auto-sync is off. */
+export function getCameraLanguageProvider() {
+  return LocalizationManager.getLanguageProvider();
+}
+
+/**
+ * Switches the plugin to the host's newly selected language — the manual
+ * alternative to {@link setCameraLanguageProvider}, and still supported.
+ *
+ * Registered bundles and the host's translate callback are kept, so this is the
+ * one call to make from a language-change handler. Text direction is re-derived
+ * from the tag, so Arabic and Persian flip the plugin to RTL automatically. Open
+ * plugin screens and the native camera update immediately — no restart.
+ *
+ * ```ts
+ * i18n.on('languageChanged', setCameraLanguage);
+ * ```
+ */
+export function setCameraLanguage(locale) {
+  // Accepting a provider here too means a host that reaches for the familiar
+  // function gets automatic synchronization instead of a mangled language tag.
+  if (isCameraLanguageProvider(locale)) {
+    LocalizationManager.bindLanguageProvider(locale);
+    return;
+  }
+  LocalizationManager.setLanguage(locale);
+}
+
+/** Registers (or replaces) translations for one or more languages. */
+export function registerCameraTranslations(bundles) {
+  LocalizationManager.updateLocalization({
+    bundles
+  });
+}
+
+/** The plugin's active language, or `''` when the host has not set one. */
+export function getCameraLocale() {
+  return LocalizationManager.getLocale();
+}
+
+/** Whether plugin UI is currently laid out right-to-left. */
+export function getCameraIsRtl() {
+  return LocalizationManager.getIsRtl();
+}
+const CameraLocalizationContext = /*#__PURE__*/createContext(null);
+export function CameraLocalizationProvider({
+  children,
+  translate,
+  translations,
+  bundles,
+  fallbackLocale,
+  isRtl,
+  locale,
+  languageProvider,
+  version
+}) {
+  useEffect(() => {
+    setCameraLocalization({
+      // A non-string `locale` is a legacy cache-busting token, not a language tag.
+      locale: typeof locale === 'string' ? locale : undefined,
+      translate,
+      translations,
+      bundles,
+      fallbackLocale,
+      isRtl,
+      // Spread rather than always passing the key: an absent prop must leave a
+      // provider bound elsewhere (at startup) alone, while `null` still detaches.
+      ...(languageProvider === undefined ? null : {
+        languageProvider
+      })
+    });
+  }, [translate, translations, bundles, fallbackLocale, isRtl, locale, languageProvider, version]);
+  const value = useCameraLocalization();
+  return /*#__PURE__*/React.createElement(CameraLocalizationContext.Provider, {
+    value
+  }, children);
+}
+export function useCameraLocalization() {
+  const [revision, setRevision] = useState(0);
+  useEffect(() => {
+    return LocalizationManager.subscribe(() => {
+      setRevision(tick => tick + 1);
+    });
+  }, []);
+  return useMemo(() => {
+    const isRtl = LocalizationManager.getIsRtl();
+    return {
+      t: (key, ...args) => LocalizationManager.getString(key, ...args),
+      /** The host's active language, or `''` when it has not set one. */
+      locale: LocalizationManager.getLocale(),
+      isRtl,
+      direction: isRtl ? 'rtl' : 'ltr',
+      textAlign: LocalizationManager.getTextAlign(),
+      flexDirection: LocalizationManager.getFlexDirection(),
+      rtlStyle: (ltr, rtl) => isRtl ? rtl : ltr,
+      writingDirectionStyle: {
+        writingDirection: isRtl ? 'rtl' : 'ltr',
+        textAlign: isRtl ? 'right' : 'left'
+      },
+      layoutDirectionStyle: {
+        direction: isRtl ? 'rtl' : 'ltr'
+      },
+      /** Row/text styles that follow the active language's direction. */
+      styles: isRtl ? rtlDirectionalStyles.rtl : rtlDirectionalStyles.ltr,
+      translations: LocalizationManager.getTranslations()
+    };
+  }, [revision]);
+}
+export function useCameraLocalizationContext() {
+  const context = useContext(CameraLocalizationContext);
+  const fallback = useCameraLocalization();
+  return context ?? fallback;
+}
+
+/**
+ * Both directions, created up front. `StyleSheet.create` runs once at module
+ * load, so the only way to stay correct across a live language switch is to
+ * build both variants and choose between them at read time.
+ */
+const rtlDirectionalStyles = {
+  ltr: StyleSheet.create({
+    row: {
+      flexDirection: 'row'
+    },
+    text: {
+      writingDirection: 'ltr',
+      textAlign: 'left'
+    }
+  }),
+  rtl: StyleSheet.create({
+    row: {
+      flexDirection: 'row-reverse'
+    },
+    text: {
+      writingDirection: 'rtl',
+      textAlign: 'right'
+    }
+  })
+};
+
+/** Row/text styles for the active language. Prefer the hook inside components. */
+export function getRtlAwareStyles() {
+  return LocalizationManager.getIsRtl() ? rtlDirectionalStyles.rtl : rtlDirectionalStyles.ltr;
+}
+
+/**
+ * Direction-aware styles that re-read the active language on every access.
+ *
+ * Defined with getters rather than a plain object: the language can change at
+ * any time, and a value captured at module load would keep an Arabic UI
+ * left-to-right until the app restarted.
+ */
+export const rtlAwareStyles = {
+  get row() {
+    return getRtlAwareStyles().row;
+  },
+  get text() {
+    return getRtlAwareStyles().text;
+  }
+};
+//# sourceMappingURL=localization.js.map