@webority/mobile-core 0.0.23

package/lib/commonjs/storage/index.js

@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setStorageImplementation = exports.isStorageAvailable = exports.Storage = void 0;
+var _kvStore = _interopRequireDefault(require("expo-sqlite/kv-store"));
+var _index = require("../logger/index.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * 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.default;
+
+/**
+ * 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.
+ */
+const isStorageAvailable = () => resolveBackend() !== null;
+exports.isStorageAvailable = isStorageAvailable;
+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}.`);
+    _index.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.
+ */
+const setStorageImplementation = impl => {
+  backend = impl;
+};
+exports.setStorageImplementation = setStorageImplementation;
+const safeJsonParse = raw => {
+  if (raw == null) {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    _index.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) {
+    _index.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) {
+    _index.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) {
+    _index.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) {
+    _index.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) {
+    _index.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) {
+    _index.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) {
+    _index.Logger.error('[Storage] multiRemove failed', error);
+    return false;
+  }
+};
+const clear = async () => {
+  try {
+    const b = requireBackend('clear');
+    if (!b.clear) {
+      _index.Logger.warn('[Storage] backend does not support clear()');
+      return false;
+    }
+    await b.clear();
+    return true;
+  } catch (error) {
+    _index.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) {
+    _index.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.
+ */
+const Storage = exports.Storage = {
+  getItem,
+  setItem,
+  removeItem,
+  getJson,
+  setJson,
+  multiGet,
+  multiSet,
+  multiRemove,
+  clear,
+  getAllKeys
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=globals.d.js.map

package/lib/commonjs/utils/imageCompression.js

@@ -0,0 +1,389 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setImageCompressorImplementation = exports.qualityForFileSize = exports.compressImage = exports.ImageUnreadableError = void 0;
+var _expoFileSystem = require("expo-file-system");
+var _expoImageManipulator = require("expo-image-manipulator");
+var _index = require("../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. */
+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.
+ */
+exports.ImageUnreadableError = ImageUnreadableError;
+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 _expoFileSystem.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 _expoFileSystem.File(uri).delete();
+  },
+  open: async uri => {
+    const source = _expoImageManipulator.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 = _expoImageManipulator.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.
+ */
+const setImageCompressorImplementation = impl => {
+  backend = impl;
+};
+exports.setImageCompressorImplementation = setImageCompressorImplementation;
+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`).
+ */
+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;
+};
+exports.qualityForFileSize = qualityForFileSize;
+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`.
+ */
+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) {
+    _index.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;
+    }
+    _index.Logger.error('[imageCompression] encoding failed; uploading the original', error);
+    return originalResult(uri, sourceSize, baseName, {
+      width: image.width,
+      height: image.height
+    });
+  } finally {
+    image.close();
+  }
+};
+exports.compressImage = compressImage;
+//# sourceMappingURL=imageCompression.js.map

package/lib/commonjs/utils/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "compressImage", {
+  enumerable: true,
+  get: function () {
+    return _imageCompression.compressImage;
+  }
+});
+Object.defineProperty(exports, "setImageCompressorImplementation", {
+  enumerable: true,
+  get: function () {
+    return _imageCompression.setImageCompressorImplementation;
+  }
+});
+var _imageCompression = require("./imageCompression.js");
+//# sourceMappingURL=index.js.map