@rakomi/react-native 0.0.0 → 0.1.0

package/dist/native/index.js

@@ -0,0 +1,377 @@
+// src/native/bare-rn-example.ts
+function createBareRnAdapter(options) {
+  const servicePrefix = options.keychainServicePrefix ?? "rakomi";
+  const crypto = {
+    getRandomBytes: async (length) => new Uint8Array(options.quickCrypto.randomBytes(length)),
+    digestSha256: async (input) => new Uint8Array(options.quickCrypto.createHash("sha256").update(input).digest())
+  };
+  const storage = {
+    getItem: async (key, opts) => {
+      const result = await options.keychain.getGenericPassword({
+        service: `${servicePrefix}.${key}`,
+        ...opts?.requireAuthentication ? { authenticationPrompt: { title: opts.authenticationPrompt ?? "Authenticate" } } : {}
+      });
+      return result ? result.password : null;
+    },
+    setItem: async (key, value, opts) => {
+      await options.keychain.setGenericPassword("rakomi", value, {
+        service: `${servicePrefix}.${key}`,
+        accessible: opts?.keychainAccessible ?? "AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY"
+      });
+    },
+    removeItem: async (key) => {
+      await options.keychain.resetGenericPassword({ service: `${servicePrefix}.${key}` });
+    }
+  };
+  const browser = {
+    openAuthSession: async (authUrl, redirectUri, opts) => {
+      const available = await options.inAppBrowser.isAvailable();
+      if (!available) return { type: "locked" };
+      const result = await options.inAppBrowser.openAuth(authUrl, redirectUri, {
+        ephemeralWebSession: opts?.preferEphemeralSession ?? true
+      });
+      if (result.type === "success" && result.url) return { type: "success", url: result.url };
+      if (result.type === "cancel") return { type: "cancel" };
+      return { type: "dismiss" };
+    }
+  };
+  const deepLink = {
+    getInitialUrl: () => options.linking.getInitialURL(),
+    addListener: (listener) => options.linking.addEventListener("url", (e) => listener(e.url))
+  };
+  const biometric = {
+    isAvailable: async () => {
+      const sensor = await options.biometrics.isSensorAvailable();
+      return sensor.available;
+    },
+    authenticate: async ({ promptMessage }) => {
+      const result = await options.biometrics.simplePrompt({ promptMessage });
+      if (result.success) return { success: true };
+      return { success: false, reason: "cancelled" };
+    }
+  };
+  const appLifecycle = {
+    addStateChangeListener: (listener) => options.appState.addEventListener("change", listener),
+    getCurrent: () => options.appState.currentState
+  };
+  const connectivity = {
+    isConnected: async () => {
+      const state = await options.netInfo.fetch();
+      return state.isConnected === true;
+    },
+    addListener: (listener) => {
+      const unsub = options.netInfo.addEventListener((state) => listener(state.isConnected === true));
+      return { remove: unsub };
+    }
+  };
+  return {
+    crypto,
+    storage,
+    browser,
+    deepLink,
+    biometric,
+    appLifecycle,
+    connectivity
+  };
+}
+
+// src/native/dpop-prover.ts
+function createNativeDpopProver(options) {
+  const mod = options.module;
+  return {
+    async createProof(input) {
+      const proof = await mod.createDpopProof(input.htm, input.htu, input.nonce ?? null);
+      if (typeof proof !== "string" || proof.length === 0) {
+        throw new Error("native DPoP signer returned an empty proof");
+      }
+      return proof;
+    },
+    async jktHint() {
+      return mod.dpopJktThumbprint();
+    }
+  };
+}
+
+// src/native/expo-adapter.ts
+function createDefaultExpoAdapter(options = {}) {
+  const crypto = createExpoCrypto();
+  const storage = createExpoSecureStore({ tokenCache: options.tokenCache });
+  const browser = createExpoBrowser();
+  const deepLink = createExpoDeepLink();
+  const biometric = createExpoBiometricGate();
+  const appLifecycle = createRnAppLifecycle();
+  const connectivity = createNetInfoConnectivity();
+  return {
+    crypto,
+    storage,
+    browser,
+    deepLink,
+    biometric,
+    appLifecycle,
+    connectivity
+  };
+}
+function createExpoCrypto() {
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-crypto').catch(() => null);
+      if (!mod) {
+        throw new Error(
+          "@rakomi/react-native: expo-crypto is required for the default adapter. Install it (Expo-managed) or pass a custom nativeAdapter (bare RN)."
+        );
+      }
+    }
+    return mod;
+  }
+  return {
+    getRandomBytes: async (n) => {
+      const m = await load();
+      const result = await m.getRandomBytesAsync(n);
+      return new Uint8Array(result);
+    },
+    digestSha256: async (input) => {
+      const m = await load();
+      let str = "";
+      for (let i = 0; i < input.length; i++) str += String.fromCharCode(input[i]);
+      const hex = await m.digestStringAsync(
+        m.CryptoDigestAlgorithm.SHA256,
+        str,
+        { encoding: m.CryptoEncoding.HEX }
+      );
+      const bytes = new Uint8Array(hex.length / 2);
+      for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+      }
+      return bytes;
+    }
+  };
+}
+function createExpoSecureStore(opts) {
+  if (opts.tokenCache) {
+    const tc = opts.tokenCache;
+    return {
+      getItem: (key) => tc.getToken(key),
+      setItem: async (key, value) => {
+        await tc.saveToken(key, value);
+      },
+      removeItem: (key) => tc.clearToken(key)
+    };
+  }
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-secure-store').catch(() => null);
+      if (!mod) {
+        throw new Error(
+          "@rakomi/react-native: expo-secure-store is required for the default adapter. Install it (Expo-managed) or pass `tokenCache` / a custom nativeAdapter."
+        );
+      }
+    }
+    return mod;
+  }
+  return {
+    getItem: async (key, options) => {
+      const m = await load();
+      return m.getItemAsync(key, {
+        requireAuthentication: options?.requireAuthentication,
+        authenticationPrompt: options?.authenticationPrompt
+      });
+    },
+    setItem: async (key, value, options) => {
+      const m = await load();
+      const accessibility = mapKeychainAccessible(
+        m,
+        options?.keychainAccessible ?? "AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY"
+      );
+      await m.setItemAsync(key, value, {
+        keychainAccessible: accessibility,
+        requireAuthentication: options?.requireAuthentication,
+        authenticationPrompt: options?.authenticationPrompt
+      });
+    },
+    removeItem: async (key) => {
+      const m = await load();
+      await m.deleteItemAsync(key);
+    }
+  };
+}
+function mapKeychainAccessible(m, level) {
+  switch (level) {
+    case "WHEN_UNLOCKED":
+      return m.WHEN_UNLOCKED;
+    case "AFTER_FIRST_UNLOCK":
+      return m.AFTER_FIRST_UNLOCK;
+    case "WHEN_UNLOCKED_THIS_DEVICE_ONLY":
+      return m.WHEN_UNLOCKED_THIS_DEVICE_ONLY;
+    case "AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY":
+      return m.AFTER_FIRST_UNLOCK_THIS_DEVICE_ONLY;
+    case "WHEN_PASSCODE_SET_THIS_DEVICE_ONLY":
+      return m.WHEN_PASSCODE_SET_THIS_DEVICE_ONLY;
+  }
+}
+function createExpoBrowser() {
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-web-browser').catch(() => null);
+      if (!mod) {
+        throw new Error("@rakomi/react-native: expo-web-browser is required for OAuth flows.");
+      }
+    }
+    return mod;
+  }
+  return {
+    openAuthSession: async (authUrl, redirectUri, options) => {
+      const m = await load();
+      const result = await m.openAuthSessionAsync(authUrl, redirectUri, {
+        preferEphemeralSession: options?.preferEphemeralSession ?? true
+      });
+      if (result.type === "success" && result.url) {
+        return { type: "success", url: result.url };
+      }
+      if (result.type === "cancel") return { type: "cancel" };
+      if (result.type === "dismiss") return { type: "dismiss" };
+      if (result.type === "locked") return { type: "locked" };
+      return { type: "cancel" };
+    }
+  };
+}
+function createExpoDeepLink() {
+  let mod = null;
+  async function load() {
+    if (!mod) {
+      mod = await import('expo-linking').catch(() => null);
+      if (!mod) {
+        throw new Error("@rakomi/react-native: expo-linking is required for OAuth deep-link callback.");
+      }
+    }
+    return mod;
+  }
+  return {
+    getInitialUrl: async () => {
+      const m = await load();
+      return m.getInitialURL();
+    },
+    addListener: (listener) => {
+      let sub = null;
+      void load().then((m) => {
+        sub = m.addEventListener("url", (event) => listener(event.url));
+      });
+      return {
+        remove: () => {
+          sub?.remove();
+        }
+      };
+    }
+  };
+}
+function createExpoBiometricGate() {
+  let mod = null;
+  async function load() {
+    if (mod !== null) return mod;
+    try {
+      mod = await import('expo-local-authentication');
+    } catch {
+      mod = null;
+    }
+    return mod;
+  }
+  return {
+    isAvailable: async () => {
+      const m = await load();
+      if (!m) return false;
+      const has = await m.hasHardwareAsync();
+      if (!has) return false;
+      const enrolled = await m.isEnrolledAsync();
+      return enrolled;
+    },
+    authenticate: async ({ promptMessage, strict = false }) => {
+      const m = await load();
+      if (!m) return { success: false, reason: "unavailable" };
+      const result = await m.authenticateAsync({
+        promptMessage,
+        disableDeviceFallback: strict,
+        fallbackLabel: "Use passcode"
+      });
+      if (result.success) return { success: true };
+      switch (result.error) {
+        case "user_cancel":
+        case "system_cancel":
+        case "app_cancel":
+          return { success: false, reason: "cancelled" };
+        case "lockout":
+        case "lockout_permanent":
+          return { success: false, reason: "lockout" };
+        case "not_enrolled":
+          return { success: false, reason: "not_enrolled" };
+        case "not_available":
+        case "no_space":
+          return { success: false, reason: "unavailable" };
+        default:
+          return { success: false, reason: "unknown" };
+      }
+    }
+  };
+}
+function createRnAppLifecycle() {
+  let rn = null;
+  let pending = null;
+  async function ensure() {
+    if (rn) return rn;
+    if (!pending) {
+      pending = import('react-native').then((m) => {
+        rn = m.default ?? m;
+        return rn;
+      });
+    }
+    return pending;
+  }
+  void ensure().catch(() => void 0);
+  return {
+    addStateChangeListener: (listener) => {
+      let sub = null;
+      void ensure().then((r) => {
+        sub = r.AppState.addEventListener("change", (next) => {
+          listener(coerceAppState(next));
+        });
+      });
+      return { remove: () => sub?.remove() };
+    },
+    getCurrent: () => rn ? coerceAppState(rn.AppState.currentState) : "unknown"
+  };
+}
+function coerceAppState(value) {
+  if (value === "active" || value === "background" || value === "inactive") return value;
+  return "unknown";
+}
+function createNetInfoConnectivity() {
+  let mod = null;
+  async function load() {
+    if (mod !== null) return mod;
+    try {
+      mod = (await import('@react-native-community/netinfo')).default ?? null;
+    } catch {
+      mod = null;
+    }
+    return mod;
+  }
+  return {
+    isConnected: async () => {
+      const m = await load();
+      if (!m) return true;
+      const state = await m.fetch();
+      return state.isConnected ?? true;
+    },
+    addListener: (listener) => {
+      let unsubscribe = null;
+      void load().then((m) => {
+        if (!m) return;
+        unsubscribe = m.addEventListener((state) => listener(state.isConnected ?? true));
+      });
+      return { remove: () => unsubscribe?.() };
+    }
+  };
+}
+
+export { createBareRnAdapter, createDefaultExpoAdapter, createNativeDpopProver };

