react-native-ensys-camera-x 1.0.7

package/lib/module/nativeActions.js

@@ -0,0 +1,307 @@
+"use strict";
+
+/**
+ * nativeActions — the TurboModule bridge calls that plugin UI needs, in a module
+ * that plugin UI can safely import.
+ *
+ * `src/index.tsx` is the package barrel: it re-exports every module in the
+ * library. Anything under `src/library/` that imported it to reach a bridge call
+ * would create a require cycle (barrel → screen → barrel), and in Metro that
+ * resolves to a half-initialised module object at import time — the classic
+ * "undefined is not a function" on first render.
+ *
+ * So the wrappers live HERE, and both sides import this file:
+ *   • `src/index.tsx` re-exports them, keeping the public API byte-identical.
+ *   • `src/library/**` imports them directly, never through `../index`.
+ *
+ * Every function is a thin pass-through to the native module. The one exception
+ * is {@link openGalleryEditor}, which composes two calls; its helpers live here
+ * with it rather than being reached back through the barrel.
+ */
+import { DeviceEventEmitter } from 'react-native';
+/**
+ * The native TurboModule, or a safe empty stand-in.
+ *
+ * Resolved lazily through `require` (not a static import) so that importing any
+ * part of this package in a plain Node/Jest environment — where the native
+ * module is absent — does not throw at module-evaluation time. Calls made
+ * against the stand-in fail individually instead of taking the whole bundle
+ * down at import.
+ */
+export function getCustomCameraModule() {
+  try {
+    const module = require('./NativeCustomCamera');
+    if (module) {
+      return module.default ?? module;
+    }
+  } catch {
+    // Fall back to a safe empty object for non-native test environments.
+  }
+  return {};
+}
+export function openCameraPicker(options = {}) {
+  return getCustomCameraModule().openCameraPicker(options);
+}
+
+/**
+ * Open the native document picker (Android Storage Access Framework). Resolves with the same
+ * `{ cancelled, assets }` shape as {@link openCameraPicker}; each asset has `type: 'document'`.
+ */
+export function openDocumentPicker(options = {}) {
+  return getCustomCameraModule().openDocumentPicker(options);
+}
+
+/**
+ * Open the native audio picker (Android Storage Access Framework, scoped to `audio/*`). Resolves
+ * with the same `{ cancelled, assets }` shape as {@link openCameraPicker}; each asset has
+ * `type: 'audio'`.
+ */
+export function openAudioPicker(options = {}) {
+  return getCustomCameraModule().openAudioPicker(options);
+}
+
+/**
+ * Open the native image/video picker (Android Storage Access Framework, scoped to `image/*` and
+ * `video/*`). Resolves with the same `{ cancelled, assets }` shape as {@link openCameraPicker};
+ * each asset has `type: 'photo'` or `type: 'video'` depending on the MIME type.
+ */
+export function openImageVideoPicker(options = {}) {
+  return getCustomCameraModule().openImageVideoPicker(options);
+}
+
+/**
+ * Open EXISTING photos/videos on the camera's own preview/editor screens.
+ *
+ * This is not a second editor: it is the same native Activity, the same preview/editor controller
+ * and the same tool set freshly captured media opens on — crop, rotate, draw, text, stickers,
+ * emoji, filters, export/compress for images; trim, mute, cover frame, compress for videos — and it
+ * finishes through the same send pipeline (cache → edit → publish to Documents). The result
+ * therefore has the identical `{ cancelled, assets }` shape as {@link openCameraPicker}, and the
+ * assets it returns are indistinguishable from captured ones downstream.
+ *
+ * The number of items picks the screen, exactly as it does for captures:
+ *  • ONE item — `{ uri }` or a single-entry `items` — opens the single-asset image/video editor.
+ *  • SEVERAL items open the multi-media Add More + Send preview, holding the whole selection in the
+ *    order given, with its strip, per-item removal and one Send for the lot.
+ *
+ * Resolves with `cancelled: true` when the user backs out, or when nothing in the selection can be
+ * opened (unreadable files, or uris that are neither image nor video).
+ */
+export function openMediaEditor(options) {
+  return getCustomCameraModule().openMediaEditor(options);
+}
+const VIDEO_EXTENSIONS = new Set(['mp4', 'm4v', 'mov', 'mkv', '3gp', '3g2', 'webm', 'avi', 'ts', 'mts', 'm2ts', 'flv', 'wmv']);
+const IMAGE_EXTENSIONS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp', 'heic', 'heif', 'avif', 'dng', 'tif', 'tiff']);
+
+/**
+ * Media kind for an asset coming back from a picker. The native picker already types the file from
+ * its MIME type; this only covers the gaps (a provider that reports no/garbage MIME) by falling
+ * back to the file extension, so a `.mp4` never lands in the image editor. Returns null when the
+ * item is neither an image nor a video — an invalid selection for the editor.
+ */
+function resolveMediaKind(asset) {
+  if (asset.type === 'video' || asset.type === 'photo') return asset.type;
+  const mimeType = asset.mimeType?.toLowerCase() ?? '';
+  if (mimeType.startsWith('video/')) return 'video';
+  if (mimeType.startsWith('image/')) return 'photo';
+  const name = (asset.fileName || asset.uri || '').toLowerCase();
+  const extension = name.slice(name.lastIndexOf('.') + 1);
+  if (VIDEO_EXTENSIONS.has(extension)) return 'video';
+  if (IMAGE_EXTENSIONS.has(extension)) return 'photo';
+  return null;
+}
+
+/**
+ * One-call "pick from the gallery, then edit" flow: opens the device gallery
+ * ({@link openImageVideoPicker}) with unlimited selection, detects whether each chosen item is an
+ * image or a video, and hands the lot to {@link openMediaEditor} — so picked media lands on the
+ * same screens a capture does, with the same tools and the same send behaviour.
+ *
+ * Selection count drives the navigation, exactly as it does for captures: one item goes straight to
+ * the image or video editor; several go to the multi-media Add More + Send preview, carrying every
+ * item — images and videos in any combination — in the order they were picked.
+ *
+ * Resolves `{ cancelled: true, assets: [] }` when the user backs out of either step, and when
+ * nothing in the selection can be opened as media at all. Never throws for a cancel; genuine
+ * failures (no Activity, unusable uris) still reject like the underlying calls do.
+ */
+export async function openGalleryEditor(options = {}) {
+  const cancelled = {
+    cancelled: true,
+    assets: []
+  };
+  // 0 = unlimited: any number of images and videos, in any combination.
+  const picked = await openImageVideoPicker({
+    selectionLimit: 0
+  });
+  if (!picked || picked.cancelled || !Array.isArray(picked.assets)) return cancelled;
+
+  // Pick order is preserved end to end — it is the order the preview, the strip and the sent
+  // result all use. Items that resolve to neither image nor video are dropped rather than sent to
+  // an editor that can't open them.
+  const items = [];
+  for (const asset of picked.assets) {
+    if (!asset?.uri) continue;
+    const kind = resolveMediaKind(asset);
+    if (!kind) continue;
+    items.push({
+      uri: asset.uri,
+      type: kind,
+      fileName: asset.fileName,
+      mimeType: asset.mimeType
+    });
+  }
+  if (items.length === 0) return cancelled;
+  return openMediaEditor({
+    items,
+    enableFilter: options.enableFilter
+  });
+}
+
+/**
+ * Opens a document uri in an external viewer (Android `ACTION_VIEW`). Resolves `true` when an
+ * app was launched to view it, `false` when no handler is available. `mimeType` may be empty —
+ * the native side falls back to inferring it from the uri.
+ */
+export function openDocument(uri, mimeType = '') {
+  return getCustomCameraModule().openDocument(uri, mimeType);
+}
+export function startUpload(uris, uploadUrl) {
+  return getCustomCameraModule().startUpload(uris, uploadUrl);
+}
+
+/**
+ * Securely delete ONE media item natively, and report exactly what happened.
+ *
+ * The native implementation measures the file's exact size, overwrites it with
+ * encrypted cryptographically secure random data 2 MB larger than that size
+ * (written in fixed-size chunks and flushed to storage, so a multi-gigabyte
+ * video never lands in RAM), unlinks the file, then removes thumbnails, cached
+ * copies, derived variants (compressed / exported / edited / cover frames) and
+ * native metadata references. It runs entirely off the main thread.
+ *
+ * Pass `assetId` whenever you have it: derived variants are named after it, so
+ * omitting it leaves those extra copies of the same media on disk.
+ *
+ * Inspect {@link SecureDeleteResult.fullySecure} before reporting success —
+ * a file can be deleted while its overwrite failed, and the two must not be
+ * presented to the user identically. Failures are logged natively.
+ *
+ * Removing the SQLCipher row is the caller's job (see `useMediaDatabase`), and
+ * should happen only after this resolves.
+ */
+export function secureDeleteMedia(uri, options = {}) {
+  return getCustomCameraModule().secureDeleteMedia(uri, options);
+}
+
+/**
+ * Share one or more media uris through the native Android share sheet
+ * (Intent.ACTION_SEND for a single item, ACTION_SEND_MULTIPLE for several)
+ * with the correct MIME type for images, videos, documents and audio.
+ * Resolves `true` when the share chooser was launched.
+ */
+export function shareMedia(uris, mimeType) {
+  return getCustomCameraModule().shareMedia(uris, mimeType);
+}
+export function getMediaMetadata(uri) {
+  return getCustomCameraModule().getMediaMetadata(uri);
+}
+
+/**
+ * The byte length of the exact clip the recording process finalized under `mediaId`, or 0 when the
+ * native layer remembers none. A freshly recorded clip's cached file is swapped in the background
+ * for a smaller aspect-cropped re-encode; this reports the pre-crop recorded length so a preview
+ * shows the same size the recording counter approached and the editor's "Original" row shows,
+ * rather than the smaller file now on disk. Returns 0 for gallery media, user-compressed/exported
+ * copies, trimmed clips, and anything after an app restart — callers then fall back to the real
+ * on-disk size.
+ */
+export function getRecordedOriginalSize(mediaId) {
+  return getCustomCameraModule().getRecordedOriginalSize(mediaId);
+}
+
+// ── Audio Recording ─────────────────────────────────────────────────
+
+export function startAudioRecording(options = {}) {
+  return getCustomCameraModule().startAudioRecording(options);
+}
+export function stopAudioRecording() {
+  return getCustomCameraModule().stopAudioRecording();
+}
+export function cancelAudioRecording() {
+  return getCustomCameraModule().cancelAudioRecording();
+}
+export function stopAndPublishAudioRecording() {
+  return getCustomCameraModule().stopAndPublishAudioRecording();
+}
+export function pauseAudioRecording() {
+  return getCustomCameraModule().pauseAudioRecording();
+}
+export function resumeAudioRecording() {
+  return getCustomCameraModule().resumeAudioRecording();
+}
+export function getAudioRecordingState() {
+  return getCustomCameraModule().getAudioRecordingState();
+}
+export function getAudioAmplitude() {
+  return getCustomCameraModule().getAudioAmplitude();
+}
+
+// ── Compression ─────────────────────────────────────────────────────
+// The library shell's viewer offers compression on the displayed image/video, so
+// these wrappers live here with the other bridge calls rather than in the barrel.
+
+/**
+ * Re-encode a video smaller, resolving with a URI for the new file. The original is only ever
+ * read — never overwritten, moved or deleted.
+ *
+ * `qualityOrOption` is a QUALITY RATIO: `'25%'` and `'0.25'` both mean "keep a quarter of the
+ * quality" (so a LOWER value is stronger compression), and only a string starting with
+ * `'Original'` (quality ratio 1.0) resolves the input URI back untouched.
+ */
+export function compressVideo(uri, qualityOrOption) {
+  return getCustomCameraModule().compressVideo(uri, qualityOrOption);
+}
+
+/**
+ * Re-encode a still image smaller, resolving with a URI for the new file. The original is only
+ * ever read — never overwritten, moved or deleted.
+ *
+ * `qualityOrOption` is a QUALITY RATIO, exactly as {@link compressVideo} takes: `'25%'` and
+ * `'0.25'` both mean "keep a quarter of the quality" (so a LOWER value is stronger compression),
+ * and only `'Original Image'` (quality ratio 1.0) resolves the input URI back untouched — every
+ * level below it, from `'5%'` up to `'99%'`, runs the encoder. An image that is already as small as
+ * it can get also resolves the input URI, since a "compressed" copy would only be larger.
+ *
+ * The compressed copy comes back as JPEG, or as lossy WebP when the source could be carrying
+ * transparency, so an image with an alpha channel is never flattened onto white.
+ */
+export function compressImage(uri, qualityOrOption) {
+  return getCustomCameraModule().compressImage(uri, qualityOrOption);
+}
+
+/** One measured progress report from an in-flight {@link compressVideo} / {@link compressImage}. */
+
+/**
+ * Subscribe to measured progress from {@link compressVideo} and {@link compressImage}.
+ *
+ * The reports are measurements, not predictions: the video transcode reports the encoder's own
+ * output position against the clip's duration, and the still compressor reports the encodes its
+ * quality search has spent. That is what makes a real remaining time derivable — `elapsed /
+ * progress` is the total the job is actually on course for — instead of counting a fixed estimate
+ * down and either running out mid-compression or still promising seconds after it has finished.
+ *
+ * Notes for callers:
+ *  - Reports are throttled natively (a few per second at most), so this is safe to render from.
+ *  - `progress` reaches 1 when the work ends, but do not WAIT for it: a compression that fails part
+ *    way through resolves its promise (or rejects) without a final report on every path. Treat the
+ *    promise as the completion signal and these events purely as progress.
+ *  - Media whose length cannot be read reports only its start and end, so treat a quiet compression
+ *    as "progress unknown", never as "stalled".
+ *
+ * @returns the subscription; call `.remove()` to stop listening.
+ */
+export function addCompressionProgressListener(listener) {
+  return DeviceEventEmitter.addListener('onCompressionProgress', listener);
+}
+//# sourceMappingURL=nativeActions.js.map

