react-native-ensys-camera-x 1.0.7

package/lib/typescript/src/library/MediaLibrary.d.ts

@@ -0,0 +1,57 @@
+/**
+ * CameraMediaLibrary — the batteries-included media library screen.
+ *
+ * This is the drop-in entry point: ONE element renders the whole shell the
+ * example app renders — the category pills, the swipeable category pager, the
+ * Plus/Cross FAB, the full-screen viewer with its scrubber and counter, the
+ * document/audio preview cards, the record-audio screen, the SQLCipher-backed
+ * library and upload progress:
+ *
+ * ```tsx
+ * export default function App() {
+ *   return (
+ *     <CameraMediaLibrary
+ *       locale={myApp.language}          // any BCP-47 tag the host already uses
+ *       bundles={MY_TRANSLATIONS}        // the host's existing translation data
+ *       uploadUrl="https://api.example.com/upload"
+ *     />
+ *   );
+ * }
+ * ```
+ *
+ * It wraps {@link MediaLibraryScreen} in the plugin's three providers —
+ * `CameraThemeProvider`, `CameraIconProvider`, `CameraLocalizationProvider` —
+ * so a host needs no provider boilerplate of its own. Hosts that already mount
+ * those providers (because they use other plugin surfaces too) should render
+ * `<MediaLibraryScreen />` directly instead and skip the duplication.
+ *
+ * Defaults are the shipped design: omitting `theme` keeps the plugin's palette,
+ * omitting `icons` uses {@link libraryIconRegistry} (the shell's hand-authored
+ * outline set), and omitting `locale`/`bundles` renders English.
+ *
+ * The props are an alternative to `configureCameraPlugin`, not an addition to
+ * it. Configure language and icons through either one — a bare
+ * `<CameraMediaLibrary />` inherits whatever `configureCameraPlugin` set, and
+ * localization props passed here take over from it (they replace the plugin's
+ * localization config rather than merging into it).
+ */
+import { type FC } from 'react';
+import { type CameraLocalizationProviderProps } from '../localization';
+import { type CameraIconRegistryConfig } from '../icons';
+import type { CameraThemeInput } from '../types';
+import { type MediaLibraryScreenProps } from './MediaLibraryScreen';
+export interface CameraMediaLibraryProps extends MediaLibraryScreenProps, Omit<CameraLocalizationProviderProps, 'children'> {
+    /**
+     * Colors/sizing for the plugin — the native camera screens AND this shell's
+     * plugin-linked palette tokens. Omit to keep the shipped look.
+     */
+    theme?: CameraThemeInput;
+    /**
+     * Icon overrides. The shell's own outline set is the base registry, so
+     * `{ overrides: { camera: { component: MyCameraIcon } } }` replaces one icon
+     * and leaves the rest alone. Passing `{ registry }` replaces the set wholesale.
+     */
+    icons?: CameraIconRegistryConfig;
+}
+export declare const CameraMediaLibrary: FC<CameraMediaLibraryProps>;
+//# sourceMappingURL=MediaLibrary.d.ts.map

package/lib/typescript/src/library/MediaLibrary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaLibrary.d.ts","sourceRoot":"","sources":["../../../../src/library/MediaLibrary.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAW,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,EAEL,KAAK,+BAA+B,EACrC,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAsB,KAAK,wBAAwB,EAAE,MAAM,UAAU,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,uBACf,SAAQ,uBAAuB,EAC7B,IAAI,CAAC,+BAA+B,EAAE,UAAU,CAAC;IACnD;;;OAGG;IACH,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB;;;;OAIG;IACH,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC;AAED,eAAO,MAAM,kBAAkB,EAAE,EAAE,CAAC,uBAAuB,CAuE1D,CAAC"}

package/lib/typescript/src/library/MediaLibraryScreen.d.ts