package/package.json

@@ -1,7 +1,98 @@
 {
   "name": "@rakomi/react-native",
-  "version": "0.0.0",
-  "description": "Reserved placeholder — first stable release published via OIDC provenance. Do not install.",
-  "license": "Apache-2.0",
-  "private": false
-}
+  "version": "0.1.0",
+  "description": "React Native / Expo SDK for Rakomi authentication.",
+  "keywords": [
+    "rakomi",
+    "authentication",
+    "auth",
+    "oauth",
+    "oidc",
+    "react-native",
+    "expo",
+    "sdk"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rakomidev/rakomi-js.git"
+  },
+  "bugs": {
+    "url": "https://github.com/rakomidev/rakomi-js/issues"
+  },
+  "homepage": "https://github.com/rakomidev/rakomi-js#readme",
+  "rakomi": {
+    "apiVersion": "2026-03-01"
+  },
+  "publishConfig": {
+    "provenance": true
+  },
+  "type": "module",
+  "license": "MIT",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./native": {
+      "import": {
+        "types": "./dist/native/index.d.ts",
+        "default": "./dist/native/index.js"
+      },
+      "require": {
+        "types": "./dist/native/index.d.cts",
+        "default": "./dist/native/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "author": "CRE8EVE Sp. z o.o.",
+  "files": [
+    "dist",
+    "!dist/metafile-*.json",
+    "README.md",
+    "LICENSE",
+    "SECURITY.md",
+    "COMPLIANCE.md",
+    "THIRD-PARTY-NOTICES",
+    "sbom.cdx.json"
+  ],
+  "peerDependencies": {
+    "expo": ">=54",
+    "react": ">=18",
+    "react-native": ">=0.81"
+  },
+  "peerDependenciesMeta": {
+    "expo": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": false
+    },
+    "react": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@rakomi/react": "0.1.0"
+  },
+  "dependencies": {
+    "jose": "^6.2.3",
+    "@rakomi/sdk-core": "^0.1.0"
+  },
+  "scripts": {
+    "build": "NODE_OPTIONS=--max-old-space-size=4096 tsup",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.typetest.json",
+    "lint": "eslint src/ test/ --max-warnings=0",
+    "test": "vitest run"
+  }
+}

