@webority/mobile-core 0.0.28 → 0.1.0

package/lib/module/storage/index.js

@@ -1,208 +1 @@
-"use strict";
-
-import KvStore from 'expo-sqlite/kv-store';
-import { Logger } from "../logger/index.js";
-
-/**
- * Minimal AsyncStorage shape we depend on.
- * Lets us avoid a hard import on `@react-native-async-storage/async-storage`.
- */
-
-/** Only what a test or the showcase injected; null means use expo-sqlite/kv-store. */
-let backend = null;
-
-/**
- * expo-sqlite's key/value store, imported directly.
- *
- * It deliberately implements the AsyncStorage v1 surface — `getItem`,
- * `setItem`, `removeItem`, `multiGet`, `multiSet`, `multiRemove`, `clear`,
- * `getAllKeys`, with v1's shapes — which is exactly what this module already
- * speaks, so there is nothing to convert. Verified against expo-sqlite 57.0.2.
- */
-const resolveBackend = () => backend ?? KvStore;
-
-/**
- * Always true now that the backend ships with the library. Kept because callers
- * whose use of storage is an OPTIMISATION branch on it, and removing it would
- * be a breaking change for no gain.
- */
-export const isStorageAvailable = () => resolveBackend() !== null;
-const requireBackend = op => {
-  const b = resolveBackend();
-  if (!b) {
-    // Only reachable if a caller injected something falsy; the default backend
-    // ships with the library, so there is no "not installed" case any more.
-    const err = new Error(`[Storage] no storage backend available; cannot ${op}.`);
-    Logger.error(err.message);
-    throw err;
-  }
-  return b;
-};
-
-/**
- * Replace the storage backend. Intended for TESTS and for the showcase; an app
- * gets expo-sqlite/kv-store without wiring anything. Pass `null` to restore it.
- */
-export const setStorageImplementation = impl => {
-  backend = impl;
-};
-const safeJsonParse = raw => {
-  if (raw == null) {
-    return null;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch (error) {
-    Logger.warn('[Storage] Failed to parse JSON value, returning null', error);
-    return null;
-  }
-};
-const getItem = async key => {
-  try {
-    return await requireBackend('getItem').getItem(key);
-  } catch (error) {
-    Logger.error(`[Storage] getItem failed for key "${key}"`, error);
-    return null;
-  }
-};
-const setItem = async (key, value) => {
-  try {
-    await requireBackend('setItem').setItem(key, value);
-    return true;
-  } catch (error) {
-    Logger.error(`[Storage] setItem failed for key "${key}"`, error);
-    return false;
-  }
-};
-const removeItem = async key => {
-  try {
-    await requireBackend('removeItem').removeItem(key);
-    return true;
-  } catch (error) {
-    Logger.error(`[Storage] removeItem failed for key "${key}"`, error);
-    return false;
-  }
-};
-const getJson = async key => {
-  const raw = await getItem(key);
-  return safeJsonParse(raw);
-};
-const setJson = async (key, value) => {
-  try {
-    return await setItem(key, JSON.stringify(value));
-  } catch (error) {
-    Logger.error(`[Storage] setJson failed for key "${key}"`, error);
-    return false;
-  }
-};
-const multiGet = async keys => {
-  try {
-    const b = requireBackend('multiGet');
-    // v3 first: its Record is already this function's return shape.
-    if (b.getMany) {
-      return await b.getMany([...keys]);
-    }
-    if (!b.multiGet) {
-      const out = {};
-      await Promise.all(keys.map(async k => {
-        out[k] = await b.getItem(k);
-      }));
-      return out;
-    }
-    const pairs = await b.multiGet(keys);
-    const out = {};
-    for (const [k, v] of pairs) {
-      out[k] = v;
-    }
-    return out;
-  } catch (error) {
-    Logger.error('[Storage] multiGet failed', error);
-    return {};
-  }
-};
-const multiSet = async entries => {
-  try {
-    const b = requireBackend('multiSet');
-    // v3 first: it takes the Record this function already receives.
-    if (b.setMany) {
-      await b.setMany(entries);
-      return true;
-    }
-    const pairs = Object.entries(entries);
-    if (!b.multiSet) {
-      await Promise.all(pairs.map(([k, v]) => b.setItem(k, v)));
-      return true;
-    }
-    await b.multiSet(pairs);
-    return true;
-  } catch (error) {
-    Logger.error('[Storage] multiSet failed', error);
-    return false;
-  }
-};
-const multiRemove = async keys => {
-  try {
-    const b = requireBackend('multiRemove');
-    if (b.removeMany) {
-      await b.removeMany([...keys]);
-      return true;
-    }
-    if (!b.multiRemove) {
-      await Promise.all(keys.map(k => b.removeItem(k)));
-      return true;
-    }
-    await b.multiRemove(keys);
-    return true;
-  } catch (error) {
-    Logger.error('[Storage] multiRemove failed', error);
-    return false;
-  }
-};
-const clear = async () => {
-  try {
-    const b = requireBackend('clear');
-    if (!b.clear) {
-      Logger.warn('[Storage] backend does not support clear()');
-      return false;
-    }
-    await b.clear();
-    return true;
-  } catch (error) {
-    Logger.error('[Storage] clear failed', error);
-    return false;
-  }
-};
-const getAllKeys = async () => {
-  try {
-    const b = requireBackend('getAllKeys');
-    if (!b.getAllKeys) {
-      return [];
-    }
-    const keys = await b.getAllKeys();
-    return [...keys];
-  } catch (error) {
-    Logger.error('[Storage] getAllKeys failed', error);
-    return [];
-  }
-};
-/**
- * Typed AsyncStorage wrapper with safe JSON helpers.
- * All operations swallow errors (logging them) and return a falsy result
- * so that storage problems never crash the app.
- *
- * Backed by `expo-sqlite/kv-store` by default;
- * override with `setStorageImplementation()` for MMKV or custom adapters.
- */
-export const Storage = {
-  getItem,
-  setItem,
-  removeItem,
-  getJson,
-  setJson,
-  multiGet,
-  multiSet,
-  multiRemove,
-  clear,
-  getAllKeys
-};
-//# sourceMappingURL=index.js.map
+import e from"expo-sqlite/kv-store";import{Logger as t}from"../logger/index.js";let r=null;const resolveBackend=()=>r??e;export const isStorageAvailable=()=>null!==resolveBackend();const requireBackend=e=>{const r=resolveBackend();if(!r){const r=new Error(`[Storage] no storage backend available; cannot ${e}.`);throw t.error(r.message),r}return r};export const setStorageImplementation=e=>{r=e};const getItem=async e=>{try{return await requireBackend("getItem").getItem(e)}catch(r){return t.error(`[Storage] getItem failed for key "${e}"`,r),null}},setItem=async(e,r)=>{try{return await requireBackend("setItem").setItem(e,r),!0}catch(r){return t.error(`[Storage] setItem failed for key "${e}"`,r),!1}};export const Storage={getItem:getItem,setItem:setItem,removeItem:async e=>{try{return await requireBackend("removeItem").removeItem(e),!0}catch(r){return t.error(`[Storage] removeItem failed for key "${e}"`,r),!1}},getJson:async e=>(e=>{if(null==e)return null;try{return JSON.parse(e)}catch(e){return t.warn("[Storage] Failed to parse JSON value, returning null",e),null}})(await getItem(e)),setJson:async(e,r)=>{try{return await setItem(e,JSON.stringify(r))}catch(r){return t.error(`[Storage] setJson failed for key "${e}"`,r),!1}},multiGet:async e=>{try{const t=requireBackend("multiGet");if(t.getMany)return await t.getMany([...e]);if(!t.multiGet){const r={};return await Promise.all(e.map(async e=>{r[e]=await t.getItem(e)})),r}const r=await t.multiGet(e),a={};for(const[e,t]of r)a[e]=t;return a}catch(e){return t.error("[Storage] multiGet failed",e),{}}},multiSet:async e=>{try{const t=requireBackend("multiSet");if(t.setMany)return await t.setMany(e),!0;const r=Object.entries(e);return t.multiSet?(await t.multiSet(r),!0):(await Promise.all(r.map(([e,r])=>t.setItem(e,r))),!0)}catch(e){return t.error("[Storage] multiSet failed",e),!1}},multiRemove:async e=>{try{const t=requireBackend("multiRemove");return t.removeMany?(await t.removeMany([...e]),!0):t.multiRemove?(await t.multiRemove(e),!0):(await Promise.all(e.map(e=>t.removeItem(e))),!0)}catch(e){return t.error("[Storage] multiRemove failed",e),!1}},clear:async()=>{try{const e=requireBackend("clear");return e.clear?(await e.clear(),!0):(t.warn("[Storage] backend does not support clear()"),!1)}catch(e){return t.error("[Storage] clear failed",e),!1}},getAllKeys:async()=>{try{const e=requireBackend("getAllKeys");if(!e.getAllKeys)return[];return[...await e.getAllKeys()]}catch(e){return t.error("[Storage] getAllKeys failed",e),[]}}};

package/lib/module/types/axios.js

@@ -1,4 +1 @@
-"use strict";
-
-import 'axios';
-//# sourceMappingURL=axios.js.map
+import"axios";

package/lib/module/types/globals.d.js

@@ -1,10 +1 @@
-"use strict";
-
-/**
- * The expo-application jest mock is exposed on globalThis so a test can blank a
- * value to reach the "no identity anywhere" path. expo ships these as module
- * constants, which cannot be reassigned through the ES binding from a test file.
- */
-
-export {};
-//# sourceMappingURL=globals.d.js.map
+export{};

package/lib/module/utils/base64.js

@@ -1,19 +1 @@
-"use strict";
-
-// Small enough for every engine's argument limit in `String.fromCharCode.apply`.
-const CHUNK = 0x2000;
-
-/**
- * Base64 of raw bytes, for a `data:` URI. Builds a Latin-1 string a chunk at a
- * time and hands it to the engine's native `btoa` (Hermes ships it), which is
- * many times faster on the JS thread than encoding byte by byte in JS.
- */
-export const encodeBase64 = buffer => {
-  const bytes = new Uint8Array(buffer);
-  let binary = '';
-  for (let i = 0; i < bytes.length; i += CHUNK) {
-    binary += String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK));
-  }
-  return btoa(binary);
-};
-//# sourceMappingURL=base64.js.map
+export const encodeBase64=r=>{const e=new Uint8Array(r);let t="";for(let r=0;r<e.length;r+=8192)t+=String.fromCharCode.apply(null,e.subarray(r,r+8192));return btoa(t)};