@@ -0,0 +1,51 @@
+import { type StyleProp, type ViewStyle } from 'react-native';
+import type { CameraAsset } from '../types';
+declare const FILTER_KEYS: readonly ["all", "photos", "videos", "documents", "audio"];
+/**
+ * One of the five library categories, in tab order. Exported from the package
+ * as `MediaLibraryFilterKey` — the type of the `initialFilter` prop.
+ */
+export type FilterKey = (typeof FILTER_KEYS)[number];
+/** Props for {@link MediaLibraryScreen}. */
+export interface MediaLibraryScreenProps {
+    /**
+     * Where confirmed media is POSTed by the native foreground UploadService —
+     * this is what drives the upload progress / completed / failed notifications
+     * in the system notification bar.
+     *
+     * OMIT IT and nothing is uploaded: every other behaviour (capture, edit, send,
+     * SQLCipher persistence, the list refresh) is byte-for-byte identical. Set it
+     * to your own endpoint to switch uploads on.
+     */
+    uploadUrl?: string;
+    /** Category tab selected on first mount. Defaults to `'all'`. */
+    initialFilter?: FilterKey;
+    /**
+     * Called with the full asset list whenever the encrypted store changes
+     * (capture, gallery pick, delete). Useful for a badge count or an outer
+     * screen that mirrors the library.
+     */
+    onAssetsChange?: (assets: CameraAsset[]) => void;
+    /** Extra style for the screen's root container. */
+    style?: StyleProp<ViewStyle>;
+}
+/**
+ * The media library screen: the category tabs + swipeable category pager, the
+ * Plus/Cross FAB that opens the camera / gallery editor / document + audio
+ * pickers / audio recorder, the full-screen swipeable viewer (image, video with
+ * scrubber, document and audio preview cards) with its position counter and
+ * details sheet, and the mini audio player.
+ *
+ * It reads its entire dataset from the encrypted SQLCipher store, so it needs
+ * the `react-native-sqlcipher` peer dependency installed.
+ *
+ * Providers above it are optional: the theme, icon and localization hooks all
+ * fall back to the process-wide configuration (`configureCameraPlugin`,
+ * `setCameraIcons`, `setCameraLocalization`), so this renders correctly on its
+ * own. What it does NOT do by itself is install the shell's hand-authored
+ * outline icon set — {@link CameraMediaLibrary} adds that (plus the three
+ * providers) on top, which is why the drop-in is the recommended entry point.
+ */
+export declare function MediaLibraryScreen({ uploadUrl, initialFilter, onAssetsChange, style, }?: MediaLibraryScreenProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=MediaLibraryScreen.d.ts.map

package/lib/typescript/src/library/MediaLibraryScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaLibraryScreen.d.ts","sourceRoot":"","sources":["../../../../src/library/MediaLibraryScreen.tsx"],"names":[],"mappings":"AASA,OAAO,EAeL,KAAK,SAAS,EACd,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,UAAU,CAAC;AAwF3D,QAAA,MAAM,WAAW,4DAA6D,CAAC;AAC/E;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AA2frD,4CAA4C;AAC5C,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,aAAa,CAAC,EAAE,SAAS,CAAC;IAC1B;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,IAAI,CAAC;IACjD,mDAAmD;IACnD,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,SAAS,EACT,aAAqB,EACrB,cAAc,EACd,KAAK,GACN,GAAE,uBAA4B,+BAupD9B"}

package/lib/typescript/src/library/components/AudioPreview.d.ts

@@ -0,0 +1,6 @@
+import type { CameraAsset } from '../../types';
+export declare const AudioPreview: ({ asset, active, }: {
+    asset: CameraAsset;
+    active: boolean;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=AudioPreview.d.ts.map

package/lib/typescript/src/library/components/AudioPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AudioPreview.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/AudioPreview.tsx"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS/C,eAAO,MAAM,YAAY,GAAI,oBAG1B;IACD,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB,gCAsBA,CAAC"}

package/lib/typescript/src/library/components/DocumentPreview.d.ts

@@ -0,0 +1,10 @@
+import type { CameraAsset } from '../../types';
+export declare const DocumentPreview: ({ asset, active, }: {
+    asset: CameraAsset;
+    /**
+     * False while this document's page is off-screen in the paging viewer — pauses expensive
+     * native work (PDF page rasterization), mirroring the audio/video cells' `active` gate.
+     */
+    active?: boolean;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=DocumentPreview.d.ts.map

package/lib/typescript/src/library/components/DocumentPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentPreview.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/DocumentPreview.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAkE/C,eAAO,MAAM,eAAe,GAAI,oBAG7B;IACD,KAAK,EAAE,WAAW,CAAC;IACnB;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,gCA4IA,CAAC"}

package/lib/typescript/src/library/components/ExpandableFab.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ExpandableFab — a bottom-right Floating Action Button that expands into a stack of labelled
+ * action rows (Camera / Document / Audio).
+ *
+ * Constraints honoured:
+ *  • All icons are hand-authored from RN primitives (see ../icons/CustomIcons) — no icon library,
+ *    no react-native-svg, no external assets.
+ *  • All motion uses ONLY React Native's built-in Animated API (no reanimated / animatable / moti /
+ *    lottie). A single Animated.Value drives everything, so there is one source of truth and the
+ *    expand/collapse reverse is exact.
+ *  • Transforms + opacity run on the native driver, so it stays smooth on low-end devices.
+ *
+ * State model: `open` (React state) is the source of truth; an effect animates `progress` toward
+ * it. Rapid taps just flip `open`; Animated.timing redirects from the current value, so there are
+ * no glitches or half-open states. The menu auto-collapses when an action is picked, when the
+ * backdrop is tapped, and whenever the FAB is disabled (e.g. a capture is in flight).
+ */
+import { type FC } from 'react';
+import { type ColorValue } from 'react-native';
+export interface ExpandableFabProps {
+    onCamera: () => void;
+    /**
+     * Opens the device gallery for an existing image or video, then hands the pick to the same
+     * preview/editor screen a capture opens on (image editor for a photo, video editor for a clip).
+     */
+    onImageVideo: () => void;
+    onDocument: () => void;
+    onAudio: () => void;
+    onRecordAudio: () => void;
+    /** Shows a spinner on the FAB and disables interaction (e.g. while capturing). */
+    busy?: boolean;
+    disabled?: boolean;
+    /** Distance from the right/bottom screen edges — defaults match the app's original FAB. */
+    right?: number;
+    bottom?: number;
+    accentColor?: ColorValue;
+}
+export declare const ExpandableFab: FC<ExpandableFabProps>;
+//# sourceMappingURL=ExpandableFab.d.ts.map

package/lib/typescript/src/library/components/ExpandableFab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpandableFab.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/ExpandableFab.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,EAAqD,KAAK,EAAE,EAAE,MAAM,OAAO,CAAC;AACnF,OAAO,EASL,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AAkBtB,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB;;;OAGG;IACH,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,kFAAkF;IAClF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2FAA2F;IAC3F,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,UAAU,CAAC;CAC1B;AAOD,eAAO,MAAM,aAAa,EAAE,EAAE,CAAC,kBAAkB,CA2LhD,CAAC"}

package/lib/typescript/src/library/components/FileTiles.d.ts

@@ -0,0 +1,8 @@
+import type { CameraAsset } from '../../types';
+export declare const DocumentTile: ({ asset }: {
+    asset: CameraAsset;
+}) => import("react").JSX.Element;
+export declare const AudioTile: ({ asset }: {
+    asset: CameraAsset;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=FileTiles.d.ts.map

package/lib/typescript/src/library/components/FileTiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileTiles.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/FileTiles.tsx"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAoI/C,eAAO,MAAM,YAAY,GAAI,WAAW;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,gCA6B7D,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,WAAW;IAAE,KAAK,EAAE,WAAW,CAAA;CAAE,gCA4B1D,CAAC"}

package/lib/typescript/src/library/components/ImagePreview.d.ts

@@ -0,0 +1,5 @@
+import type { CameraAsset } from '../../types';
+export declare const ImagePreview: ({ asset, }: {
+    asset: CameraAsset;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=ImagePreview.d.ts.map

package/lib/typescript/src/library/components/ImagePreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImagePreview.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/ImagePreview.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,eAAO,MAAM,YAAY,GAAI,YAE1B;IACD,KAAK,EAAE,WAAW,CAAC;CACpB,gCA+BA,CAAC"}

package/lib/typescript/src/library/components/MediaMetadataHeader.d.ts

@@ -0,0 +1,16 @@
+import type { CameraAsset } from '../../types';
+export interface MediaMetadataHeaderProps {
+    asset: CameraAsset;
+    /** Append `width × height` — images only, and only when both are known. */
+    showDimensions?: boolean;
+    /** Append the clip length — videos and audio. */
+    showDuration?: boolean;
+    /** Meta chunk rendered before the size (the document strip's page count). */
+    leadingMeta?: string | null;
+    /** Include the capture date and time chunks. @default true */
+    showDateTime?: boolean;
+    /** Shown when the asset carries no usable file name at all. @default 'Media' */
+    fallbackName?: string;
+}
+export declare const MediaMetadataHeader: ({ asset, showDimensions, showDuration, leadingMeta, showDateTime, fallbackName, }: MediaMetadataHeaderProps) => import("react").JSX.Element;
+//# sourceMappingURL=MediaMetadataHeader.d.ts.map

package/lib/typescript/src/library/components/MediaMetadataHeader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MediaMetadataHeader.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/MediaMetadataHeader.tsx"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAc/C,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,WAAW,CAAC;IACnB,2EAA2E;IAC3E,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,iDAAiD;IACjD,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,6EAA6E;IAC7E,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,8DAA8D;IAC9D,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gFAAgF;IAChF,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAqDD,eAAO,MAAM,mBAAmB,GAAI,mFAOjC,wBAAwB,gCA+D1B,CAAC"}

package/lib/typescript/src/library/components/RecordAudioScreen.d.ts

@@ -0,0 +1,8 @@
+import type { CameraAsset } from '../../types';
+export interface RecordAudioScreenProps {
+    visible: boolean;
+    onClose: () => void;
+    onRecorded: (asset: CameraAsset) => void;
+}
+export declare const RecordAudioScreen: ({ visible, onClose, onRecorded, }: RecordAudioScreenProps) => import("react").JSX.Element;
+//# sourceMappingURL=RecordAudioScreen.d.ts.map

package/lib/typescript/src/library/components/RecordAudioScreen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordAudioScreen.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/RecordAudioScreen.tsx"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAW/C,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,UAAU,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC1C;AAeD,eAAO,MAAM,iBAAiB,GAAI,mCAI/B,sBAAsB,gCAojBxB,CAAC"}

package/lib/typescript/src/library/components/VideoPreview.d.ts

@@ -0,0 +1,20 @@
+import type { CameraAsset } from '../../types';
+export interface VideoPreviewProps {
+    asset: CameraAsset;
+    paused: boolean;
+    onTogglePause: () => void;
+    onPlaybackEnded?: () => void;
+    active: boolean;
+    controlsVisible: boolean;
+    /**
+     * Fired ONLY when the video playback area itself is tapped. The host toggles the three transport
+     * controls: a tap reveals them, and a tap while they are showing hides them again. There is no
+     * auto-hide timer — once shown the controls stay until the video is tapped again. Deliberately
+     * scoped to the video surface: the X/close, counter, Share/Delete/Info and surrounding chrome are
+     * OUTSIDE this handler and never affect (or trigger) control visibility.
+     */
+    onVideoAreaPress: () => void;
+    onControlInteraction: () => void;
+}
+export declare const VideoPreview: ({ asset, paused, onTogglePause, onPlaybackEnded, active, controlsVisible, onVideoAreaPress, onControlInteraction, }: VideoPreviewProps) => import("react").JSX.Element;
+//# sourceMappingURL=VideoPreview.d.ts.map

package/lib/typescript/src/library/components/VideoPreview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoPreview.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/VideoPreview.tsx"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA6B/C,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,WAAW,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,IAAI,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,eAAe,EAAE,OAAO,CAAC;IACzB;;;;;;OAMG;IACH,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,oBAAoB,EAAE,MAAM,IAAI,CAAC;CAClC;AAED,eAAO,MAAM,YAAY,GAAI,qHAS1B,iBAAiB,gCAqRnB,CAAC"}

package/lib/typescript/src/library/components/ViewerCounter.d.ts

@@ -0,0 +1,13 @@
+import { type StyleProp, type TextStyle } from 'react-native';
+export interface ViewerCounterHandle {
+    /** Show `index` (0-based) immediately. Ignored when it doesn't change the rendered text. */
+    setIndex: (index: number) => void;
+}
+export interface ViewerCounterProps {
+    /** Settled 0-based position — re-syncs the counter when the parent moves it. */
+    index: number;
+    total: number;
+    style?: StyleProp<TextStyle>;
+}
+export declare const ViewerCounter: import("react").ForwardRefExoticComponent<ViewerCounterProps & import("react").RefAttributes<ViewerCounterHandle>>;
+//# sourceMappingURL=ViewerCounter.d.ts.map

package/lib/typescript/src/library/components/ViewerCounter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewerCounter.d.ts","sourceRoot":"","sources":["../../../../../src/library/components/ViewerCounter.tsx"],"names":[],"mappings":"AAcA,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAIpE,MAAM,WAAW,mBAAmB;IAClC,4FAA4F;IAC5F,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,kBAAkB;IACjC,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B;AAED,eAAO,MAAM,aAAa,oHAsCzB,CAAC"}

package/lib/typescript/src/library/compressionEstimate.d.ts

@@ -0,0 +1,313 @@
+import type { CameraTranslationFunction } from '../localization';
+/** MB of SOURCE video demuxed + decoded + re-encoded per second. */
+export declare const COMPRESSION_SOURCE_MB_PER_SECOND = 1;
+/** Megapixels of decoded frame data processed per second (≈ 2 s per second of 1080p). */
+export declare const COMPRESSION_MEGAPIXELS_PER_SECOND = 4;
+/**
+ * Deprecated per-level discount, kept at 1 (no discount).
+ *
+ * They used to model the native transcoder downscaling the frame once the quality ratio dropped
+ * under 0.6, which made a heavy level a cheaper pass. That downscale is gone — every level now
+ * re-encodes at FULL resolution so quality is protected rather than traded away
+ * (`MediaPreviewEditor.estimateCompressionSeconds` dropped its matching discount for the same
+ * reason) — so the pass costs the same at 5% as at 95% and the factor must not shorten the seed.
+ * Left in place, and exported, because they are part of this module's public surface.
+ */
+export declare const COMPRESSION_DOWNSCALE_QUALITY_CEILING = 60;
+export declare const COMPRESSION_DOWNSCALED_LEVEL_FACTOR = 1;
+/**
+ * Floor: below this there is no countdown worth showing, and it doubles as the allowance for the
+ * fixed codec + muxer setup that no amount of video changes.
+ */
+export declare const MIN_COMPRESSION_COUNTDOWN_SECONDS = 2;
+/** Ceiling: a very long clip shows a bounded number and finishes in "Finalizing..." if need be. */
+export declare const MAX_COMPRESSION_COUNTDOWN_SECONDS = 180;
+/**
+ * Megapixels of STILL image compressed per second, behind {@link estimateImageCompressionSeconds}.
+ *
+ * Much lower than a plain "encode one JPEG" rate because a still compression is not one encode:
+ * the native compressor decodes once and then re-encodes several times while it searches for the
+ * quality that hits the requested size.
+ */
+export declare const IMAGE_COMPRESSION_MEGAPIXELS_PER_SECOND = 3;
+/** Ceiling for a still: even a 100 MP source is bounded well below the video ceiling. */
+export declare const MAX_IMAGE_COMPRESSION_COUNTDOWN_SECONDS = 30;
+/** Caption shown once there is no measurable remaining time left to quote. */
+export declare const COMPRESSION_FINALIZING_LABEL = "Finalizing...";
+/** Caption shown when there is no countdown to display (estimate unavailable). */
+export declare const COMPRESSION_FALLBACK_LABEL = "Compressing...";
+/**
+ * The quality percentage a dropdown option asks to KEEP (5..99), or 0 for anything that is not a
+ * level (the "Original Video" / "Original Image" entries, which never start a compression).
+ */
+export declare const parseCompressionPercent: (option: string) => number;
+export interface VideoCompressionEstimateInput {
+    /** Size of the ORIGINAL file in bytes (never a previously compressed copy's). */
+    sizeBytes?: number;
+    /** Duration of the original, in milliseconds (seconds are accepted and normalised). */
+    duration?: number;
+    /** The original's own pixel dimensions. */
+    width?: number;
+    height?: number;
+    /** The selected level: the percentage of the original QUALITY to keep (5..99). Lower = stronger. */
+    percent: number;
+}
+/**
+ * How long compressing a clip is expected to take, in whole seconds — the value the countdown
+ * starts at, and only that: measured progress takes the figure over within the first second or so
+ * (see {@link foldCompressionProgress}).
+ *
+ * Two independent predictors are computed and the LARGER is taken, because either one alone is
+ * wrong for a whole class of clip:
+ *
+ *  - **Bytes.** The whole file is demuxed, decoded and re-encoded, so throughput measured in MB of
+ *    SOURCE per second is the most stable single predictor across devices. On its own it
+ *    under-predicts a long, low-bitrate clip (lots of frames, few bytes).
+ *  - **Pixels × frames.** Duration times megapixels per frame is what the codec actually has to
+ *    work on. On its own it under-predicts a short, very high-bitrate clip (few frames, huge
+ *    bytes).
+ *
+ * Every input must come from the ORIGINAL, so picking a second level after a first estimates
+ * against the untouched file rather than the shrunken copy. A clip with no readable metadata at
+ * all falls back to the floor rather than to zero.
+ */
+export declare const estimateVideoCompressionSeconds: ({ sizeBytes, duration, width, height, percent, }: VideoCompressionEstimateInput) => number;
+export interface ImageCompressionEstimateInput {
+    /** The ORIGINAL still's own pixel dimensions. */
+    width?: number;
+    height?: number;
+}
+/**
+ * How long compressing a still is expected to take, in whole seconds — the seed for its countdown.
+ *
+ * A single predictor, unlike the video estimate's two: a still has no duration and no bit rate, so
+ * the only thing that varies is how many pixels there are to decode and re-encode. The requested
+ * level does not enter into it either — the native compressor searches for the quality that hits
+ * the target, so a light level costs the same handful of encodes as a heavy one.
+ *
+ * A still with no readable dimensions falls back to the floor rather than to zero.
+ */
+export declare const estimateImageCompressionSeconds: ({ width, height, }: ImageCompressionEstimateInput) => number;
+/** The countdown's text for a given number of seconds remaining, e.g. `Compressing (5s left)`. */
+export declare const formatCompressionCountdown: (secondsLeft: number, t?: CameraTranslationFunction) => string;
+/**
+ * Below this fraction, `elapsed / fraction` is dominated by fixed setup cost (codec configuration,
+ * the first decode) and would predict a wildly pessimistic total. Under it the prediction is
+ * blended with the up-front estimate in proportion to how far along it is, so the number is steady
+ * at the start and fully measurement-driven from here on.
+ */
+export declare const MIN_TRUSTED_COMPRESSION_PROGRESS = 0.08;
+/**
+ * At or above this the encoder has finished its frames and the pass is in its tail — flushing,
+ * muxing, reading the output back — real work with no measurable length, which the line reports as
+ * "Finalizing..." rather than quoting seconds it cannot justify.
+ */
+export declare const COMPRESSION_FINALIZING_PROGRESS = 0.985;
+/**
+ * Weight given to a freshly derived total when smoothing. Low enough that a burst of
+ * cheap-to-encode frames cannot make the figure jump, high enough that a genuinely slower job has
+ * the number corrected within a few seconds.
+ */
+export declare const COMPRESSION_PREDICTION_SMOOTHING = 0.4;
+/** How often the screen should re-read the line. Twice a second; the read is one subtraction. */
+export declare const COMPRESSION_COUNTDOWN_TICK_MS = 500;
+/**
+ * One step of the opening ramp: how long each number stays on screen while the total is being
+ * worked out. About three numbers a second — slow enough to read every one of them, quick enough
+ * that the ramp is over in a moment.
+ */
+export declare const COMPRESSION_CALCULATION_STEP_MS = 300;
+/**
+ * The most steps the ramp may take, which is what bounds it in wall-clock time
+ * (`COMPRESSION_CALCULATION_STEP_MS` × this ≈ 3 s). A long job strides in larger increments rather
+ * than taking longer to count up — the ramp must never become the wait it is describing.
+ */
+export declare const COMPRESSION_CALCULATION_MAX_STEPS = 10;
+/**
+ * And it may never spend more than this share of the predicted job counting up either, so a job
+ * that is over in two seconds does not spend most of it ramping.
+ */
+export declare const COMPRESSION_CALCULATION_MAX_ELAPSED_FRACTION = 0.4;
+export interface CompressionProgressTracker {
+    /** `Date.now()` when the compression started. */
+    readonly startedAtMs: number;
+    /** The up-front estimate in seconds, which seeds — and early on partly carries — the total. */
+    readonly estimateSeconds: number;
+    /**
+     * The largest fraction the compressor has reported, or 0 while it has reported nothing at all.
+     * 0 is a real state, not just an initial one: a source with no readable duration reports nothing,
+     * and then the estimate is all there is.
+     */
+    readonly progress: number;
+    /** How long the whole compression is now expected to take, in seconds from its start. */
+    readonly predictedTotalSeconds: number;
+    /**
+     * Seconds the opening ramp adds per step. 1 for anything the ramp can count up to one second at
+     * a time within its step budget, larger for a job long enough that it has to stride.
+     */
+    readonly calculationStepSeconds: number;
+    /**
+     * Where the ramp stops climbing no matter what: the first multiple of
+     * [calculationStepSeconds] at or above the up-front estimate. Normally the ramp ends before this
+     * by meeting the real remaining time; this is the backstop for a prediction that runs away
+     * upward while the ramp is still climbing.
+     */
+    readonly calculationCeilingSeconds: number;
+}
+/** A tracker for a compression starting now, seeded by its up-front [estimateSeconds]. */
+export declare const createCompressionProgressTracker: (estimateSeconds: number, nowMs: number) => CompressionProgressTracker;
+/**
+ * Fold one measured progress report (0..1) into [tracker], re-deriving how long the whole
+ * compression will take from how long it has taken to get this far.
+ *
+ * `total = elapsed / fraction` is the entire idea: it is why the displayed figure can stretch as
+ * well as shrink, and therefore why it neither hits zero mid-compression nor lingers after the
+ * work is done. Out-of-order or repeated reports cannot walk the fraction backwards.
+ *
+ * Reports during the opening ramp are folded in exactly like any other: the ramp is a DISPLAY
+ * concern only, so nothing here has to be held back or paused for it. That is what makes the
+ * hand-over accurate — by the time the ramp meets the countdown, the figure it meets has already
+ * had every report so far folded into it.
+ */
+export declare const foldCompressionProgress: (tracker: CompressionProgressTracker, progress: number, nowMs: number) => CompressionProgressTracker;
+/**
+ * The figure the opening ramp is showing right now, or `null` once it is over and the countdown
+ * proper owns the line.
+ *
+ * The ramp ends the moment its climbing figure REACHES the real remaining time, which is what
+ * makes the hand-over seamless: the last number it shows and the first number the countdown shows
+ * are the same one, arrived at from below. (`remaining` is falling in real time while the ramp
+ * climbs, so the two always meet — the ceiling is only a backstop for a prediction re-derived
+ * upward faster than the ramp can climb.)
+ */
+export declare const compressionCalculationSeconds: (tracker: CompressionProgressTracker, nowMs: number) => number | null;
+/**
+ * How long the screen should wait before re-reading the line.
+ *
+ * While the ramp is climbing this is the time to its NEXT step, so every number it shows gets the
+ * same {@link COMPRESSION_CALCULATION_STEP_MS} on screen — an even cadence rather than one
+ * quantised to a tick that does not divide it. Afterwards it is the ordinary countdown tick.
+ */
+export declare const compressionCountdownTickMs: (tracker: CompressionProgressTracker | null, nowMs: number) => number;
+/**
+ * What the overlay's line should read right now.
+ *
+ * Four cases, in order:
+ *
+ *  1. **The encoder is done and the pass is in its tail** (progress at or above
+ *     {@link COMPRESSION_FINALIZING_PROGRESS}) — "Finalizing...", because flushing and muxing are
+ *     real work of unmeasurable length.
+ *  2. **The opening ramp is still climbing** — its figure, one readable step at a time, until it
+ *     meets the real remaining time (see {@link compressionCalculationSeconds}).
+ *  3. **The prediction is spent and nothing was ever measured** — "Finalizing..." as well: a
+ *     compressor that reports no progress leaves only the estimate, and counting through zero into
+ *     negative numbers would misrepresent what is happening.
+ *  4. **Otherwise** — `predicted total - elapsed`, floored at one second. The floor is reached only
+ *     within about a second of the end (it takes progress above `elapsed / (elapsed + 1)`), and
+ *     case 1 takes over from there.
+ */
+export declare const compressionCountdownLabel: (tracker: CompressionProgressTracker | null, nowMs: number, t?: CameraTranslationFunction) => string;
+/**
+ * The QUALITY levels the sheet offers, highest quality first — the percentage of the original to
+ * KEEP, which is exactly what the bridge takes (`compressVideo(uri, '45%')`). So the number a row
+ * displays is the number handed to the encoder: no inversion anywhere between the two.
+ *
+ * The native editor's ladder is the same rungs expressed the other way round (percent to SHAVE), so
+ * `95%` quality here is its `5% smaller` row and `5%` quality here is its `95% smaller` row.
+ */
+export declare const COMPRESSION_QUALITY_LEVELS: readonly number[];
+/**
+ * How far under its ceiling a compression routinely lands, which is the bottom of every quoted band
+ * — for stills because the encoder's size search stops at the highest quality at or under the
+ * target (quality quantisation, a profile pre-cap, a fallback when the target is out of reach), and
+ * for clips because the same fraction is used so a video band and an image band open by the same
+ * amount. Shared verbatim with `ImageExporter.ESTIMATE_SIZE_UNDERSHOOT`.
+ */
+export declare const ESTIMATE_SIZE_UNDERSHOOT = 0.85;
+/**
+ * The quality floor, mirrored from `VideoRotationTranscoder.MIN_BITS_PER_PIXEL_AVC` — the fewest
+ * bits per pixel per frame the native encoder will spend on a full-size frame, however heavy the
+ * level asked for. Kotlin is the source of truth for the value; this copy exists so the sheet does
+ * not quote a size the pipeline deliberately refuses to produce.
+ *
+ * AVC's figure rather than HEVC's on purpose: it is the HIGHER of the two, and the shell cannot know
+ * which codec the device will pick, so assuming AVC keeps every quoted row at or above what will
+ * actually be written. A row that promises slightly less reduction than it delivers is a pleasant
+ * surprise; the other way round is a broken promise.
+ */
+export declare const MIN_BITS_PER_PIXEL_AVC = 0.065;
+/**
+ * How far the floor may push into the clip's own rate, mirroring
+ * `VideoRotationTranscoder.MAX_FLOOR_SOURCE_SHARE`. A clip that already sits below the floor is
+ * honestly cheap rather than under-encoded, so the floor gives way to half its own average rate:
+ * every clip can always be made about twice as small, and past that the picture is protected.
+ */
+export declare const MAX_FLOOR_SOURCE_SHARE = 0.5;
+/**
+ * Frames per second assumed when quoting the floor. The shell has no access to a clip's real frame
+ * rate (nothing on a `CameraAsset` carries it), and 30 is both the overwhelmingly common capture
+ * rate and native's own fallback (`VideoRotationTranscoder.DEFAULT_FRAME_RATE`).
+ */
+export declare const ASSUMED_VIDEO_FRAME_RATE = 30;
+/** The clip facts the quality floor is measured from. All optional: missing any of them drops it. */
+export interface CompressedSizeFrame {
+    /** The clip's pixel dimensions. Orientation does not matter — only the pixel COUNT is used. */
+    readonly width?: number;
+    readonly height?: number;
+    /** Duration in milliseconds (seconds are accepted and normalised). */
+    readonly duration?: number;
+}
+/** A quoted output-size band: [low]..[high], the pair a level row shows as "1.8 – 2.1 MB". */
+export interface CompressedSizeBand {
+    readonly low: number;
+    readonly high: number;
+}
+/**
+ * The CEILING a compression at [qualityPercent] is aiming at: [originalBytes] with the shaved share
+ * removed. The single figure a compressed clip is quoted at afterwards, and the top of the band a
+ * row promises beforehand.
+ *
+ * `shave = 100 - qualityPercent`, pinned to the same range the encoder pins it to — 1..99 for a
+ * clip, 1..95 for a still (`ImageExporter.compress`'s own clamp) — and the arithmetic is integer
+ * truncating, exactly as native's is, so the two agree to the byte.
+ *
+ * For a CLIP the result is then raised to the quality floor when [frame] describes the video well
+ * enough to measure one (see {@link qualityFloorBytes}): the native encoder will not take a
+ * full-size frame below that rate, so the heavy rungs all land on the same size and a row that went
+ * on quoting `1% of the original` would be promising a file that is never written. Omit [frame] and
+ * the figure stays purely proportional, as it was before the floor existed.
+ */
+export declare const compressedCeilingBytes: (originalBytes: number, qualityPercent: number, kind: "video" | "image", frame?: CompressedSizeFrame) => number;
+/**
+ * The band of output sizes a compression at [qualityPercent] is expected to land in, or null when
+ * [originalBytes] is unknown — which drops the size from the row rather than inventing one.
+ *
+ * The top is {@link compressedCeilingBytes}; the bottom is that ceiling scaled by
+ * {@link ESTIMATE_SIZE_UNDERSHOOT}. Both media kinds share the shape deliberately: a still's band is
+ * the encoder's own target arithmetic, and a clip's is the display convention the native menu uses
+ * so a video row and an image row read alike at every rung. [frame] is the clip's own geometry and
+ * duration, which is what lets a video band respect the encoder's quality floor.
+ */
+export declare const compressedSizeBand: (originalBytes: number, qualityPercent: number, kind: "video" | "image", frame?: CompressedSizeFrame) => CompressedSizeBand | null;
+/**
+ * The option string the bridge is called with for a quality level — the level itself, as a
+ * percentage. `compressVideo(uri, '45%')` keeps 45% of the quality.
+ */
+export declare const compressionOptionForQuality: (qualityPercent: number) => string;
+/**
+ * The sentinel option for "leave it alone". Native resolves any option starting with `Original`
+ * straight back to the input URI (quality ratio 1.0), and {@link parseCompressionPercent} reads it
+ * as 0, so it never starts a compression on either side. Never displayed — the row's label comes
+ * from the localized `originalVideo` / `originalImage` keys.
+ */
+export declare const originalCompressionOption: (kind: "video" | "image") => string;
+/** True for the {@link originalCompressionOption} sentinels — the rows that compress nothing. */
+export declare const isOriginalCompressionOption: (option: string) => boolean;
+/**
+ * How much smaller a finished compression came out, as a whole percentage of the original — the
+ * `{1}` of the `compressedToSize` line. Returns null when there is nothing honest to claim (either
+ * size unknown, or an output that did not actually shrink), and the caller falls back to
+ * `compressedToSizeOnly`.
+ */
+export declare const compressionSavingPercent: (originalBytes: number, compressedBytes: number) => number | null;
+//# sourceMappingURL=compressionEstimate.d.ts.map

package/lib/typescript/src/library/compressionEstimate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressionEstimate.d.ts","sourceRoot":"","sources":["../../../../src/library/compressionEstimate.ts"],"names":[],"mappings":"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"}