flowboard-react 0.6.0 → 0.6.2

package/src/core/apiConfig.ts

@@ -0,0 +1,59 @@
+const DEFAULT_API_BASE_URL = 'api.flow-board.co';
+const DEFAULT_API_VERSION = 'v0';
+
+function trimTrailingSlashes(value: string): string {
+  return value.replace(/\/+$/, '');
+}
+
+function trimSurroundingSlashes(value: string): string {
+  return value.replace(/^\/+|\/+$/g, '');
+}
+
+function normalizeApiBaseUrl(value: string): string {
+  const trimmed = trimTrailingSlashes(String(value || '').trim());
+  if (!trimmed) {
+    throw new Error('Flowboard API base URL must be a non-empty string.');
+  }
+
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed;
+  }
+
+  return `https://${trimmed}`;
+}
+
+function normalizeApiVersion(value: string): string {
+  const trimmed = trimSurroundingSlashes(String(value || '').trim());
+  if (!trimmed) {
+    throw new Error('Flowboard API version must be a non-empty string.');
+  }
+
+  return `/${trimmed}`;
+}
+
+export function getFlowboardApiBaseUrl(): string {
+  return normalizeApiBaseUrl(DEFAULT_API_BASE_URL);
+}
+
+export function getFlowboardApiVersion(): string {
+  return normalizeApiVersion(DEFAULT_API_VERSION);
+}
+
+export function getFlowboardRuntimeBaseUrl(): string {
+  return `${getFlowboardApiBaseUrl()}${getFlowboardApiVersion()}`;
+}
+
+export function getResolveFlowUrl(): string {
+  return `${getFlowboardRuntimeBaseUrl()}/flows`;
+}
+
+export function getFlowByIdUrl(flowId: string): string {
+  const normalizedFlowId = String(flowId || '').trim();
+  if (!normalizedFlowId) {
+    throw new Error('flowId must be a non-empty string.');
+  }
+
+  return `${getFlowboardRuntimeBaseUrl()}/flows/${encodeURIComponent(
+    normalizedFlowId
+  )}`;
+}

package/src/core/resolverService.ts

@@ -1,48 +1,31 @@
 import type { ClientContext } from './clientContext';
