@leisuresaas/react-native 0.6.2

package/src/hosted-ui-link.ts

@@ -0,0 +1,265 @@
+import * as Linking from "expo-linking";
+import * as WebBrowser from "expo-web-browser";
+import { useEffect } from "react";
+
+/** Default Hosted UI path locale when tag is missing/invalid. */
+export const DEFAULT_HOSTED_UI_LOCALE = "en";
+
+const BCP47_RE = /^[A-Za-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+
+/** True when a path segment looks like a BCP 47 language tag (no support whitelist). */
+export function isLocalePathSegment(raw?: string | null): boolean {
+  const v = (raw ?? "").trim();
+  return Boolean(v) && BCP47_RE.test(v) && v.length <= 32;
+}
+
+/** Canonicalize BCP 47-ish tag (language lower, region upper). */
+function canonicalizeBcp47(raw: string): string {
+  const parts = raw.trim().split("-").filter(Boolean);
+  if (parts.length === 0) {
+    return DEFAULT_HOSTED_UI_LOCALE;
+  }
+  const out = [parts[0]!.toLowerCase()];
+  for (const part of parts.slice(1)) {
+    if (part.length === 2 && /^[A-Za-z]{2}$/.test(part)) {
+      out.push(part.toUpperCase());
+    } else if (part.length === 4 && /^[A-Za-z]{4}$/.test(part)) {
+      out.push(part[0]!.toUpperCase() + part.slice(1).toLowerCase());
+    } else {
+      out.push(part.toLowerCase());
+    }
+  }
+  return out.join("-");
+}
+
+/**
+ * Map BCP 47-ish tag onto a Hosted UI path locale.
+ * No support whitelist: any valid tag is accepted (with common aliases).
+ * Missing/invalid tags fall back to {@link DEFAULT_HOSTED_UI_LOCALE} (`en`).
+ */
+export function normalizeHostedUILocale(raw?: string | null): string {
+  const v = (raw ?? "").trim().replace(/_/g, "-");
+  if (!v || !isLocalePathSegment(v)) {
+    return DEFAULT_HOSTED_UI_LOCALE;
+  }
+  const lower = v.toLowerCase();
+  // Convenient aliases for Hosted UI path conventions (not a closed allow-list).
+  if (lower === "en" || lower.startsWith("en-")) {
+    return "en";
+  }
+  if (lower === "zh" || lower.startsWith("zh-")) {
+    return "zh-CN";
+  }
+  if (lower === "de" || lower.startsWith("de-")) {
+    return "de";
+  }
+  return canonicalizeBcp47(v);
+}
+
+function pathSegments(url: string): string[] {
+  try {
+    const parsed = Linking.parse(url);
+    return (parsed.path ?? "").replace(/^\//, "").split("/").filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+/** True when URL is a Hosted UI password-reset page (path ends with /reset-password). */
+export function isHostedUIPasswordResetURL(url: string): boolean {
+  try {
+    const path = (Linking.parse(url).path ?? "").replace(/^\//, "");
+    return /(^|\/)reset-password\/?$/.test(path) || /\/reset-password\b/.test(path);
+  } catch {
+    return false;
+  }
+}
+
+/** True when URL is Hosted UI `/{locale}/open` handoff. */
+export function isHostedUIOpenHandoffURL(url: string): boolean {
+  const segs = pathSegments(url);
+  if (segs.length >= 2 && isLocalePathSegment(segs[0]) && segs[1] === "open") {
+    return true;
+  }
+  return segs.length === 1 && segs[0] === "open";
+}
+
+/** Business HTTPS URL from `/{locale}/open?next=…`. */
+export function hostedUIURLFromOpenHandoff(url: string): string | null {
+  if (!isHostedUIOpenHandoffURL(url)) {
+    return null;
+  }
+  try {
+    const parsed = Linking.parse(url);
+    const q = parsed.queryParams?.next;
+    const next = typeof q === "string" ? q : Array.isArray(q) ? q[0] : "";
+    const trimmed = (next ?? "").trim();
+    if (!trimmed) {
+      return null;
+    }
+    if (/^https:\/\//i.test(trimmed)) {
+      return trimmed;
+    }
+    if (trimmed.startsWith("/")) {
+      const base = Linking.parse(url);
+      const host = base.hostname;
+      if (!host) {
+        return null;
+      }
+      const scheme = base.scheme === "http" ? "http" : "https";
+      return `${scheme}://${host}${trimmed}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** True when deep link path is auth/open (custom scheme from Hosted UI). */
+function isAppOpenPath(url: string): boolean {
+  try {
+    const parsed = Linking.parse(url);
+    const host = (parsed.hostname ?? "").replace(/^\//, "");
+    const path = (parsed.path ?? "").replace(/^\//, "");
+    if (host === "auth" && (path === "open" || path === "")) {
+      return true;
+    }
+    return path === "auth/open" || path.endsWith("/auth/open");
+  } catch {
+    return false;
+  }
+}
+
+/** HTTPS page URL embedded in `{scheme}://auth/open?url=…`. */
+export function hostedUIURLFromAppOpenLink(url: string): string | null {
+  if (!isAppOpenPath(url)) {
+    return null;
+  }
+  try {
+    const parsed = Linking.parse(url);
+    const q = parsed.queryParams?.url;
+    const embedded = typeof q === "string" ? q : Array.isArray(q) ? q[0] : "";
+    const trimmed = (embedded ?? "").trim();
+    if (!trimmed || !/^https:\/\//i.test(trimmed)) {
+      return null;
+    }
+    return trimmed;
+  } catch {
+    return null;
+  }
+}
+
+/** Ensure Hosted UI opens with compact mobile layout when terminal is absent. */
+export function withTerminalMobile(url: string): string {
+  const trimmed = url.trim();
+  if (!trimmed || !/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+  try {
+    const u = new URL(trimmed);
+    if (!u.searchParams.get("terminal")) {
+      u.searchParams.set("terminal", "mobile");
+    }
+    return u.toString();
+  } catch {
+    return trimmed;
+  }
+}
+
+/** Rewrite Hosted UI path locale segment (insert or replace). Invalid locale → `en`. */
+export function withHostedUILocale(url: string, locale?: string | null): string {
+  const trimmed = url.trim();
+  if (locale == null || !String(locale).trim() || !trimmed || !/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+  const normalized = normalizeHostedUILocale(locale);
+  try {
+    const u = new URL(trimmed);
+    const segs = u.pathname.split("/").filter(Boolean);
+    if (segs.length > 0 && isLocalePathSegment(segs[0])) {
+      segs[0] = normalized;
+    } else {
+      segs.unshift(normalized);
+    }
+    u.pathname = "/" + segs.join("/");
+    return u.toString();
+  } catch {
+    return trimmed;
+  }
+}
+
+export type OpenHostedUIInAppOptions = {
+  locale?: string;
+};
+
+/**
+ * Open Hosted UI identity URL inside an in-app browser.
+ * Pass the HTTPS Universal Link / App Link URL unchanged — do not strip token.
+ * Adds `terminal=mobile` when missing so Hosted UI uses the compact layout.
+ * Optionally rewrites path locale to match the app language (unsupported/invalid → `en`).
+ * Never opens `/open` itself — resolves `next` to the business page first.
+ */
+export async function openHostedUIInApp(url: string, opts?: OpenHostedUIInAppOptions): Promise<void> {
+  let trimmed = url.trim();
+  const fromHandoff = hostedUIURLFromOpenHandoff(trimmed);
+  if (fromHandoff) {
+    trimmed = fromHandoff;
+  }
+  trimmed = withTerminalMobile(trimmed);
+  if (opts?.locale) {
+    trimmed = withHostedUILocale(trimmed, opts.locale);
+  }
+  if (!trimmed) {
+    return;
+  }
+  await WebBrowser.openBrowserAsync(trimmed, {
+    createTask: false,
+    showInRecents: true,
+  });
+}
+
+/**
+ * Handle an incoming deep link:
+ * - HTTPS Hosted UI `/open?next=` → In-App Browser with business URL
+ * - HTTPS Hosted UI reset-password → In-App Browser
+ * - `{scheme}://auth/open?url=https…` → In-App Browser with embedded URL
+ */
+export async function handleHostedUILink(url: string, opts?: OpenHostedUIInAppOptions): Promise<boolean> {
+  const fromOpen = hostedUIURLFromAppOpenLink(url);
+  if (fromOpen) {
+    await openHostedUIInApp(fromOpen, opts);
+    return true;
+  }
+  if (isHostedUIOpenHandoffURL(url) || isHostedUIPasswordResetURL(url)) {
+    await openHostedUIInApp(url, opts);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Subscribe to cold-start + foreground links for Hosted UI reset-password / open / auth/open.
+ * Call once near the app root (e.g. inside AuthProvider children).
+ */
+export function useHostedUIPasswordResetLink(enabled = true, locale?: string): void {
+  useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const opts = locale ? { locale } : undefined;
+    let active = true;
+    (async () => {
+      const initial = await Linking.getInitialURL();
+      if (active && initial) {
+        await handleHostedUILink(initial, opts);
+      }
+    })();
+    const sub = Linking.addEventListener("url", ({ url }) => {
+      void handleHostedUILink(url, opts);
+    });
+    return () => {
+      active = false;
+      sub.remove();
+    };
+  }, [enabled, locale]);
+}

package/src/index.ts

@@ -0,0 +1,161 @@
+export { buildAdClickUrl } from "./ads";
+export {
+  Ad,
+  AdBanner,
+  AdFooter,
+  AdInline,
+  AdPreview,
+  AdSidebar,
+  AdsProvider,
+  defaultAdsTheme,
+  effectiveRotationMode,
+  layoutsForType,
+  defaultLayoutForType,
+  normalizeAdType,
+  normalizeLayout,
+  normalizeRotationMode,
+  useAdsFeed,
+  useAdRotation,
+  TEXT_LAYOUTS,
+  IMAGE_LAYOUTS,
+  AD_TYPES,
+} from "./ads-ui";
+export type {
+  AdCreativeStyles,
+  AdLayout,
+  AdLayoutRenderContext,
+  AdLayoutStyles,
+  AdPreviewProps,
+  AdProps,
+  AdRenderContext,
+  AdRotationMode,
+  AdRotationStyles,
+  AdSlotViewProps,
+  AdsProviderProps,
+  AdsTheme,
+  InAppNavigate,
+  UseAdsFeedOptions,
+  UseAdsFeedResult,
+  UseAdRotationResult,
+  AdType,
+  TextLayout,
+  ImageLayout,
+  TextLayoutStyles,
+  ImageLayoutStyles,
+} from "./ads-ui";
+export { AuthProvider, useAuth, LeisureSaasAuthProvider, useLeisureSaasAuth } from "./auth";
+export type {
+  AuthContextValue,
+  AuthProviderProps,
+  LeisureSaasAuthContextValue,
+  LeisureSaasAuthProviderProps,
+} from "./auth";
+export { AuthLoginError } from "./auth-errors";
+export type { AuthLoginErrorCode } from "./auth-errors";
+export { fetchUserInfo } from "./userinfo";
+export type { UserInfo } from "./userinfo";
+export {
+  DEFAULT_HOSTED_UI_LOCALE,
+  handleHostedUILink,
+  hostedUIURLFromAppOpenLink,
+  hostedUIURLFromOpenHandoff,
+  isHostedUIOpenHandoffURL,
+  isHostedUIPasswordResetURL,
+  isLocalePathSegment,
+  normalizeHostedUILocale,
+  openHostedUIInApp,
+  useHostedUIPasswordResetLink,
+  withHostedUILocale,
+  withTerminalMobile,
+} from "./hosted-ui-link";
+export {
+  bindPlatformAccount,
+  changeProductPassword,
+  deleteProductAccount,
+  loginProductAccount,
+  loginWithPlatformAccount,
+  logoutProductAccount,
+  refreshProductSession,
+  registerProductAccount,
+  requestProductEmailVerification,
+  requestProductPasswordReset,
+  startPlatformAuthorize,
+  unbindPlatformAccount,
+} from "./public-auth";
+export type { ProductAuthTokens, PublicAuthContext } from "./public-auth";
+export { getPublicAdsFeed, recordPublicAdEvents } from "./public-ads";
+export type { PublicAdsRequestContext } from "./public-ads";
+export { getPublicAppConfig } from "./public-app-config";
+export type { AppConfigResponse, PublicAppConfigRequestContext } from "./public-app-config";
+export {
+  DRIVE_UPLOAD_MAX_AUTO_PUT_BYTES,
+  listFsNodes,
+  getFsStorageUsage,
+  getFsNode,
+  createFsFolder,
+  renameFsNode,
+  moveFsNode,
+  deleteFsNode,
+  createFsUploadSession,
+  finishFsUploadSession,
+  createFsContentURL,
+  putFsUploadURL,
+  uploadFsFile,
+} from "./drive";
+export type {
+  DriveRequestContext,
+  FsContentURLIntent,
+  FsContentURLResult,
+  FsNode,
+  FsStorageUsage,
+  FsUploadSessionResult,
+  UploadProgress,
+  UploadProgressHandler,
+} from "./drive";
+export { applyPublishableKeyHeaders, resolvePublishableKeyFromEnv } from "./publishable-key";
+export { resolveGatewayUrlFromEnv } from "./gateway-url";
+export { fetchPlatformApiBase, resolvePlatformApiBase } from "./platform-api-base";
+export type { ResolvePlatformApiBaseOptions } from "./platform-api-base";
+export {
+  AppUpdateProvider,
+  AppVersionSettingsCard,
+  useAppUpdate,
+  useAppVersionSettings,
+} from "./app-update/context";
+export type {
+  AppUpdateInfo,
+  AppUpdateLabels,
+  AppUpdateProviderProps,
+  AppUpdateStatus,
+  AppVersionSettingsCardProps,
+  AppVersionSettingsState,
+} from "./app-update/context";
+export { lineupIdFromSource } from "./ads/lineup-id";
+export {
+  accessNeedsRefresh,
+  exchangeAuthorizationCode,
+  exchangeMagicToken,
+  magicTokenFromURL,
+  refreshOAuthTokens,
+} from "./auth-session";
+export type { OAuthTokenResponse } from "./auth-session";
+export { buildEnablePushRegistration, fetchNativeDevicePushToken } from "./push";
+export { devAppleSignedTransaction, devDeviceToken, devGooglePurchaseToken } from "./dev";
+export { LeisureSaasHttpError } from "./errors";
+export { mobilePlatform, adsSurfaceKey, adsSurfaceHeaders } from "./platform";
+export { appBundleId } from "./ads/bundle-id";
+export type {
+  AdEventInput,
+  AdFeedItem,
+  AdFeedRotation,
+  AdFeedSource,
+  AdsFeedResponse,
+  AuthConfig,
+  EnablePushOptions,
+  Entitlement,
+  LeisureSaasAuthConfig,
+  MobilePlatform,
+  Plan,
+  RegisterDeviceTokenInput,
+  SubscriptionStatus,
+} from "./types";

package/src/platform-api-base.ts

@@ -0,0 +1,72 @@
+import { LeisureSaasHttpError } from "./errors";
+import { resolveGatewayUrlFromEnv } from "./gateway-url";
+
+const DISCOVERY_PLATFORM_API_KEY = "leisuresaas_platform_api_base";
+
+function trimSlash(url: string): string {
+  return url.replace(/\/$/, "");
+}
+
+/**
+ * Fetch LeisureSaas platform API base from OIDC discovery
+ * (`leisuresaas_platform_api_base` vendor claim).
+ * Prefer {@link resolvePlatformApiBase} so EXPO_PUBLIC_GATEWAY_URL wins.
+ */
+export async function fetchPlatformApiBase(issuer: string): Promise<string> {
+  const base = trimSlash(issuer.trim());
+  if (!base) {
+    throw new Error("issuer is required");
+  }
+  const res = await fetch(`${base}/.well-known/openid-configuration`, {
+    method: "GET",
+    headers: { Accept: "application/json" },
+  });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new LeisureSaasHttpError(res.status, text.trim());
+  }
+  let doc: Record<string, unknown>;
+  try {
+    doc = JSON.parse(text) as Record<string, unknown>;
+  } catch {
+    throw new Error("openid-configuration: invalid JSON");
+  }
+  const raw = doc[DISCOVERY_PLATFORM_API_KEY];
+  const api = typeof raw === "string" ? trimSlash(raw.trim()) : "";
+  if (!api) {
+    throw new Error(`openid-configuration missing ${DISCOVERY_PLATFORM_API_KEY}`);
+  }
+  return api;
+}
+
+export type ResolvePlatformApiBaseOptions = {
+  /** Explicit platform API root (wins). */
+  gatewayUrl?: string;
+  /** OAuth issuer used to fetch discovery when env/prop absent. */
+  issuer?: string;
+  env?: Record<string, string | undefined>;
+};
+
+/**
+ * Resolve platform API base: prop → EXPO_PUBLIC_GATEWAY_URL → discovery via issuer.
+ * Never treats OAuth issuer itself as the Public API root.
+ */
+export async function resolvePlatformApiBase(opts: ResolvePlatformApiBaseOptions = {}): Promise<string> {
+  const fromProp = opts.gatewayUrl?.trim();
+  if (fromProp) {
+    return trimSlash(fromProp);
+  }
+  const fromEnv = resolveGatewayUrlFromEnv(opts.env);
+  if (fromEnv) {
+    return trimSlash(fromEnv);
+  }
+  const issuer =
+    opts.issuer?.trim() ||
+    opts.env?.EXPO_PUBLIC_OAUTH_ISSUER?.trim() ||
+    (typeof process !== "undefined" ? process.env.EXPO_PUBLIC_OAUTH_ISSUER?.trim() : "") ||
+    "";
+  if (!issuer) {
+    return "";
+  }
+  return fetchPlatformApiBase(issuer);
+}

package/src/platform.ts

@@ -0,0 +1,16 @@
+import { Platform } from "react-native";
+
+import type { MobilePlatform } from "./types";
+
+export function mobilePlatform(): MobilePlatform {
+  return Platform.OS === "ios" ? "ios" : "android";
+}
+
+/** Surface key for Public / Integration ads feed (ios | android). */
+export function adsSurfaceKey(): MobilePlatform {
+  return mobilePlatform();
+}
+
+export function adsSurfaceHeaders(): Record<string, string> {
+  return { "X-Ads-Surface-Key": adsSurfaceKey() };
+}

package/src/public-ads.ts

@@ -0,0 +1,105 @@
+import { LeisureSaasHttpError } from "./errors";
+import { adsSurfaceKey } from "./platform";
+import { applyPublishableKeyHeaders } from "./publishable-key";
+import type { AdEventInput, AdsFeedResponse, MobilePlatform } from "./types";
+
+export type PublicAdsRequestContext = {
+  gatewayUrl: string;
+  publishableKey: string;
+  /** Surface key sent as X-Ads-Surface-Key (e.g. ios, android, web). */
+  surfaceKey?: MobilePlatform | "web";
+  /** @deprecated Use surfaceKey. Gateway requires X-Ads-Surface-Key since v0.5.1. */
+  platform?: MobilePlatform | "web";
+  bundleId?: string;
+  origin?: string;
+};
+
+function trimSlash(url: string): string {
+  return url.replace(/\/$/, "");
+}
+
+function resolveSurfaceKey(ctx: PublicAdsRequestContext): MobilePlatform | "web" {
+  return ctx.surfaceKey ?? ctx.platform ?? adsSurfaceKey();
+}
+
+function publicAdsHeaders(ctx: PublicAdsRequestContext, accessToken?: string): Record<string, string> {
+  const surfaceKey = resolveSurfaceKey(ctx);
+  const headers: Record<string, string> = {
+    Accept: "application/json",
+    "X-Ads-Surface-Key": surfaceKey,
+  };
+  applyPublishableKeyHeaders(headers, ctx.publishableKey);
+  if (surfaceKey === "web") {
+    if (ctx.origin?.trim()) {
+      headers.Origin = ctx.origin.trim();
+    }
+  } else if (ctx.bundleId?.trim()) {
+    headers["X-Ads-Bundle-Id"] = ctx.bundleId.trim();
+  }
+  if (accessToken?.trim()) {
+    headers.Authorization = `Bearer ${accessToken.trim()}`;
+  }
+  return headers;
+}
+
+async function publicAdsRequest<T>(
+  ctx: PublicAdsRequestContext,
+  method: "GET" | "POST",
+  path: string,
+  body?: unknown,
+  accessToken?: string,
+): Promise<T> {
+  const base = `${trimSlash(ctx.gatewayUrl)}/v1/public/ads`;
+  const url = `${base}${path.startsWith("/") ? path : `/${path}`}`;
+  const headers = publicAdsHeaders(ctx, accessToken);
+  let payload: string | undefined;
+  if (body !== undefined) {
+    headers["Content-Type"] = "application/json";
+    payload = JSON.stringify(body);
+  }
+  const res = await fetch(url, { method, headers, body: payload });
+  const text = await res.text();
+  if (!res.ok) {
+    throw new LeisureSaasHttpError(res.status, text.trim());
+  }
+  if (!text) {
+    return {} as T;
+  }
+  return JSON.parse(text) as T;
+}
+
+export async function getPublicAdsFeed(
+  ctx: PublicAdsRequestContext,
+  placement = "home_banner",
+): Promise<AdsFeedResponse> {
+  const q = encodeURIComponent(placement.trim());
+  const resp = await publicAdsRequest<AdsFeedResponse>(ctx, "GET", `/feed?placement=${q}`);
+  return { ...resp, ads: resp.ads ?? [] };
+}
+
+export async function recordPublicAdEvents(
+  ctx: PublicAdsRequestContext,
+  sessionId: string,
+  events: AdEventInput[],
+  accessToken?: string | null,
+): Promise<number> {
+  if (events.length === 0) {
+    return 0;
+  }
+  const payload = {
+    session_id: sessionId.trim(),
+    events: events.map((ev) => {
+      const lineupId = ev.lineupId?.trim() ?? "";
+      return {
+        ad_id: ev.adId,
+        event_type: ev.eventType,
+        ...(ev.placementKey ? { placement_key: ev.placementKey } : {}),
+        ...(lineupId ? { lineup_id: lineupId } : {}),
+      };
+    }),
+  };
+  const resp = await publicAdsRequest<{ recorded: number }>(
+    ctx, "POST", "/events", payload, accessToken ?? undefined,
+  );
+  return resp.recorded ?? 0;
+}