@wayq/beekon-rn 0.0.6 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wayq/beekon-rn",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "React Native binding for the Beekon location SDK (Android + iOS).",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -38,7 +38,8 @@
     "fetch-beekonkit": "bash scripts/fetch-beekonkit.sh",
     "prepare": "yarn fetch-beekonkit && bob build",
     "typecheck": "tsc",
-    "lint": "eslint \"**/*.{js,ts,tsx}\""
+    "lint": "eslint \"**/*.{js,ts,tsx}\"",
+    "test": "jest"
   },
   "keywords": [
     "react-native",
@@ -75,12 +76,15 @@
     "@eslint/js": "^10.0.1",
     "@react-native/babel-preset": "0.85.0",
     "@react-native/eslint-config": "0.85.0",
+    "@types/jest": "^29.5.14",
     "@types/react": "^19.2.0",
+    "babel-jest": "^29.7.0",
     "del-cli": "^7.0.0",
     "eslint": "^9.39.4",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-ft-flow": "^3.0.11",
     "eslint-plugin-prettier": "^5.5.5",
+    "jest": "^29.7.0",
     "prettier": "^3.8.1",
     "react": "19.2.3",
     "react-native": "0.85.0",

package/scripts/fetch-beekonkit.sh

@@ -13,12 +13,12 @@
 
 set -euo pipefail
 
-VERSION="0.0.6"
+VERSION="0.0.7"
 URL="https://github.com/wayqteam/beekon-ios-binary/releases/download/v${VERSION}/BeekonKit.xcframework.zip"
-# SHA256 of the v0.0.6 BeekonKit.xcframework.zip. Matches the SwiftPM
-# `binaryTarget` checksum in beekon-ios-binary's Package.swift at tag v0.0.6
+# SHA256 of the v0.0.7 BeekonKit.xcframework.zip. Matches the SwiftPM
+# `binaryTarget` checksum in beekon-ios-binary's Package.swift at tag v0.0.7
 # (SwiftPM's compute-checksum is the SHA256 of the zip).
-EXPECTED_SHA="eb0cd87c869cdbce5374569efa2d47f0f7e6c01ce18461c0653ef701163cf343"
+EXPECTED_SHA="48803b540f063f609230f44a0f5b7faca125847db9f4628d0bf5d31d351a762b"
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 DEST_DIR="${ROOT}/ios/Frameworks"

package/src/NativeBeekonRn.ts

@@ -84,6 +84,13 @@ export type WireConfig = {
   sync?: WireSyncConfig;
   /** Android-only; the iOS native module ignores it. */
   notification?: WireNotificationConfig;
+  /**
+   * License token (license-format-v1 §9). Omitted/`undefined` means unset — the
+   * native SDK falls through to the manifest / Info.plist. The wrapper passes it
+   * through verbatim (no trimming or fallback). `configure` crosses as an untyped
+   * object, so this field documents the shape rather than altering codegen.
+   */
+  licenseKey?: string;
 };
 
 export type WireLocation = {
@@ -153,6 +160,29 @@ export type WireAuthTokens = {
   epoch: number;
 };
 
+/**
+ * Flat wire form of the current platform's native license status
+ * (license-format-v1 §8). `status` is the wire-stable identifier; `tier` and
+ * `entitlements` are populated only when `status === 'licensed'` (null / empty
+ * otherwise), and `reason` only when `status === 'invalid'`.
+ */
+export type WireLicenseStatus = {
+  /**
+   * One of: 'notDetermined' | 'licensed' | 'evaluation' | 'expired' |
+   * 'updateEntitlementLapsed' | 'invalid'.
+   */
+  status: string;
+  /** The opaque pricing tier; `null` unless `status === 'licensed'`. */
+  tier: string | null;
+  /** Opaque feature-gate strings; empty unless `status === 'licensed'`. */
+  entitlements: string[];
+  /**
+   * `null` unless `status === 'invalid'`. One of: 'malformed' | 'unknownKey' |
+   * 'badSignature' | 'appIdMismatch' | 'productMismatch' | 'unsupportedVersion'.
+   */
+  reason: string | null;
+};
+
 export interface Spec extends TurboModule {
   /**
    * The config crosses as an untyped object (`ReadableMap` on Android,
@@ -195,11 +225,19 @@ export interface Spec extends TurboModule {
   removeGeofences(ids: string[]): Promise<void>;
   listGeofences(): Promise<WireGeofence[]>;
 
+  /**
+   * The current platform's native license status (license-format-v1 §8). Each
+   * native SDK validates independently; this reflects only the platform you are
+   * running on — no cross-platform merging.
+   */
+  licenseStatus(): Promise<WireLicenseStatus>;
+
   readonly onState: CodegenTypes.EventEmitter<WireState>;
   readonly onLocation: CodegenTypes.EventEmitter<WireLocation>;
   readonly onGeofenceEvent: CodegenTypes.EventEmitter<WireGeofenceEvent>;
   readonly onSyncStatus: CodegenTypes.EventEmitter<WireSyncStatus>;
   readonly onAuthTokens: CodegenTypes.EventEmitter<WireAuthTokens>;
+  readonly onLicenseStatus: CodegenTypes.EventEmitter<WireLicenseStatus>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('BeekonRn');

package/src/beekon.ts

@@ -3,6 +3,7 @@ import type { AuthTokens } from './types/auth';
 import type { BeekonConfig } from './types/config';
 import type { AccuracyMode } from './types/enums';
 import type { BeekonGeofence, GeofenceEvent } from './types/geofence';
+import type { LicenseStatus } from './types/license';
 import type { Location } from './types/location';
 import type { BeekonState } from './types/state';
 import type { SyncStatus } from './types/sync';
@@ -14,6 +15,7 @@ import {
   wireToAuthTokens,
   wireToGeofence,
   wireToGeofenceEvent,
+  wireToLicenseStatus,
   wireToLocation,
   wireToState,
   wireToSyncStatus,
@@ -39,9 +41,11 @@ class EventHub {
   private readonly geofenceListeners = new Set<Listener<GeofenceEvent>>();
   private readonly syncListeners = new Set<Listener<SyncStatus>>();
   private readonly authTokenListeners = new Set<Listener<AuthTokens>>();
+  private readonly licenseListeners = new Set<Listener<LicenseStatus>>();
   private lastState: BeekonState | undefined;
   private lastSyncStatus: SyncStatus | undefined;
   private lastAuthTokens: AuthTokens | undefined;
+  private lastLicenseStatus: LicenseStatus | undefined;
 
   /** Idempotent: opens the native subscriptions the first time it is called. */
   ensureSubscribed(): void {
@@ -70,6 +74,11 @@ class EventHub {
       this.lastAuthTokens = t;
       this.authTokenListeners.forEach((cb) => cb(t));
     });
+    NativeBeekon.onLicenseStatus((w) => {
+      const s = wireToLicenseStatus(w);
+      this.lastLicenseStatus = s;
+      this.licenseListeners.forEach((cb) => cb(s));
+    });
   }
 
   onState(cb: Listener<BeekonState>): () => void {
@@ -114,6 +123,15 @@ class EventHub {
       this.authTokenListeners.delete(cb);
     };
   }
+
+  onLicenseStatus(cb: Listener<LicenseStatus>): () => void {
+    this.ensureSubscribed();
+    this.licenseListeners.add(cb);
+    if (this.lastLicenseStatus !== undefined) cb(this.lastLicenseStatus);
+    return () => {
+      this.licenseListeners.delete(cb);
+    };
+  }
 }
 
 /**
@@ -293,6 +311,16 @@ class BeekonImpl {
     return wires.map(wireToGeofence);
   }
 
+  /**
+   * The current platform's license status (license-format-v1 §8). Android and
+   * iOS validate independently — this reflects the platform you are running on,
+   * with no cross-platform merging. Purely observational: a license never blocks,
+   * degrades, or delays the SDK. For live transitions use {@link onLicenseStatus}.
+   */
+  async licenseStatus(): Promise<LicenseStatus> {
+    return wireToLicenseStatus(await NativeBeekon.licenseStatus());
+  }
+
   /**
    * Subscribe to tracking-state transitions (`idle` / `tracking` /
    * `stopped(reason)`). The current state is delivered to new subscribers
@@ -337,6 +365,16 @@ class BeekonImpl {
   onAuthTokens(cb: (t: AuthTokens) => void): () => void {
     return this.hub.onAuthTokens(cb);
   }
+
+  /**
+   * Subscribe to license-status transitions for the current platform
+   * (license-format-v1 §8). The current status is delivered to new subscribers
+   * immediately (replay-1), then again on each transition (the first validation
+   * is lazy). Purely observational. Returns an unsubscribe function.
+   */
+  onLicenseStatus(cb: (s: LicenseStatus) => void): () => void {
+    return this.hub.onLicenseStatus(cb);
+  }
 }
 
 export const Beekon = new BeekonImpl();

package/src/index.tsx

@@ -24,4 +24,5 @@ export type {
 } from './types/geofence';
 export type { BeekonState, StopReason } from './types/state';
 export type { SyncStatus, SyncFailure } from './types/sync';
+export type { LicenseStatus, LicenseInvalidReason } from './types/license';
 export { BeekonError, type BeekonErrorKind } from './types/error';

package/src/internal/mappers.ts

@@ -15,6 +15,7 @@ import type {
   GeofenceEvent,
   Transition,
 } from '../types/geofence';
+import type { LicenseInvalidReason, LicenseStatus } from '../types/license';
 import type { Location } from '../types/location';
 import type { BeekonState, StopReason } from '../types/state';
 import type { SyncFailure, SyncStatus } from '../types/sync';
@@ -26,6 +27,7 @@ import type {
   WireGeofence,
   WireGeofenceEvent,
   WireKeyValue,
+  WireLicenseStatus,
   WireLocation,
   WireState,
   WireSyncStatus,
@@ -90,6 +92,10 @@ export function configToWire(config: BeekonConfig): WireConfig {
           smallIcon: config.notification.smallIcon,
         }
       : undefined,
+    // Passed through verbatim — `undefined` is omitted and the native SDK falls
+    // through to manifest/Info.plist. No wrapper-side trimming or fallback
+    // (blank/whitespace handling lives in the native SDK; spec §9).
+    licenseKey: config.licenseKey,
   };
 }
 
@@ -232,6 +238,50 @@ export function wireToAuthTokens(w: WireAuthTokens): AuthTokens {
   };
 }
 
