@layers/amba-web 1.0.1 → 1.0.2

package/dist-rn/index.js

@@ -0,0 +1,488 @@
+import init, { AmbaCoreWasm } from "@layers/amba-core";
+
+//#region src/storage-adapter.ts
+/**
+* Browser localStorage adapter for SDK identity persistence.
+*
+* The SDK runtime currently re-seeds an `anonymous_id` on every page load.
+* This adapter is the documented home for storage-prefix handling so
+* customers can override the localStorage key prefix used by the
+* (eventual) identity cache.
+*/
+var LocalStoragePersistence = class {
+	constructor(prefix) {
+		this.prefix = prefix;
+	}
+	/** Read everything we'd want to hydrate at init. No-op until wired through. */
+	hydrate() {}
+	read(key) {
+		if (typeof localStorage === "undefined") return null;
+		return localStorage.getItem(`${this.prefix}:${key}`);
+	}
+	write(key, value) {
+		if (typeof localStorage === "undefined") return;
+		localStorage.setItem(`${this.prefix}:${key}`, value);
+	}
+	delete(key) {
+		if (typeof localStorage === "undefined") return;
+		localStorage.removeItem(`${this.prefix}:${key}`);
+	}
+};
+
+//#endregion
+//#region src/json.ts
+/**
+* JSON encode helper — guarantees stable serialization across browser
+* runtimes and provides a single hook for future schema validation.
+*/
+function encodeJson(value) {
+	return JSON.stringify(value);
+}
+
+//#endregion
+//#region src/error.ts
+var AmbaApiError = class extends Error {
+	code;
+	details;
+	constructor(code, message, details) {
+		super(message);
+		this.name = "AmbaApiError";
+		this.code = code;
+		this.details = details;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
+};
+/**
+* Best-effort: pull a stable error code out of a Rust `AmbaError`
+* Display string. Used by `toAmbaApiError` when the underlying thrown
+* value is a generic `Error` produced by `wasm-bindgen`'s `JsError::new`.
+*
+* Keep in sync with `sdks/core/src/error.rs::AmbaError`'s `#[error]`
+* format strings — but the parser falls back to UNKNOWN_ERROR for any
+* pattern it doesn't recognize, so a stale match list isn't a footgun,
+* just a quality-of-life regression.
+*/
+function codeFromMessage(message) {
+	if (message.startsWith("Unauthorized")) return "UNAUTHORIZED";
+	if (message.startsWith("Forbidden")) return "FORBIDDEN";
+	if (message.startsWith("Not found")) return "NOT_FOUND";
+	if (message.startsWith("Conflict")) return "CONFLICT";
+	if (message.startsWith("Rate limited")) return "RATE_LIMITED";
+	if (message.startsWith("Validation error")) return "VALIDATION_ERROR";
+	if (message.startsWith("Network error")) return "NETWORK_ERROR";
+	if (message.startsWith("HTTP error")) return "HTTP_ERROR";
+	if (message.startsWith("Circuit breaker")) return "CIRCUIT_OPEN";
+	if (message.startsWith("Consent not granted")) return "CONSENT_NOT_GRANTED";
+	if (message.includes("not initialized")) return "NOT_INITIALIZED";
+	if (message.startsWith("Invalid configuration")) return "INVALID_CONFIG";
+	if (message.startsWith("Invalid argument")) return "INVALID_ARGUMENT";
+	return "UNKNOWN_ERROR";
+}
+/**
+* Coerce any thrown value into an `AmbaApiError`. Idempotent — passing
+* an existing `AmbaApiError` returns it unchanged so wrappers can stack
+* without re-wrapping.
+*
+* Heuristics:
+* 1. Existing `AmbaApiError` → returned as-is.
+* 2. Object with `.code` → use that code + `.message` + `.details`.
+* 3. `Error` (e.g. runtime-emitted error) → infer code from message prefix.
+* 4. Anything else → stringify and tag UNKNOWN_ERROR.
+*/
+function toAmbaApiError(err) {
+	if (err instanceof AmbaApiError) return err;
+	if (err && typeof err === "object") {
+		const obj = err;
+		if (typeof obj.code === "string") return new AmbaApiError(obj.code, typeof obj.message === "string" ? obj.message : "unknown", obj.details);
+	}
+	if (err instanceof Error) return new AmbaApiError(codeFromMessage(err.message), err.message);
+	return new AmbaApiError("UNKNOWN_ERROR", String(err));
+}
+
+//#endregion
+//#region src/index.ts
+/**
+* Internal state — one instance per page. Created lazily by `Amba.configure()`.
+*/
+let coreInstance = null;
+function requireCore() {
+	if (!coreInstance) throw new AmbaApiError("NOT_INITIALIZED", "amba SDK not configured. Call Amba.configure({ apiKey }) at app start before any other API.");
+	return coreInstance;
+}
+/**
+* Run a single SDK-runtime call and rewrap any thrown value into a
+* stable `AmbaApiError`. Every method on `Amba` funnels through this
+* so callers see one error shape regardless of which layer failed
+* (network, validation, etc.). Sync `requireCore()` accessors
+* (e.g. the `anonymousId` getter) already throw the typed shape on
+* their own.
+*/
+async function coreCall(fn) {
+	try {
+		return await fn(requireCore());
+	} catch (err) {
+		throw toAmbaApiError(err);
+	}
+}
+const authSubscribers = /* @__PURE__ */ new Set();
+function snapshotSession(user) {
+	if (!user) return null;
+	return {
+		sessionToken: "",
+		refreshToken: "",
+		user,
+		expiresAt: ""
+	};
+}
+function notifyAuthSubscribers(session) {
+	for (const cb of authSubscribers) try {
+		cb(session);
+	} catch (err) {
+		if (typeof console !== "undefined") console.error("[amba] onAuthStateChange callback threw", err);
+	}
+}
+async function notifyFromAuthResult(result) {
+	notifyAuthSubscribers(snapshotSession(result.user));
+}
+/**
+* Top-level SDK namespace.
+*
+* Stateless from the JS side — all state lives in the SDK runtime. Calling
+* `Amba.configure()` multiple times replaces the previous instance.
+*/
+const Amba = {
+	configure: async (config) => {
+		if (!config.apiKey || config.apiKey.trim() === "") throw new Error("Amba.configure: apiKey is required");
+		await init(); // Hermes-stripped Node-init block (DX-15) — see scripts/build-rn.mjs
+		new LocalStoragePersistence(config.storagePrefix ?? "amba").hydrate();
+		coreInstance = AmbaCoreWasm.init(encodeJson({
+			api_key: config.apiKey,
+			base_url: config.baseUrl,
+			sdk_platform: "web",
+			sdk_wrapper_version: `amba-web/${SDK_VERSION}`,
+			consent_required: config.consentRequired,
+			debug: config.debug
+		}), globalThis.fetch.bind(globalThis));
+	},
+	get anonymousId() {
+		return requireCore().anonymousId();
+	},
+	get appUserId() {
+		return requireCore().appUserId() ?? void 0;
+	},
+	get isAuthenticated() {
+		return requireCore().isAuthenticated();
+	},
+	setDebug: (enabled) => {
+		requireCore().setDebug(enabled);
+	},
+	events: { track: async (event, properties) => {
+		await coreCall((c) => c.track(event, properties ? encodeJson(properties) : void 0));
+	} },
+	auth: {
+		signInAnonymously: async () => {
+			const r = await coreCall((c) => c.signInAnonymously());
+			await notifyFromAuthResult(r);
+			return r;
+		},
+		signInWithEmail: async (email, password) => {
+			const r = await coreCall((c) => c.signInWithEmail(email, password));
+			await notifyFromAuthResult(r);
+			return r;
+		},
+		signUpWithEmail: async (email, password) => {
+			const r = await coreCall((c) => c.signUpWithEmail(email, password));
+			await notifyFromAuthResult(r);
+			return r;
+		},
+		signInWithSocial: async (provider, idToken) => {
+			const r = await coreCall((c) => c.signInWithSocial(provider, idToken));
+			await notifyFromAuthResult(r);
+			return r;
+		},
+		signOut: async (rotateAnonymousId = false) => {
+			await coreCall((c) => c.signOut(rotateAnonymousId));
+			notifyAuthSubscribers(null);
+		},
+		refresh: async () => {
+			const r = await coreCall((c) => c.refreshSession());
+			await notifyFromAuthResult(r);
+			return r;
+		},
+		me: async () => {
+			return await coreCall((c) => c.me());
+		},
+		getSession: async () => {
+			if (!requireCore().isAuthenticated()) return null;
+			return snapshotSession(await coreCall((c) => c.me()));
+		},
+		getAnonymousId: async () => {
+			return requireCore().anonymousId();
+		},
+		onAuthStateChange: (cb) => {
+			authSubscribers.add(cb);
+			return () => {
+				authSubscribers.delete(cb);
+			};
+		}
+	},
+	collections: {
+		find: async (name, options = {}) => {
+			return await coreCall((c) => c.collectionsFind(name, encodeJson(options)));
+		},
+		findOne: async (name, id) => {
+			return await coreCall((c) => c.collectionsFindOne(name, id));
+		},
+		insert: async (name, row) => {
+			return await coreCall((c) => c.collectionsInsert(name, encodeJson(row)));
+		},
+		update: async (name, id, set) => {
+			return await coreCall((c) => c.collectionsUpdate(name, id, encodeJson(set)));
+		},
+		delete: async (name, id) => {
+			return await coreCall((c) => c.collectionsDelete(name, id));
+		},
+		where: {
+			eq: (column, value) => ({
+				column,
+				op: "eq",
+				value
+			}),
+			ne: (column, value) => ({
+				column,
+				op: "ne",
+				value
+			}),
+			gt: (column, value) => ({
+				column,
+				op: "gt",
+				value
+			}),
+			gte: (column, value) => ({
+				column,
+				op: "gte",
+				value
+			}),
+			lt: (column, value) => ({
+				column,
+				op: "lt",
+				value
+			}),
+			lte: (column, value) => ({
+				column,
+				op: "lte",
+				value
+			}),
+			in: (column, values) => ({
+				column,
+				op: "in",
+				value: values
+			}),
+			notIn: (column, values) => ({
+				column,
+				op: "not_in",
+				value: values
+			}),
+			like: (column, pattern) => ({
+				column,
+				op: "like",
+				value: pattern
+			}),
+			ilike: (column, pattern) => ({
+				column,
+				op: "ilike",
+				value: pattern
+			}),
+			isNull: (column) => ({
+				column,
+				op: "is_null"
+			}),
+			isNotNull: (column) => ({
+				column,
+				op: "is_not_null"
+			}),
+			and: (...filters) => ({ and: filters }),
+			or: (...filters) => ({ or: filters }),
+			not: (filter) => ({ not: filter })
+		}
+	},
+	storage: {
+		presign: async (params) => {
+			return await coreCall((c) => c.storagePresign(params.bucket, params.filename, params.mimeType, params.sizeBytes, params.retentionDays ?? void 0));
+		},
+		upload: async (params) => {
+			const filename = params.filename ?? ("name" in params.file ? params.file.name : "upload");
+			const mimeType = params.file.type || "application/octet-stream";
+			const presign = await Amba.storage.presign({
+				bucket: params.bucket,
+				filename,
+				mimeType,
+				sizeBytes: params.file.size,
+				retentionDays: params.retentionDays
+			});
+			const uploadHeaders = {};
+			for (const [k, v] of presign.upload_headers) uploadHeaders[k] = v;
+			const putResp = await fetch(presign.upload_url, {
+				method: "PUT",
+				headers: uploadHeaders,
+				body: params.file
+			});
+			if (!putResp.ok) throw new Error(`upload to R2 failed: status ${putResp.status}`);
+			return await coreCall((c) => c.storageCommit(presign.upload_id, presign.asset_id));
+		}
+	},
+	push: {
+		register: async (token, platform, bundleId) => {
+			return await coreCall((c) => c.pushRegister(token, platform, bundleId ?? void 0));
+		},
+		unregister: async (token) => {
+			await coreCall((c) => c.pushUnregister(token));
+		},
+		getTokens: async () => {
+			return await coreCall((c) => c.pushGetTokens());
+		},
+		subscribe: async (topic) => {
+			await coreCall((c) => c.pushSubscribe(topic));
+		},
+		unsubscribe: async (topic) => {
+			await coreCall((c) => c.pushUnsubscribe(topic));
+		}
+	},
+	entitlements: {
+		list: async () => {
+			return await coreCall((c) => c.entitlementsList());
+		},
+		has: async (name) => {
+			return await coreCall((c) => c.entitlementsHas(name));
+		}
+	},
+	ai: { anthropic: { messages: { create: async (request) => {
+		return await coreCall((c) => c.aiAnthropicMessages(encodeJson(request)));
+	} } } },
+	config: { fetch: async () => {
+		return await coreCall((c) => c.configFetch());
+	} },
+	flags: { fetch: async () => {
+		return await coreCall((c) => c.flagsFetch());
+	} },
+	achievements: {
+		getAll: async () => await coreCall((c) => c.achievementsGetAll()),
+		getProgress: async () => await coreCall((c) => c.achievementsGetProgress())
+	},
+	challenges: {
+		getActive: async () => await coreCall((c) => c.challengesGetActive()),
+		get: async (id) => await coreCall((c) => c.challengesGet(id)),
+		getProgress: async (id) => await coreCall((c) => c.challengesGetProgress(id)),
+		claim: async (id) => await coreCall((c) => c.challengesClaim(id))
+	},
+	currencies: {
+		getBalance: async () => await coreCall((c) => c.currenciesGetBalance()),
+		getTransactions: async (currencyKey) => await coreCall((c) => c.currenciesGetTransactions(currencyKey))
+	},
+	inventory: {
+		getItems: async () => await coreCall((c) => c.inventoryGetItems()),
+		getItem: async (id) => await coreCall((c) => c.inventoryGetItem(id)),
+		purchase: async (request) => await coreCall((c) => c.inventoryPurchase(encodeJson(request))),
+		consume: async (request) => await coreCall((c) => c.inventoryConsume(encodeJson(request)))
+	},
+	leaderboards: {
+		get: async (key) => await coreCall((c) => c.leaderboardsGet(key)),
+		getEntries: async (key, limit) => await coreCall((c) => c.leaderboardsGetEntries(key, limit ?? void 0)),
+		getMyRank: async (key) => await coreCall((c) => c.leaderboardsGetMyRank(key))
+	},
+	stores: {
+		list: async () => await coreCall((c) => c.storesList()),
+		getPurchaseOptions: async (storeKey) => await coreCall((c) => c.storesGetPurchaseOptions(storeKey)),
+		purchase: async (storeKey, purchaseOptionId, receipt) => await coreCall((c) => c.storesPurchase(storeKey, purchaseOptionId, encodeJson(receipt)))
+	},
+	xp: {
+		getBalance: async () => await coreCall((c) => c.xpGetBalance()),
+		getHistory: async (limit) => await coreCall((c) => c.xpGetHistory(limit ?? void 0)),
+		claim: async (grantKey) => await coreCall((c) => c.xpClaim(grantKey))
+	},
+	streaks: {
+		getAll: async () => await coreCall((c) => c.streaksGetAll()),
+		qualify: async (streakKey) => await coreCall((c) => c.streaksQualify(streakKey))
+	},
+	feeds: { getActivity: async (feed, cursor) => await coreCall((c) => c.feedsGetActivity(feed ?? void 0, cursor ?? void 0)) },
+	friends: {
+		getList: async () => await coreCall((c) => c.friendsGetList()),
+		getFriends: async () => await coreCall((c) => c.friendsGetFriends()),
+		blockUser: async (userId) => await coreCall((c) => c.friendsBlockUser(userId)),
+		unblockUser: async (userId) => {
+			await coreCall((c) => c.friendsUnblockUser(userId));
+		},
+		removeBlock: async (friendshipId) => {
+			await coreCall((c) => c.friendsRemoveBlock(friendshipId));
+		}
+	},
+	groups: {
+		create: async (params) => await coreCall((c) => c.groupsCreate(encodeJson(params))),
+		get: async (id) => await coreCall((c) => c.groupsGet(id)),
+		update: async (id, patch) => await coreCall((c) => c.groupsUpdate(id, encodeJson(patch))),
+		delete: async (id) => {
+			await coreCall((c) => c.groupsDelete(id));
+		},
+		getMembers: async (id) => await coreCall((c) => c.groupsGetMembers(id)),
+		join: async (id) => await coreCall((c) => c.groupsJoin(id)),
+		leave: async (id) => {
+			await coreCall((c) => c.groupsLeave(id));
+		},
+		invite: async (id, userId) => await coreCall((c) => c.groupsInvite(id, userId))
+	},
+	messaging: {
+		getConversations: async () => await coreCall((c) => c.messagingGetConversations()),
+		getMessage: async (id) => await coreCall((c) => c.messagingGetMessage(id)),
+		sendMessage: async (request) => await coreCall((c) => c.messagingSendMessage(encodeJson(request)))
+	},
+	moderation: {
+		reportUser: async (request) => await coreCall((c) => c.moderationReportUser(encodeJson(request))),
+		reportContent: async (request) => await coreCall((c) => c.moderationReportContent(encodeJson(request))),
+		getReportStatus: async (id) => await coreCall((c) => c.moderationGetReportStatus(id))
+	},
+	reviews: {
+		list: async (targetType, targetId) => await coreCall((c) => c.reviewsList(targetType, targetId)),
+		create: async (params) => await coreCall((c) => c.reviewsCreate(encodeJson(params))),
+		update: async (id, patch) => await coreCall((c) => c.reviewsUpdate(id, encodeJson(patch))),
+		delete: async (id) => {
+			await coreCall((c) => c.reviewsDelete(id));
+		}
+	},
+	roles: {
+		getMyRoles: async () => await coreCall((c) => c.rolesGetMyRoles()),
+		hasPermission: async (permission) => await coreCall((c) => c.rolesHasPermission(permission))
+	},
+	referrals: {
+		getReferralCode: async () => await coreCall((c) => c.referralsGetReferralCode()),
+		claimReferral: async (code) => await coreCall((c) => c.referralsClaimReferral(code)),
+		create: async (code, maxUses) => await coreCall((c) => c.referralsCreate(code ?? void 0, maxUses ?? void 0))
+	},
+	catalog: { list: async () => await coreCall((c) => c.catalogList()) },
+	content: {
+		getToday: async (channel = "default") => await coreCall((c) => c.contentGetToday(channel)),
+		getLibrary: async (channel = "default", options) => await coreCall((c) => c.contentGetLibrary(channel, options?.limit ?? void 0, options?.cursor ?? void 0)),
+		getItem: async (id) => await coreCall((c) => c.contentGetItem(id)),
+		updateItem: async (id, state) => await coreCall((c) => c.contentUpdateItem(id, encodeJson(state))),
+		createItem: async (channel, item) => await coreCall((c) => c.contentCreateItem(channel, encodeJson(item)))
+	},
+	deepLinks: {
+		get: async (shortCode) => await coreCall((c) => c.deepLinksGet(shortCode)),
+		create: async (params) => await coreCall((c) => c.deepLinksCreate(encodeJson(params)))
+	},
+	onboarding: {
+		getStatus: async () => await coreCall((c) => c.onboardingGetStatus()),
+		nextStep: async (payload) => await coreCall((c) => c.onboardingNextStep(encodeJson(payload))),
+		skipStep: async () => await coreCall((c) => c.onboardingSkipStep()),
+		complete: async () => await coreCall((c) => c.onboardingComplete())
+	}
+};
+/** Escape hatch — the raw SDK runtime handle, for namespaces not yet wrapped. */
+function getCoreWasm() {
+	return requireCore();
+}
+/** Package version stamped at build time. */
+const SDK_VERSION = "0.1.0";
+
+//#endregion
+export { Amba, AmbaApiError, SDK_VERSION, getCoreWasm };
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layers/amba-web",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "amba SDK for browser apps — full 25-namespace surface (auth, collections, storage, events, push, entitlements, ai, config, flags, achievements, challenges, currencies, friends, groups, leaderboards, messaging, and more).",
   "type": "module",
   "main": "./dist/index.js",
@@ -9,11 +9,16 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "react-native": "./dist-rn/index.js",
+      "browser": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [
     "dist",
+    "dist-rn/index.js",
+    "dist-rn/index.d.ts",
     "README.md"
   ],
   "license": "MIT",
@@ -27,7 +32,7 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@layers/amba-core": "^1.0.0"
+    "@layers/amba-core": "^1.0.3"
   },
   "devDependencies": {
     "@types/node": "^22.13.14",
@@ -45,7 +50,10 @@
     "last 2 edge versions"
   ],
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && node ./scripts/build-rn.mjs",
+    "build:web": "tsdown",
+    "build:rn": "node ./scripts/build-rn.mjs",
+    "verify:pkg": "node ./scripts/verify-pkg.mjs",
     "test": "vitest run",
     "test:watch": "vitest"
   }