@webority-technologies/mobile-core 0.0.1 → 0.0.3

package/lib/commonjs/auth/jwt.js

@@ -14,16 +14,40 @@ const base64UrlToBase64 = input => {
   const padded = input + '='.repeat((4 - input.length % 4) % 4);
   return padded.replace(/-/g, '+').replace(/_/g, '/');
 };
-const decodeBase64 = input => {
-  // RN runtimes expose `atob` (Hermes 0.71+); fall back to a Buffer-based decode otherwise.
-  if (typeof atob === 'function') {
-    return atob(input);
+const BASE64_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+/**
+ * Pure-JS base64, used only when the runtime has no `atob`.
+ *
+ * This used to be `require('buffer')`. That was a latent bundling failure for
+ * every consumer: `buffer` is a Node builtin that React Native does not
+ * provide, it was never declared as a dependency, and Metro resolves requires
+ * STATICALLY — so sitting inside an unreached fallback branch did not save it.
+ * The app still failed to bundle, with an error naming this file. It only went
+ * unnoticed because the repo's own checks never bundle for a device.
+ *
+ * Decoding four base64 characters yields three bytes; the padding tells us how
+ * many of those three are real.
+ */
+const decodeBase64Fallback = input => {
+  let out = '';
+  for (let i = 0; i < input.length; i += 4) {
+    const chunk = [0, 1, 2, 3].map(offset => BASE64_ALPHABET.indexOf(input[i + offset] ?? '='));
+    const bits = Math.max(chunk[0], 0) << 18 | Math.max(chunk[1], 0) << 12 | Math.max(chunk[2], 0) << 6 | Math.max(chunk[3], 0);
+    out += String.fromCharCode(bits >> 16 & 0xff);
+    if (chunk[2] !== -1) {
+      out += String.fromCharCode(bits >> 8 & 0xff);
+    }
+    if (chunk[3] !== -1) {
+      out += String.fromCharCode(bits & 0xff);
+    }
   }
-  const {
-    Buffer
-  } = require('buffer');
-  return Buffer.from(input, 'base64').toString('utf-8');
+  return out;
 };
+const decodeBase64 = input =>
+// Every RN runtime the library supports has `atob` (Hermes 0.71+), so the
+// fallback is a safety net rather than a path anyone is expected to take.
+typeof atob === 'function' ? atob(input) : decodeBase64Fallback(input);
 const utf8FromBinary = binary => {
   // Convert percent-encoded UTF-8 sequence so multi-byte chars survive.
   try {

package/lib/commonjs/config/index.js

@@ -18,7 +18,8 @@ const DEFAULT_CONFIG = {
   environment: 'Development',
   country: 'in',
   appId: null,
-  appVersion: null
+  appVersion: null,
+  logCurl: false
 };
 let globalConfig = {
   ...DEFAULT_CONFIG

package/lib/commonjs/deepLink/index.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useDeepLink = exports.parseDeepLink = exports.DeepLink = void 0;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _index = require("../logger/index.js");
+const PREFIX = '[@webority-technologies/mobile-core]';
+const decodeSafe = value => {
+  try {
+    return decodeURIComponent(value.replace(/\+/g, ' '));
+  } catch {
+    return value;
+  }
+};
+const parseQuery = raw => {
+  const out = {};
+  if (!raw) {
+    return out;
+  }
+  for (const pair of raw.split('&')) {
+    if (!pair) {
+      continue;
+    }
+    const eq = pair.indexOf('=');
+    const key = decodeSafe(eq >= 0 ? pair.slice(0, eq) : pair);
+    if (!key) {
+      continue;
+    }
+    out[key] = eq >= 0 ? decodeSafe(pair.slice(eq + 1)) : '';
+  }
+  return out;
+};
+const trimSlashes = value => value.replace(/^\/+/, '').replace(/\/+$/, '');
+
+/**
+ * Parse a deep-link URL. Returns null for anything that is not a usable URL so
+ * a hostile or truncated link can never throw on the native event path.
+ */
+const parseDeepLink = url => {
+  if (typeof url !== 'string') {
+    return null;
+  }
+  const trimmed = url.trim();
+  if (!trimmed || /\s/.test(trimmed)) {
+    return null;
+  }
+  const withoutFragment = trimmed.split('#')[0] ?? '';
+  const schemeEnd = withoutFragment.indexOf('://');
+  let scheme = '';
+  let rest = withoutFragment;
+  if (schemeEnd >= 0) {
+    const rawScheme = withoutFragment.slice(0, schemeEnd);
+    if (!/^[a-zA-Z][a-zA-Z0-9+.-]*$/.test(rawScheme)) {
+      return null;
+    }
+    scheme = rawScheme.toLowerCase();
+    rest = withoutFragment.slice(schemeEnd + 3);
+  }
+  const queryStart = rest.indexOf('?');
+  const rawPath = queryStart >= 0 ? rest.slice(0, queryStart) : rest;
+  const query = parseQuery(queryStart >= 0 ? rest.slice(queryStart + 1) : '');
+  let host = '';
+  let pathPart = rawPath;
+  if (scheme === 'http' || scheme === 'https') {
+    const slash = rawPath.indexOf('/');
+    host = slash >= 0 ? rawPath.slice(0, slash) : rawPath;
+    pathPart = slash >= 0 ? rawPath.slice(slash + 1) : '';
+  }
+  const path = trimSlashes(pathPart);
+  const segments = path ? path.split('/').filter(Boolean) : [];
+  if (scheme && scheme !== 'http' && scheme !== 'https') {
+    host = segments[0] ?? '';
+  }
+  return {
+    url: trimmed,
+    scheme,
+    host,
+    path,
+    segments,
+    query
+  };
+};
+exports.parseDeepLink = parseDeepLink;
+const matchPattern = (pattern, segments) => {
+  const patternSegments = trimSlashes(pattern).split('/').filter(Boolean);
+  if (patternSegments.length !== segments.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i += 1) {
+    const p = patternSegments[i];
+    const s = segments[i];
+    if (p.startsWith(':')) {
+      const name = p.slice(1);
+      if (!name) {
+        return null;
+      }
+      params[name] = s;
+    } else if (p.toLowerCase() !== s.toLowerCase()) {
+      return null;
+    }
+  }
+  return params;
+};
+const matchRegExp = (pattern, path) => {
+  // A /g or /y pattern carries lastIndex between calls, so the same link would
+  // match on one dispatch and miss on the next.
+  if (pattern.global || pattern.sticky) {
+    pattern.lastIndex = 0;
+  }
+  const result = pattern.exec(path);
+  if (!result) {
+    return null;
+  }
+  const params = {};
+  for (let i = 1; i < result.length; i += 1) {
+    const group = result[i];
+    if (group !== undefined) {
+      params[String(i)] = group;
+    }
+  }
+  for (const [name, value] of Object.entries(result.groups ?? {})) {
+    if (value !== undefined) {
+      params[name] = value;
+    }
+  }
+  return params;
+};
+const matchRoute = (routes, link) => {
+  for (const route of routes) {
+    const params = typeof route.match === 'string' ? matchPattern(route.match, link.segments) : matchRegExp(route.match, link.path);
+    if (params) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+};
+let config = null;
+let subscription = null;
+let started = false;
+let pending = null;
+let readyOverride = null;
+const isReady = () => {
+  if (readyOverride !== null) {
+    return readyOverride;
+  }
+  return config?.isReady?.() ?? true;
+};
+const isAuthenticated = () => config?.isAuthenticated?.() ?? true;
+const dispatch = link => {
+  const active = config;
+  if (!active) {
+    return;
+  }
+  const matched = matchRoute(active.routes, link);
+  if (!matched) {
+    active.onUnmatched?.(link);
+    return;
+  }
+  if (matched.route.requiresAuth && !isAuthenticated()) {
+    pending = link;
+    active.onUnauthenticated?.(link);
+    return;
+  }
+  matched.route.handler(link, matched.params);
+};
+const flushPending = () => {
+  const link = pending;
+  if (!link) {
+    return;
+  }
+  // Cleared BEFORE dispatch: a handler that navigates can re-enter this path,
+  // and a link that fires twice is the classic deep-link duplicate-screen bug.
+  pending = null;
+  dispatch(link);
+};
+const configure = next => {
+  if (!next || !Array.isArray(next.routes)) {
+    throw new Error(`${PREFIX} DeepLink.configure() needs a config object with a "routes" array. ` + 'Pass { routes: [{ match: "order/:id", handler }] }.');
+  }
+  config = next;
+};
+const handleUrl = url => {
+  if (!config) {
+    _index.Logger.error(`${PREFIX} DeepLink received a URL before configure() was called; the link was dropped. ` + 'Call DeepLink.configure({ routes }) (or useDeepLink) during app start.');
+    return;
+  }
+  const parsed = parseDeepLink(url);
+  // A malformed URL still reaches the app through onUnmatched, with the raw
+  // value in `url`, rather than vanishing.
+  if (!parsed) {
+    config.onUnmatched?.({
+      url: typeof url === 'string' ? url : '',
+      scheme: '',
+      host: '',
+      path: '',
+      segments: [],
+      query: {}
+    });
+    return;
+  }
+  const link = parsed;
+  if (!isReady()) {
+    pending = link;
+    return;
+  }
+  dispatch(link);
+};
+const start = async () => {
+  if (!config) {
+    throw new Error(`${PREFIX} DeepLink.start() was called before configure(). ` + 'Call DeepLink.configure({ routes }) first, or use the useDeepLink() hook.');
+  }
+  if (started) {
+    return;
+  }
+  started = true;
+  // Subscribe before reading the cold-start URL so a link arriving during the
+  // await is not lost.
+  subscription = _reactNative.Linking.addEventListener('url', event => {
+    handleUrl(event.url);
+  });
+  try {
+    const initial = await _reactNative.Linking.getInitialURL();
+    if (initial) {
+      handleUrl(initial);
+    }
+  } catch (error) {
+    _index.Logger.error(`${PREFIX} DeepLink could not read the cold-start URL`, error);
+  }
+};
+const stop = () => {
+  subscription?.remove?.();
+  subscription = null;
+  started = false;
+  pending = null;
+  readyOverride = null;
+};
+const setReady = ready => {
+  readyOverride = ready;
+  if (ready) {
+    flushPending();
+  }
+};
+const DeepLink = exports.DeepLink = {
+  configure,
+  start,
+  stop,
+  handleUrl,
+  setReady,
+  /** Replay the stashed link, once. Call after a successful login. */
+  replayPending: flushPending,
+  getPending: () => pending
+};
+
+/**
+ * Configure and start the deep-link service for the lifetime of a component.
+ * The stored config delegates to the latest render, so new route closures do
+ * not tear down and re-subscribe the native listener.
+ */
+const useDeepLink = deepLinkConfig => {
+  const configRef = (0, _react.useRef)(deepLinkConfig);
+  configRef.current = deepLinkConfig;
+  (0, _react.useEffect)(() => {
+    DeepLink.configure({
+      get routes() {
+        return configRef.current.routes;
+      },
+      isReady: () => configRef.current.isReady?.() ?? true,
+      isAuthenticated: () => configRef.current.isAuthenticated?.() ?? true,
+      onUnauthenticated: link => configRef.current.onUnauthenticated?.(link),
+      onUnmatched: link => configRef.current.onUnmatched?.(link)
+    });
+    void DeepLink.start();
+    return () => {
+      DeepLink.stop();
+    };
+  }, []);
+};
+exports.useDeepLink = useDeepLink;
+//# sourceMappingURL=index.js.map

package/lib/commonjs/download/adapters/expoFs.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.adaptExpoFileSystem = void 0;
+/**
+ * expo-file-system. Shape verified against 57.0.6, where the legacy function
+ * API (`downloadAsync`, `getInfoAsync`) still exists on the main entry point
+ * but every one of those functions THROWS at runtime; they now live behind
+ * `expo-file-system/legacy`. This adapter therefore uses the class API only.
+ *
+ * The REQUIRE lives in the entry point beside this file, never here.
+ */
+
+/**
+ * expo reports a directory as a URI with a trailing slash, and the download
+ * module joins a directory to a file name with a `/` of its own.
+ */
+const asDirectoryPath = uri => uri.replace(/\/+$/, '');
+
+/**
+ * expo REJECTS a non-2xx download rather than resolving a status, and the two
+ * platforms word it differently: iOS "server returned HTTP 404", Android
+ * "HTTP 404", and the non-task download path "response has status: 404".
+ * Recovering the code is what lets the download module report `http-error` with
+ * a status rather than a bare `network` failure. A future wording change
+ * degrades to `network`, never to a wrong status.
+ */
+const HTTP_STATUS = /(?:HTTP|status)\s*:?\s*(\d{3})\b/i;
+const statusFrom = error => {
+  const message = error instanceof Error ? error.message : String(error);
+  const match = HTTP_STATUS.exec(message);
+  return match ? Number(match[1]) : undefined;
+};
+const adaptExpoFileSystem = mod => {
+  const lib = mod?.default ?? mod;
+  if (typeof lib?.File !== 'function' || typeof lib.File.createDownloadTask !== 'function') {
+    return null;
+  }
+  const {
+    File,
+    Directory,
+    Paths
+  } = lib;
+  const documents = asDirectoryPath(Paths.document.uri);
+  return {
+    dirs: {
+      documents,
+      cache: asDirectoryPath(Paths.cache.uri),
+      // expo exposes no public Downloads directory, so a "downloads" request
+      // lands in the app's documents directory instead of the shared folder.
+      downloads: documents
+    },
+    download: ({
+      url,
+      path,
+      headers,
+      onProgress
+    }) => {
+      const task = File.createDownloadTask(url, new File(path), {
+        headers,
+        onProgress: onProgress ? progress => onProgress(progress.bytesWritten, progress.totalBytes) : undefined
+      });
+      return {
+        promise: task.downloadAsync().then(file => ({
+          bytes: file?.size
+        }), error => {
+          const status = statusFrom(error);
+          if (status === undefined) {
+            throw error;
+          }
+          return {
+            status
+          };
+        }),
+        cancel: () => task.cancel()
+      };
+    },
+    exists: path => Promise.resolve(new File(path).exists),
+    stat: path => Promise.resolve({
+      size: new File(path).size
+    }),
+    unlink: path => {
+      new File(path).delete();
+      return Promise.resolve();
+    },
+    // The download module calls this for a directory that usually already
+    // exists, so it must be idempotent rather than throw on the second run.
+    mkdir: path => {
+      new Directory(path).create({
+        intermediates: true,
+        idempotent: true
+      });
+      return Promise.resolve();
+    }
+  };
+};
+exports.adaptExpoFileSystem = adaptExpoFileSystem;
+//# sourceMappingURL=expoFs.js.map

package/lib/commonjs/download/adapters/shared.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asNumber = void 0;
+/** Coerce a driver-supplied size, which some report as a string. */
+const asNumber = value => {
+  const n = typeof value === 'number' ? value : Number(value);
+  return Number.isFinite(n) ? n : 0;
+};
+exports.asNumber = asNumber;
+//# sourceMappingURL=shared.js.map