+/**
+ * Decode the wire-stable license status into the public discriminated union. The
+ * native side already decided the status (the wrapper performs no validation) —
+ * this only re-shapes the flat wire form and validates the enum strings.
+ */
+export function wireToLicenseStatus(w: WireLicenseStatus): LicenseStatus {
+  switch (w.status) {
+    case 'licensed':
+      return {
+        status: 'licensed',
+        tier: w.tier ?? '',
+        entitlements: w.entitlements ?? [],
+      };
+    case 'invalid':
+      return {
+        status: 'invalid',
+        reason: oneOf<LicenseInvalidReason>(
+          w.reason,
+          [
+            'malformed',
+            'unknownKey',
+            'badSignature',
+            'appIdMismatch',
+            'productMismatch',
+            'unsupportedVersion',
+          ],
+          'malformed'
+        ),
+      };
+    case 'evaluation':
+      return { status: 'evaluation' };
+    case 'expired':
+      return { status: 'expired' };
+    case 'updateEntitlementLapsed':
+      return { status: 'updateEntitlementLapsed' };
+    case 'notDetermined':
+      return { status: 'notDetermined' };
+    default:
+      // Forward-compat: an unknown status string means a native build newer than
+      // this wrapper — surface as notDetermined rather than throwing.
+      return { status: 'notDetermined' };
+  }
+}
+
 function toStopReason(s: string | undefined): StopReason {
   return oneOf<StopReason>(
     s,

package/src/types/config.ts

@@ -78,4 +78,17 @@ export type BeekonConfig = {
   sync?: SyncConfig;
   /** Android-only notification overrides. Ignored on iOS. */
   notification?: NotificationConfig;
+  /**
+   * Beekon license token (a `license-format-v1` JWS). The **highest-priority**
+   * supply channel (spec §9): it overrides the platform manifest value
+   * (`in.wayq.beekon.license` meta-data on Android, `BeekonLicenseKey` in
+   * `Info.plist` on iOS). `undefined`, blank, or whitespace-only means unset —
+   * the SDK falls through to the manifest, then to evaluation mode.
+   *
+   * The license **never blocks** the SDK; observe the outcome via
+   * {@link Beekon.licenseStatus} / {@link Beekon.onLicenseStatus}. Safe to commit
+   * to source control: a token is app-id-bound and product-bound, so it is
+   * useless to anyone else. Default: unset.
+   */
+  licenseKey?: string;
 };

package/src/types/license.ts

@@ -0,0 +1,47 @@
+/**
+ * Why an invalid license token failed verification (license-format-v1 §8.1).
+ * These are the exact wire-stable identifiers — the string names *are* the
+ * contract, shared verbatim with both native SDKs.
+ *
+ * - `'malformed'` — unparseable: bad encoding, structure, header, or claim types.
+ * - `'unknownKey'` — signed with a key this SDK build does not embed (update the SDK).
+ * - `'badSignature'` — the ES256 signature does not verify.
+ * - `'appIdMismatch'` — the license does not cover this application id.
+ * - `'productMismatch'` — the license does not cover this framework (here, `rn`).
+ * - `'unsupportedVersion'` — the token's claim schema is newer than this SDK understands.
+ */
+export type LicenseInvalidReason =
+  | 'malformed'
+  | 'unknownKey'
+  | 'badSignature'
+  | 'appIdMismatch'
+  | 'productMismatch'
+  | 'unsupportedVersion';
+
+/**
+ * License verification status for the **current platform** (license-format-v1
+ * §8). Purely observational — no status ever blocks, degrades, or delays the
+ * SDK. Use the `status` field as a discriminator.
+ *
+ * - `'notDetermined'` — before the first (lazy) validation completes.
+ * - `'evaluation'` — no license key supplied through any channel; running free.
+ * - `'expired'` — the license's expiry has passed.
+ * - `'updateEntitlementLapsed'` — this SDK build is newer than the license's
+ *   covered update window. Still fully functional; renew to cover newer releases.
+ * - `'licensed'` — a valid license covering this app, framework, and SDK release;
+ *   carries the opaque `tier` and `entitlements` (empty when the token carried none).
+ * - `'invalid'` — verification failed; see {@link LicenseInvalidReason}.
+ *
+ * **Platform divergence is legal** (spec §8.2): Android and iOS validate
+ * independently, so for one app the two platforms may report different statuses
+ * (e.g. a license scoped to `["android"]` reads `licensed` on Android and
+ * `invalid` / `productMismatch` on iOS). This value reflects only the platform
+ * you are running on; the wrapper never merges across platforms.
+ */
+export type LicenseStatus =
+  | { status: 'notDetermined' }
+  | { status: 'evaluation' }
+  | { status: 'expired' }
+  | { status: 'updateEntitlementLapsed' }
+  | { status: 'licensed'; tier: string; entitlements: string[] }
+  | { status: 'invalid'; reason: LicenseInvalidReason };