package/lib/module/nativeActions.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["DeviceEventEmitter","getCustomCameraModule","module","require","default","openCameraPicker","options","openDocumentPicker","openAudioPicker","openImageVideoPicker","openMediaEditor","VIDEO_EXTENSIONS","Set","IMAGE_EXTENSIONS","resolveMediaKind","asset","type","mimeType","toLowerCase","startsWith","name","fileName","uri","extension","slice","lastIndexOf","has","openGalleryEditor","cancelled","assets","picked","selectionLimit","Array","isArray","items","kind","push","length","enableFilter","openDocument","startUpload","uris","uploadUrl","secureDeleteMedia","shareMedia","getMediaMetadata","getRecordedOriginalSize","mediaId","startAudioRecording","stopAudioRecording","cancelAudioRecording","stopAndPublishAudioRecording","pauseAudioRecording","resumeAudioRecording","getAudioRecordingState","getAudioAmplitude","compressVideo","qualityOrOption","compressImage","addCompressionProgressListener","listener","addListener"],"sourceRoot":"..\\..\\src","sources":["nativeActions.ts"],"mappings":"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AAiB,CAAC,CAAC;AACpD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAC3BlC,GAAW,EACXmC,eAAuB,EACN;EACjB,OAAOxD,qBAAqB,CAAC,CAAC,CAACuD,aAAa,CAAClC,GAAG,EAAEmC,eAAe,CAAC;AACpE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAC3BpC,GAAW,EACXmC,eAAuB,EACN;EACjB,OAAOxD,qBAAqB,CAAC,CAAC,CAACyD,aAAa,CAACpC,GAAG,EAAEmC,eAAe,CAAC;AACpE;;AAEA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,8BAA8BA,CAC5CC,QAAmD,EAC3B;EACxB,OAAO5D,kBAAkB,CAAC6D,WAAW,CAAC,uBAAuB,EAAED,QAAQ,CAAC;AAC1E","ignoreList":[]}