package/sbom.cdx.json

@@ -0,0 +1,66 @@
+{
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.6",
+  "version": 1,
+  "metadata": {
+    "authors": [
+      {
+        "name": "CRE8EVE"
+      }
+    ],
+    "tools": {
+      "components": [
+        {
+          "type": "application",
+          "group": "rakomi",
+          "name": "generate-sbom",
+          "version": "sha256:6612f58a07b8"
+        }
+      ]
+    },
+    "component": {
+      "type": "library",
+      "bom-ref": "pkg:npm/%40rakomi%2Freact-native@0.1.0",
+      "name": "@rakomi/react-native",
+      "version": "0.1.0",
+      "purl": "pkg:npm/%40rakomi%2Freact-native@0.1.0",
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    }
+  },
+  "components": [
+    {
+      "type": "library",
+      "bom-ref": "pkg:npm/@rakomi/sdk-core@0.1.0",
+      "name": "@rakomi/sdk-core",
+      "version": "0.1.0",
+      "purl": "pkg:npm/@rakomi/sdk-core@0.1.0",
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "pkg:npm/jose@6.2.3",
+      "name": "jose",
+      "version": "6.2.3",
+      "purl": "pkg:npm/jose@6.2.3",
+      "licenses": [
+        {
+          "license": {
+            "id": "MIT"
+          }
+        }
+      ]
+    }
+  ]
+}