-import type { FlowboardData } from '../types/flowboard';
-
-const DEFAULT_ENDPOINT = 'https://test-638704832888.europe-west1.run.app';
-const SPECIFIC_ONBOARDING_ENDPOINT =
-  'https://onboardsolo-638704832888.europe-west1.run.app';
+import type { FlowboardData, FlowboardFlowVersion } from '../types/flowboard';
+import { getFlowByIdUrl, getResolveFlowUrl } from './apiConfig';
 
 export class ResolverService {
-  private endpoint: string;
-  private specificOnboardingEndpoint: string;
+  private fetchImpl: typeof fetch;
 
-  constructor(endpoint?: string) {
-    this.endpoint = endpoint ?? DEFAULT_ENDPOINT;
-    this.specificOnboardingEndpoint = SPECIFIC_ONBOARDING_ENDPOINT;
+  constructor(fetchImpl: typeof fetch = fetch) {
+    this.fetchImpl = fetchImpl;
   }
 
   async fetchOnboardingJson(params: {
     context: ClientContext;
-    appId: string;
+    apiToken: string;
   }): Promise<FlowboardData> {
-    const { context, appId } = params;
-    const payload = context.toJson();
-    payload.appId = appId;
-    payload.installId = context.installId;
-    payload.bundleId = context.bundleId;
-
-    payload.appVersion = context.appVersion;
-    payload.buildNumber = context.buildNumber;
-    payload.os = context.os;
-    payload.osVersion = context.osVersion;
-    payload.deviceType = context.deviceType;
-    payload.locale = context.locale;
-    payload.country = context.country;
-
-    payload.sdk = {
-      name: 'flowboard',
-      version: '1.0.0',
-    };
+    const { context, apiToken } = params;
+    const url = new URL(getResolveFlowUrl());
+    url.searchParams.set('installId', context.installId);
+    url.searchParams.set('appVersion', context.appVersion);
+    url.searchParams.set('locale', context.locale);
+    url.searchParams.set('country', context.country);
+    url.searchParams.set('os', context.os);
 
     let response: Response;
     try {
-      response = await fetch(this.endpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
+      response = await this.fetchImpl(url.toString(), {
+        method: 'GET',
+        headers: this.createHeaders(apiToken),
       });
     } catch (error) {
       throw new Error(`Failed to connect to resolver: ${String(error)}`);
@@ -56,6 +39,7 @@ export class ResolverService {
     }
 
     const body = (await response.json()) as FlowboardData;
+    this.normalizeFlowIdentifier(body);
     this.applyHeaderMetadata(response, body);
 
     return body;
@@ -64,18 +48,18 @@ export class ResolverService {
   async fetchOnboardingById(params: {
     onboardingId: string;
     locale: string;
+    apiToken: string;
+    version?: FlowboardFlowVersion;
   }): Promise<FlowboardData> {
-    const payload = {
-      onboardingId: params.onboardingId,
-      locale: params.locale,
-    };
+    const url = new URL(getFlowByIdUrl(params.onboardingId));
+    url.searchParams.set('locale', params.locale);
+    url.searchParams.set('version', params.version ?? 'live');
 
     let response: Response;
     try {
-      response = await fetch(this.specificOnboardingEndpoint, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(payload),
+      response = await this.fetchImpl(url.toString(), {
+        method: 'GET',
+        headers: this.createHeaders(params.apiToken),
       });
     } catch (error) {
       throw new Error(`Failed to connect to resolver: ${String(error)}`);
@@ -89,11 +73,26 @@ export class ResolverService {
     }
 
     const body = (await response.json()) as FlowboardData;
+    this.normalizeFlowIdentifier(body);
     this.applyHeaderMetadata(response, body);
 
     return body;
   }
 
+  private createHeaders(apiToken: string): Record<string, string> {
+    return {
+      Accept: '*/*',
+      Authorization: `Bearer ${apiToken}`,
+    };
+  }
+
+  private normalizeFlowIdentifier(body: FlowboardData): void {
+    const legacyFlowId = (body as FlowboardData & { flowId?: unknown }).flowId;
+    if (!body.flow_id && typeof legacyFlowId === 'string' && legacyFlowId) {
+      body.flow_id = legacyFlowId;
+    }
+  }
+
   private applyHeaderMetadata(response: Response, body: FlowboardData): void {
     const flowId = response.headers.get('x-flowboard-flow-id');
     if (flowId) body.flow_id = flowId;

package/src/index.tsx

@@ -9,6 +9,7 @@ export type {
   OnStepChangeCallback,
   FlowboardLaunchOptions,
   FlowboardLaunchByIdOptions,
+  FlowboardFlowVersion,
   FlowboardData,
 } from './types/flowboard';
 export type { FlowboardFlowProps } from './components/FlowboardFlow';

package/src/types/flowboard.ts

@@ -13,6 +13,8 @@ export type FlowboardData = {
   experiment_id?: string;
 } & JsonMap;
 
+export type FlowboardFlowVersion = 'live' | 'draft';
+
 export type FlowboardContext = {
   context?: any;
   currentIndex: number;
@@ -53,4 +55,5 @@ export type FlowboardLaunchOptions = {
 
 export type FlowboardLaunchByIdOptions = FlowboardLaunchOptions & {
   locale?: string;
+  version?: FlowboardFlowVersion;
 };

package/src/utils/flowboardUtils.ts

@@ -91,7 +91,15 @@ export function parseDimension(
     return value;
   }
   if (typeof value === 'string') {
-    if (value.toLowerCase() === 'infinity') return Number.POSITIVE_INFINITY;
+    const normalized = value.trim().toLowerCase();
+    if (
+      normalized === 'infinity' ||
+      normalized === 'infinite' ||
+      normalized === 'double.infinity' ||
+      normalized === '+infinity'
+    ) {
+      return Number.POSITIVE_INFINITY;
+    }
     const numeric = Number(value);
     if (!Number.isNaN(numeric)) {
       if (zeroIsNull && numeric === 0) return undefined;