package/lib/module/nativeComponentSupport.js

@@ -0,0 +1,61 @@
+"use strict";
+
+/**
+ * Resolution helpers for this library's optional native views.
+ *
+ * Every native view here is optional by design: the JS half of the library is published as
+ * plain source and can be running against a host app whose native module was built before that
+ * view existed (or against a platform that has no native half at all). The JS must therefore be
+ * able to answer "is this view actually in the binary?" — and answer it *before* rendering.
+ */
+
+import { Platform, UIManager, requireNativeComponent } from 'react-native';
+
+/**
+ * The native component registered under [name], or `null` when this build does not have it.
+ *
+ * `requireNativeComponent` resolves its view config LAZILY: the call itself always succeeds and
+ * the UIManager lookup only happens when React first renders the element. Wrapping the call in
+ * try/catch — the shape this library used previously — therefore cannot see a missing view
+ * manager, so `isNative…Available()` reported `true` and the first row that rendered the view
+ * threw `requireNativeComponent: '<name>' was not found in the UIManager` instead of quietly
+ * taking the fallback. Asking the UIManager up front makes the answer truthful, which is what
+ * every caller's fallback path depends on.
+ */
+export function resolveNativeComponent(name) {
+  if (Platform.OS !== 'android') return null;
+  // Only a definite "no" rules the view out. An unanswerable probe must not: reading it as
+  // absent would send a working build down the fallback path for every view in the library.
+  if (isViewManagerRegistered(name) === false) return null;
+  try {
+    return requireNativeComponent(name);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Whether the UIManager knows [name] — `null` when this runtime cannot say, which is not the
+ * same answer as `false`.
+ */
+function isViewManagerRegistered(name) {
+  try {
+    if (typeof UIManager?.hasViewManagerConfig !== 'function') return null;
+    return UIManager.hasViewManagerConfig(name);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * A URI ReactNative's `<Image>` can actually load.
+ *
+ * The media database stores plain absolute paths (`/data/user/0/…/Documents/media_documents/
+ * photo.jpg`), and Fresco needs a scheme: pointed at a bare path it renders nothing at all and
+ * reports no error, which is indistinguishable from an empty tile.
+ */
+export function toImageSourceUri(uri) {
+  if (!uri) return undefined;
+  return /^[a-z][a-z0-9+.-]*:/i.test(uri) ? uri : `file://${uri}`;
+}
+//# sourceMappingURL=nativeComponentSupport.js.map

package/lib/module/nativeComponentSupport.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","UIManager","requireNativeComponent","resolveNativeComponent","name","OS","isViewManagerRegistered","hasViewManagerConfig","toImageSourceUri","uri","undefined","test"],"sourceRoot":"..\\..\\src","sources":["nativeComponentSupport.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,QAAQ,EAAEC,SAAS,EAAEC,sBAAsB,QAAQ,cAAc;;AAE1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,sBAAsBA,CACpCC,IAAY,EACiB;EAC7B,IAAIJ,QAAQ,CAACK,EAAE,KAAK,SAAS,EAAE,OAAO,IAAI;EAC1C;EACA;EACA,IAAIC,uBAAuB,CAACF,IAAI,CAAC,KAAK,KAAK,EAAE,OAAO,IAAI;EACxD,IAAI;IACF,OAAOF,sBAAsB,CAAQE,IAAI,CAAC;EAC5C,CAAC,CAAC,MAAM;IACN,OAAO,IAAI;EACb;AACF;;AAEA;AACA;AACA;AACA;AACA,SAASE,uBAAuBA,CAACF,IAAY,EAAkB;EAC7D,IAAI;IACF,IAAI,OAAOH,SAAS,EAAEM,oBAAoB,KAAK,UAAU,EAAE,OAAO,IAAI;IACtE,OAAON,SAAS,CAACM,oBAAoB,CAACH,IAAI,CAAC;EAC7C,CAAC,CAAC,MAAM;IACN,OAAO,IAAI;EACb;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASI,gBAAgBA,CAACC,GAAmB,EAAsB;EACxE,IAAI,CAACA,GAAG,EAAE,OAAOC,SAAS;EAC1B,OAAO,sBAAsB,CAACC,IAAI,CAACF,GAAG,CAAC,GAAGA,GAAG,GAAG,UAAUA,GAAG,EAAE;AACjE","ignoreList":[]}

package/lib/module/networkPerformance.js

@@ -0,0 +1,24 @@
+"use strict";
+
+import { validateUploadUrl } from "./validation.js";
+export { validateUploadUrl } from "./validation.js";
+export async function checkNetworkConnectivity() {
+  return true;
+}
+export async function adaptiveUpload(uri, uploadUrl) {
+  validateUploadUrl(uploadUrl);
+  return {
+    ok: true,
+    uri,
+    uploadUrl
+  };
+}
+export function estimateBandwidth() {
+  return 0;
+}
+export class NetworkMonitor {
+  async check() {
+    return true;
+  }
+}
+//# sourceMappingURL=networkPerformance.js.map

package/lib/module/networkPerformance.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["validateUploadUrl","checkNetworkConnectivity","adaptiveUpload","uri","uploadUrl","ok","estimateBandwidth","NetworkMonitor","check"],"sourceRoot":"..\\..\\src","sources":["networkPerformance.ts"],"mappings":";;AAAA,SAASA,iBAAiB,QAAQ,iBAAc;AAEhD,SAASA,iBAAiB,QAAQ,iBAAc;AAEhD,OAAO,eAAeC,wBAAwBA,CAAA,EAAqB;EACjE,OAAO,IAAI;AACb;AAEA,OAAO,eAAeC,cAAcA,CAClCC,GAAW,EACXC,SAAiB,EACyC;EAC1DJ,iBAAiB,CAACI,SAAS,CAAC;EAE5B,OAAO;IACLC,EAAE,EAAE,IAAI;IACRF,GAAG;IACHC;EACF,CAAC;AACH;AAEA,OAAO,SAASE,iBAAiBA,CAAA,EAAW;EAC1C,OAAO,CAAC;AACV;AAEA,OAAO,MAAMC,cAAc,CAAC;EAC1B,MAAMC,KAAKA,CAAA,EAAqB;IAC9B,OAAO,IAAI;EACb;AACF","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/performance.js

@@ -0,0 +1,104 @@
+"use strict";
+
+import { measurePerformance as measurePerformanceMonitor } from "./performanceMonitor.js";
+export { measurePerformance } from "./performanceMonitor.js";
+export function debounce(fn, wait = 0) {
+  let timeout = null;
+  return (...args) => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => {
+      timeout = null;
+      fn(...args);
+    }, wait);
+  };
+}
+export function throttle(fn, wait = 0) {
+  let lastCall = 0;
+  return (...args) => {
+    const now = Date.now();
+    if (now - lastCall >= wait) {
+      lastCall = now;
+      fn(...args);
+    }
+  };
+}
+export class MediaCache {
+  store = new Map();
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  get(key) {
+    return this.store.get(key);
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+}
+export class BackgroundOperationManager {
+  queue = [];
+  async enqueue(operation) {
+    this.queue.push(operation);
+    return this.runNext();
+  }
+  async runNext() {
+    const operation = this.queue.shift();
+    if (!operation) {
+      return undefined;
+    }
+    try {
+      return await operation();
+    } finally {
+      if (this.queue.length > 0) {
+        await this.runNext();
+      }
+    }
+  }
+}
+export class LazyLoader {
+  isLoading = false;
+  error = null;
+  constructor(factory) {
+    this.factory = factory;
+  }
+  load() {
+    if (this.value === undefined && !this.isLoading) {
+      try {
+        this.isLoading = true;
+        this.value = this.factory();
+        this.error = null;
+      } catch (err) {
+        this.error = err;
+        throw err;
+      } finally {
+        this.isLoading = false;
+      }
+    }
+    if (this.error) {
+      throw this.error;
+    }
+    return this.value;
+  }
+  reset() {
+    this.value = undefined;
+    this.error = null;
+  }
+  get isLoaded() {
+    return this.value !== undefined;
+  }
+  get hasError() {
+    return this.error !== null;
+  }
+}
+export async function processMediaInChunks(items, batchSize = 10, processor) {
+  for (let index = 0; index < items.length; index += batchSize) {
+    const chunk = items.slice(index, index + batchSize);
+    await processor(chunk);
+  }
+}
+export { measurePerformanceMonitor as measurePerformanceMonitorImpl };
+//# sourceMappingURL=performance.js.map

package/lib/module/performance.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["measurePerformance","measurePerformanceMonitor","debounce","fn","wait","timeout","args","clearTimeout","setTimeout","throttle","lastCall","now","Date","MediaCache","store","Map","set","key","value","get","delete","clear","BackgroundOperationManager","queue","enqueue","operation","push","runNext","shift","undefined","length","LazyLoader","isLoading","error","constructor","factory","load","err","reset","isLoaded","hasError","processMediaInChunks","items","batchSize","processor","index","chunk","slice","measurePerformanceMonitorImpl"],"sourceRoot":"..\\..\\src","sources":["performance.ts"],"mappings":"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","ignoreList":[]}