package/lib/module/utils/imageCompression.js

@@ -1,383 +1 @@
-"use strict";
-
-import { File } from 'expo-file-system';
-import { ImageManipulator } from 'expo-image-manipulator';
-import { Logger } from "../logger/index.js";
-
-/**
- * Image compression for uploads: the whole shell an app needs around a
- * picked photo, so an app calls this once and uploads what comes back.
- *
- * What it does, in order:
- *
- * 1. Measures the source. A missing or EMPTY file throws `ImageUnreadableError`
- *    so the user is asked to retake: the OS evicts a camera temp file between
- *    capture and a delayed save, and uploading the empty result is a certain
- *    server rejection that can wedge an outbox.
- * 2. Decodes the photo ONCE and reads its size. The longer side is brought
- *    down to `maxSize` (1500 by default, the fleet standard); a photo already
- *    within it is never enlarged.
- * 3. Re-encodes at a quality picked from the source's real byte size (bigger
- *    files are compressed harder), or at the `quality` given. The re-encode
- *    drops EXIF as a side effect; location and time travel as payload fields,
- *    never add a second stripping step.
- * 4. With `maxBytes`, keeps re-encoding at a lower quality, then a smaller
- *    size, until the output fits, deleting each superseded file.
- * 5. Measures the output the same way as the source and returns everything
- *    an upload needs: uri, pixel size, byte size, mime type, extension, file
- *    name and a ready `FormData` part.
- *
- * Only an ENCODER failure falls back to the original file, reported through
- * `compressed: false` with the original's own type and size; the reference
- * apps upload the original rather than lose the photo. An unreadable file is
- * never a fallback, it throws.
- *
- * Backed by `expo-image-manipulator` and `expo-file-system`; an app wires
- * nothing. Tests and the showcase inject a backend through
- * `setImageCompressorImplementation`.
- */
-
-/** The source was missing or empty, or the encoder produced an empty file. */
-export class ImageUnreadableError extends Error {
-  constructor(uri, reason) {
-    super(`Image is unreadable (${reason}): ${uri || '<empty uri>'}`);
-    this.name = 'ImageUnreadableError';
-    this.uri = uri;
-  }
-}
-
-/** A decoded image, held in memory until `close`. */
-
-/**
- * What the algorithm needs from a backend. The default is built on
- * expo-image-manipulator and expo-file-system.
- */
-
-const release = object => {
-  try {
-    object?.release?.();
-  } catch {
-    // A shared object released twice throws; nothing to do.
-  }
-};
-
-/**
- * expo-image-manipulator's contextual API plus expo-file-system's File
- * class. `manipulate` accepts the decoded ImageRef as well as a URI (checked
- * in the Android and iOS module sources for SDK 57), which is what makes the
- * single decode possible: every encode, including each step of the byte
- * ceiling ladder, resizes the in-memory image rather than re-reading and
- * re-decoding the file.
- */
-const expoBackend = {
-  stat: async uri => {
-    const file = new File(uri);
-    if (!file.exists) {
-      return {
-        exists: false,
-        size: 0
-      };
-    }
-    // Both native modules hand back null when the size attribute cannot be
-    // read (a provider-backed URI). That is UNKNOWN, never empty: reading it
-    // as 0 would send a user to retake a perfectly good photo.
-    return file.size == null ? null : {
-      exists: true,
-      size: file.size
-    };
-  },
-  remove: async uri => {
-    new File(uri).delete();
-  },
-  open: async uri => {
-    const source = ImageManipulator.manipulate(uri);
-    let image;
-    try {
-      image = await source.renderAsync();
-    } finally {
-      release(source);
-    }
-    return {
-      width: image.width,
-      height: image.height,
-      encode: async ({
-        width,
-        height,
-        quality,
-        format
-      }) => {
-        const context = ImageManipulator.manipulate(image);
-        let rendered = null;
-        try {
-          if (width !== undefined || height !== undefined) {
-            context.resize({
-              width: width ?? null,
-              height: height ?? null
-            });
-          }
-          rendered = await context.renderAsync();
-          const saved = await rendered.saveAsync({
-            compress: quality,
-            // expo's SaveFormat enum spells the same three strings.
-            format: format
-          });
-          return {
-            uri: saved.uri,
-            width: saved.width,
-            height: saved.height
-          };
-        } finally {
-          release(rendered);
-          release(context);
-        }
-      },
-      close: () => release(image)
-    };
-  }
-};
-
-/** Only what a test or the showcase injected; null means the expo backend. */
-let backend = null;
-
-/**
- * Replace the backend. Intended for TESTS and for the showcase; an app gets
- * the expo modules without wiring anything. Pass `null` to restore them.
- */
-export const setImageCompressorImplementation = impl => {
-  backend = impl;
-};
-const resolveBackend = () => backend ?? expoBackend;
-const EIGHT_MB = 8 * 1024 * 1024;
-const THREE_MB = 3 * 1024 * 1024;
-
-/**
- * Bigger source files get compressed harder: a fixed quality either
- * over-compresses small photos or leaves large ones too heavy to upload
- * quickly. Unknown size falls back to the middle rung rather than assuming
- * either extreme. The fleet ladder (`react-native.md`).
- */
-export const qualityForFileSize = fileSize => {
-  if (fileSize == null) {
-    return 0.7;
-  }
-  if (fileSize > EIGHT_MB) {
-    return 0.6;
-  }
-  if (fileSize > THREE_MB) {
-    return 0.7;
-  }
-  return 0.8;
-};
-const DEFAULT_MAX_SIZE = 1500;
-const DEFAULT_MIN_QUALITY = 0.4;
-/** One step of the byte ceiling ladder. */
-const QUALITY_STEP = 0.1;
-/** How much the longer side shrinks per step once quality is at its floor. */
-const SIZE_STEP = 0.75;
-/** The ladder stops shrinking here; below it a document photo is unreadable. */
-const MIN_SIDE = 320;
-const FORMAT = {
-  jpg: {
-    encode: 'jpeg',
-    mimeType: 'image/jpeg'
-  },
-  png: {
-    encode: 'png',
-    mimeType: 'image/png'
-  },
-  webp: {
-    encode: 'webp',
-    mimeType: 'image/webp'
-  }
-};
-
-/** The mime type an untouched original is uploaded with, from its extension. */
-const MIME_BY_EXTENSION = {
-  jpg: 'image/jpeg',
-  jpeg: 'image/jpeg',
-  png: 'image/png',
-  webp: 'image/webp',
-  gif: 'image/gif',
-  heic: 'image/heic',
-  heif: 'image/heif',
-  bmp: 'image/bmp',
-  tif: 'image/tiff',
-  tiff: 'image/tiff'
-};
-
-/** The last path segment of a URI, without query or fragment. */
-const lastSegment = uri => {
-  const path = uri.split(/[?#]/)[0] ?? '';
-  return decodeURIComponentSafe(path.slice(path.lastIndexOf('/') + 1));
-};
-const decodeURIComponentSafe = value => {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-};
-const extensionOf = fileName => {
-  const dot = fileName.lastIndexOf('.');
-  return dot > 0 ? fileName.slice(dot + 1).toLowerCase() : '';
-};
-const withoutExtension = fileName => {
-  const dot = fileName.lastIndexOf('.');
-  return dot > 0 ? fileName.slice(0, dot) : fileName;
-};
-const baseNameFor = (uri, name) => withoutExtension(name?.trim() || lastSegment(uri)) || 'image';
-const round1 = value => Math.round(value * 10) / 10;
-
-/** A stat that throws (an unsupported scheme) is UNKNOWN, not missing. */
-const safeStat = async (lib, uri) => {
-  try {
-    return await lib.stat(uri);
-  } catch {
-    return null;
-  }
-};
-const safeRemove = async (lib, uri) => {
-  try {
-    await lib.remove(uri);
-  } catch {
-    // A superseded temp file that will not delete is the cache's problem, not the upload's.
-  }
-};
-/**
- * Encode the decoded image with its longer side inside `bound`, then measure
- * the file. Only the longer side is given to the encoder: expo treats a given
- * width AND height as targets and would distort the image.
- */
-const renderWithin = async (lib, image, bound, quality, format) => {
-  const longer = Math.max(image.width, image.height);
-  const resize = longer > bound ? image.width >= image.height ? {
-    width: bound
-  } : {
-    height: bound
-  } : {};
-  const encoded = await image.encode({
-    ...resize,
-    quality,
-    format
-  });
-  const stat = await safeStat(lib, encoded.uri);
-  if (stat && (!stat.exists || stat.size === 0)) {
-    await safeRemove(lib, encoded.uri);
-    throw new ImageUnreadableError(encoded.uri, 'the encoder wrote an empty file');
-  }
-  return {
-    ...encoded,
-    size: stat?.size ?? null
-  };
-};
-const originalResult = (uri, size, baseName, dimensions) => {
-  const extension = extensionOf(lastSegment(uri)) || 'jpg';
-  const mimeType = MIME_BY_EXTENSION[extension] ?? 'image/jpeg';
-  const fileName = `${baseName}.${extension}`;
-  return {
-    uri,
-    width: dimensions?.width ?? null,
-    height: dimensions?.height ?? null,
-    size,
-    mimeType,
-    extension,
-    fileName,
-    compressed: false,
-    quality: null,
-    part: {
-      uri,
-      name: fileName,
-      type: mimeType
-    }
-  };
-};
-
-/**
- * Compress an image for upload. See the module comment for the contract.
- *
- * @throws ImageUnreadableError when the source is missing or empty, or the
- * encoder produced an empty file. Any other failure returns the original with
- * `compressed: false`.
- */
-export const compressImage = async (uri, options = {}) => {
-  if (!uri) {
-    throw new ImageUnreadableError(uri, 'no uri');
-  }
-  const lib = resolveBackend();
-  const {
-    maxSize = DEFAULT_MAX_SIZE,
-    output = 'jpg',
-    maxBytes,
-    minQuality = DEFAULT_MIN_QUALITY,
-    name
-  } = options;
-  const format = FORMAT[output] ?? FORMAT.jpg;
-  const baseName = baseNameFor(uri, name);
-  const source = await safeStat(lib, uri);
-  if (source && !source.exists) {
-    throw new ImageUnreadableError(uri, 'the file does not exist');
-  }
-  if (source && source.size === 0) {
-    throw new ImageUnreadableError(uri, 'the file is empty');
-  }
-  const sourceSize = source?.size ?? options.fileSize ?? null;
-  let image;
-  try {
-    image = await lib.open(uri);
-  } catch (error) {
-    Logger.error('[imageCompression] could not decode the image; uploading the original', error);
-    return originalResult(uri, sourceSize, baseName, null);
-  }
-  try {
-    let quality = options.quality ?? qualityForFileSize(sourceSize);
-    let bound = maxSize;
-    let rendered = await renderWithin(lib, image, bound, quality, format.encode);
-    if (maxBytes !== undefined) {
-      // Quality first, then size: a smaller file at the same pixel size
-      // keeps the document legible longer than a shrunken one.
-      while (rendered.size !== null && rendered.size > maxBytes) {
-        if (output !== 'png' && round1(quality - QUALITY_STEP) >= minQuality) {
-          quality = round1(quality - QUALITY_STEP);
-        } else {
-          const longer = Math.max(rendered.width, rendered.height);
-          if (longer <= MIN_SIDE) {
-            break;
-          }
-          bound = Math.max(MIN_SIDE, Math.floor(longer * SIZE_STEP));
-        }
-        const next = await renderWithin(lib, image, bound, quality, format.encode);
-        await safeRemove(lib, rendered.uri);
-        rendered = next;
-      }
-    }
-    const fileName = `${baseName}.${output}`;
-    return {
-      uri: rendered.uri,
-      width: rendered.width,
-      height: rendered.height,
-      size: rendered.size,
-      mimeType: format.mimeType,
-      extension: output,
-      fileName,
-      compressed: true,
-      quality: output === 'png' ? null : quality,
-      part: {
-        uri: rendered.uri,
-        name: fileName,
-        type: format.mimeType
-      }
-    };
-  } catch (error) {
-    if (error instanceof ImageUnreadableError) {
-      throw error;
-    }
-    Logger.error('[imageCompression] encoding failed; uploading the original', error);
-    return originalResult(uri, sourceSize, baseName, {
-      width: image.width,
-      height: image.height
-    });
-  } finally {
-    image.close();
-  }
-};
-//# sourceMappingURL=imageCompression.js.map
+import{File as e}from"expo-file-system";import{ImageManipulator as t}from"expo-image-manipulator";import{Logger as i}from"../logger/index.js";export class ImageUnreadableError extends Error{constructor(e,t){super(`Image is unreadable (${t}): ${e||"<empty uri>"}`),this.name="ImageUnreadableError",this.uri=e}}const release=e=>{try{e?.release?.()}catch{}},r={stat:async t=>{const i=new e(t);return i.exists?null==i.size?null:{exists:!0,size:i.size}:{exists:!1,size:0}},remove:async t=>{new e(t).delete()},open:async e=>{const i=t.manipulate(e);let r;try{r=await i.renderAsync()}finally{release(i)}return{width:r.width,height:r.height,encode:async({width:e,height:i,quality:a,format:n})=>{const o=t.manipulate(r);let s=null;try{void 0===e&&void 0===i||o.resize({width:e??null,height:i??null}),s=await o.renderAsync();const t=await s.saveAsync({compress:a,format:n});return{uri:t.uri,width:t.width,height:t.height}}finally{release(s),release(o)}},close:()=>release(r)}}};let a=null;export const setImageCompressorImplementation=e=>{a=e};export const qualityForFileSize=e=>null==e?.7:e>8388608?.6:e>3145728?.7:.8;const n=1500,o=.4,s={jpg:{encode:"jpeg",mimeType:"image/jpeg"},png:{encode:"png",mimeType:"image/png"},webp:{encode:"webp",mimeType:"image/webp"}},l={jpg:"image/jpeg",jpeg:"image/jpeg",png:"image/png",webp:"image/webp",gif:"image/gif",heic:"image/heic",heif:"image/heif",bmp:"image/bmp",tif:"image/tiff",tiff:"image/tiff"},lastSegment=e=>{const t=e.split(/[?#]/)[0]??"";return decodeURIComponentSafe(t.slice(t.lastIndexOf("/")+1))},decodeURIComponentSafe=e=>{try{return decodeURIComponent(e)}catch{return e}},round1=e=>Math.round(10*e)/10,safeStat=async(e,t)=>{try{return await e.stat(t)}catch{return null}},safeRemove=async(e,t)=>{try{await e.remove(t)}catch{}},renderWithin=async(e,t,i,r,a)=>{const n=Math.max(t.width,t.height)>i?t.width>=t.height?{width:i}:{height:i}:{},o=await t.encode({...n,quality:r,format:a}),s=await safeStat(e,o.uri);if(s&&(!s.exists||0===s.size))throw await safeRemove(e,o.uri),new ImageUnreadableError(o.uri,"the encoder wrote an empty file");return{...o,size:s?.size??null}},originalResult=(e,t,i,r)=>{const a=(e=>{const t=e.lastIndexOf(".");return t>0?e.slice(t+1).toLowerCase():""})(lastSegment(e))||"jpg",n=l[a]??"image/jpeg",o=`${i}.${a}`;return{uri:e,width:r?.width??null,height:r?.height??null,size:t,mimeType:n,extension:a,fileName:o,compressed:!1,quality:null,part:{uri:e,name:o,type:n}}};export const compressImage=async(e,t={})=>{if(!e)throw new ImageUnreadableError(e,"no uri");const l=a??r,{maxSize:m=n,output:h="jpg",maxBytes:g,minQuality:c=o,name:p}=t,u=s[h]??s.jpg,d=((e,t)=>(e=>{const t=e.lastIndexOf(".");return t>0?e.slice(0,t):e})(t?.trim()||lastSegment(e))||"image")(e,p),w=await safeStat(l,e);if(w&&!w.exists)throw new ImageUnreadableError(e,"the file does not exist");if(w&&0===w.size)throw new ImageUnreadableError(e,"the file is empty");const y=w?.size??t.fileSize??null;let f;try{f=await l.open(e)}catch(t){return i.error("[imageCompression] could not decode the image; uploading the original",t),originalResult(e,y,d,null)}try{let e=t.quality??(null==(x=y)?.7:x>8388608?.6:x>3145728?.7:.8),i=m,r=await renderWithin(l,f,i,e,u.encode);if(void 0!==g)for(;null!==r.size&&r.size>g;){if("png"!==h&&round1(e-.1)>=c)e=round1(e-.1);else{const e=Math.max(r.width,r.height);if(e<=320)break;i=Math.max(320,Math.floor(.75*e))}const t=await renderWithin(l,f,i,e,u.encode);await safeRemove(l,r.uri),r=t}const a=`${d}.${h}`;return{uri:r.uri,width:r.width,height:r.height,size:r.size,mimeType:u.mimeType,extension:h,fileName:a,compressed:!0,quality:"png"===h?null:e,part:{uri:r.uri,name:a,type:u.mimeType}}}catch(t){if(t instanceof ImageUnreadableError)throw t;return i.error("[imageCompression] encoding failed; uploading the original",t),originalResult(e,y,d,{width:f.width,height:f.height})}finally{f.close()}var x};

package/lib/module/utils/index.js

@@ -1,4 +1 @@
-"use strict";
-
-export { compressImage, setImageCompressorImplementation } from "./imageCompression.js";
-//# sourceMappingURL=index.js.map
+export{compressImage,setImageCompressorImplementation}from"./imageCompression.js";