// destinations.ts: steps 1 and 2, shared with the React and React Native tabs.
// 1. Your allow-list: your app's own scheme and the web hosts you own.
const APP_PREFIX = 'myapp://';
const WEB_HOSTS = ['www.example.com', 'offers.example.com'];

export type Destination = { kind: 'app'; path: string } | { kind: 'external'; url: string };

// 2. Turn a delivered destination into something safe to open, or null.
export function resolveDestination(raw: string): Destination | null {
  const value = raw.trim();
  if (/^\/(?!\/)/.test(value)) return { kind: 'app', path: value };                 // /in-app/offers
  if (value.toLowerCase().startsWith(APP_PREFIX)) {
    return { kind: 'app', path: '/' + value.slice(APP_PREFIX.length) };              // myapp://offers/42
  }
  const web = /^https:\/\/([^/?#@:]+)(?::\d+)?(?:[/?#]|$)/i.exec(value);
  if (web && WEB_HOSTS.includes(web[1].toLowerCase())) return { kind: 'external', url: value };
  if (/^(mailto|tel):\S+$/i.test(value)) return { kind: 'external', url: value };
  return null;                                                                        // anything else: ignore
}

// 3. The person tapped the block's button: record it, then route.
const block = client.getBlock('home_banner');
if (block) {
  ctaButton.onclick = () => {
    client.trackCtaClick(block);
    const to = resolveDestination(String(block.get('cta_url') ?? ''));
    if (to?.kind === 'app') router.navigate(to.path);
    else if (to) window.open(to.url, '_blank', 'noopener');
  };
}

import { useCF, useCFBlock } from '@contentflow/sdk/react';
import { useNavigate } from 'react-router-dom';
// 1-2. The allow-list and resolveDestination from the JavaScript tab.
import { resolveDestination } from './destinations';

function OfferButton() {
  const cf = useCF();
  const navigate = useNavigate();
  const block = useCFBlock('home_banner');   // tracks the impression
  if (!block || !block.ctaVisible) return null;

  // 3. The person tapped the block's button: record it, then route.
  const onClick = () => {
    cf.trackCtaClick(block);
    const to = resolveDestination(String(block.get('cta_url') ?? ''));
    if (to?.kind === 'app') navigate(to.path);
    else if (to) window.open(to.url, '_blank', 'noopener');
  };
  return <button onClick={onClick}>{block.ctaLabel}</button>;
}

import { Linking, Pressable, Text } from 'react-native';
import { useCF, useCFBlock } from '@contentflow/sdk/react-native';
// 1-2. The allow-list and resolveDestination from the JavaScript tab (no DOM needed).
import { resolveDestination } from './destinations';

function OfferButton({ navigate }: { navigate: (path: string) => void }) {
  const cf = useCF();
  const block = useCFBlock('home_banner');   // tracks the impression
  if (!block || !block.ctaVisible) return null;

  // 3. The person tapped the block's button: record it, then route.
  //    (<CFBanner onPress> records trackTap for a tap on the whole card instead.)
  const onPress = () => {
    cf.trackCtaClick(block);
    const to = resolveDestination(String(block.get('cta_url') ?? ''));
    if (to?.kind === 'app') navigate(to.path);
    else if (to) void Linking.openURL(to.url);
  };
  return <Pressable onPress={onPress}><Text>{block.ctaLabel}</Text></Pressable>;
}

import UIKit
import ContentFlow

// 1. Your allow-list: your app's own scheme and the web hosts you own.
let appScheme = "myapp"
let webHosts: Set<String> = ["www.example.com", "offers.example.com"]

enum Destination { case app(path: String), external(URL) }

// 2. Turn a delivered destination into something safe to open, or nil.
func resolveDestination(_ raw: String) -> Destination? {
    let value = raw.trimmingCharacters(in: .whitespacesAndNewlines)
    if value.hasPrefix("/") && !value.hasPrefix("//") { return .app(path: value) }
    guard let url = URL(string: value), let scheme = url.scheme?.lowercased() else { return nil }
    switch scheme {
    case appScheme:
        return .app(path: "/" + (url.host ?? "") + url.path)
    case "https":
        guard let host = url.host?.lowercased(), webHosts.contains(host), url.user == nil else { return nil }
        return .external(url)
    case "mailto", "tel":
        return .external(url)
    default:
        return nil
    }
}

// A url field reaches this SDK as an unknown field type: read its raw string.
func ctaDestination(_ block: ContentBlock) -> String {
    switch block.field("#cta_url")?.value {
    case .unknown(_, let raw)?: return raw.stringValue ?? ""
    case .text(let text)?: return text
    default: return ""
    }
}

// 3. The person tapped the block's button: record it, then route.
@MainActor
func ctaTapped(_ block: ContentBlock) async {
    _ = try? await client.trackEngagement(.ctaClick(block))
    switch resolveDestination(ctaDestination(block)) {
    case .app(let path)?: router.open(path)
    case .external(let url)?: _ = await UIApplication.shared.open(url)
    case nil: break
    }
}

import android.content.Context
import android.content.Intent
import android.net.Uri
import click.contentflow.*

// 1. Your allow-list: your app's own scheme and the web hosts you own.
const val APP_SCHEME = "myapp"
val WEB_HOSTS = setOf("www.example.com", "offers.example.com")

sealed interface Destination {
    data class App(val path: String) : Destination
    data class External(val uri: Uri) : Destination
}

// 2. Turn a delivered destination into something safe to open, or null.
fun resolveDestination(raw: String): Destination? {
    val value = raw.trim()
    if (value.startsWith("/") && !value.startsWith("//")) return Destination.App(value)
    val uri = Uri.parse(value)
    return when (uri.scheme?.lowercase()) {
        APP_SCHEME -> Destination.App("/" + (uri.host ?: "") + (uri.path ?: ""))
        "https" -> if (uri.host?.lowercase() in WEB_HOSTS && uri.userInfo == null) Destination.External(uri) else null
        "mailto", "tel" -> Destination.External(uri)
        else -> null
    }
}

// A url field reaches this SDK as an unknown field type: read it raw. Tags need the leading #.
fun ctaDestination(block: ContentBlock): String =
    (block.value(FieldKeys.raw("#cta_url")) as? JsonValue.Str)?.value.orEmpty()

// 3. The person tapped the block's button (from a coroutine): record it, then route.
suspend fun onCtaTapped(context: Context, block: ContentBlock) {
    client.track(CFEngagementEvent.of(block, CFEngagementEvent.CTA_CLICK))
    when (val to = resolveDestination(ctaDestination(block))) {
        is Destination.App -> router.open(to.path)
        is Destination.External -> context.startActivity(Intent(Intent.ACTION_VIEW, to.uri))
        null -> Unit
    }
}

import 'package:url_launcher/url_launcher.dart';

final cf = ContentFlow.instance;

// 1. Your allow-list: your app's own scheme and the web hosts you own.
const appScheme = 'myapp';
const webHosts = {'www.example.com', 'offers.example.com'};

class Destination {
  const Destination.app(String this.appPath) : external = null;
  const Destination.external(Uri this.external) : appPath = null;
  final String? appPath;
  final Uri? external;
}

// 2. Turn a delivered destination into something safe to open, or null.
Destination? resolveDestination(String raw) {
  final value = raw.trim();
  if (value.startsWith('/') && !value.startsWith('//')) return Destination.app(value);
  final uri = Uri.tryParse(value);
  if (uri == null) return null;
  switch (uri.scheme.toLowerCase()) {
    case appScheme:
      return Destination.app('/${uri.host}${uri.path}');
    case 'https':
      return webHosts.contains(uri.host.toLowerCase()) && uri.userInfo.isEmpty
          ? Destination.external(uri)
          : null;
    case 'mailto':
    case 'tel':
      return Destination.external(uri);
    default:
      return null;
  }
}

// 3. The person tapped the block's button: record it, then route.
//    (block.cta?.action reads #cta_url or #cta_action too.)
Future<void> onCtaTapped(CFBlock block) async {
  await cf.trackCtaClick(blockKey: block.key, instanceId: block.instanceId);
  final to = resolveDestination('${block.get('cta_url') ?? ''}');
  if (to?.appPath != null) {
    router.go(to!.appPath!);
  } else if (to?.external != null) {
    await launchUrl(to!.external!);
  }
}

# 1-2. Routing happens in your app; there is nothing to call for it.
# 3. Record the CTA click for the block instance the person tapped.
curl -X POST https://api.contentflow.click/sdk/v1/events \
  -H "X-CF-Key: $CF_SDK_KEY" -H "X-CF-Device: $CF_DEVICE" -H 'Content-Type: application/json' \
  -d '{"events":[{"type":"cta_click","blockKey":"home_banner","instanceId":"'"$INSTANCE_ID"'"}]}'

import { resolveDestination } from './destinations';   // from the block sample

// 1. The highest-priority campaign for the placement, and its impression.
const [top] = await client.getCampaigns('home_hero');
if (top) {
  client.trackCampaignImpression(top);

  // 2. On tap: record the tap (sent at once), then route actionUrl through the same check.
  heroButton.onclick = () => {
    client.trackCampaignTap(top);
    const to = resolveDestination(top.actionUrl);
    if (to?.kind === 'app') router.navigate(to.path);
    else if (to) window.open(to.url, '_blank', 'noopener');
  };
}

// 3. Later, when the person completes what the campaign offered:
// client.trackCampaignConversion(top);

import { useCF, useCFCampaigns } from '@contentflow/sdk/react';
import { useNavigate } from 'react-router-dom';
import { resolveDestination } from './destinations';

function Hero() {
  const cf = useCF();
  const navigate = useNavigate();
  // 1. The highest-priority campaign; the hook tracks one impression per campaign.
  const [top] = useCFCampaigns('home_hero');
  if (!top) return null;

  // 2. On tap: record the tap, then route actionUrl through the same check.
  const onClick = () => {
    cf.trackCampaignTap(top);
    const to = resolveDestination(top.actionUrl);
    if (to?.kind === 'app') navigate(to.path);
    else if (to) window.open(to.url, '_blank', 'noopener');
  };
  // 3. Later, on the goal: cf.trackCampaignConversion(top)
  return <button onClick={onClick}>{top.ctaLabel || top.title}</button>;
}

import { Linking } from 'react-native';
import { CFCampaignBanner } from '@contentflow/sdk/react-native';
import { resolveDestination } from './destinations';

// 1. Renders the highest-priority campaign and tracks its impression.
// 2. onPress fires after the banner has recorded trackCampaignTap: just route.
//    (With a custom `render`, the banner doesn't wrap it in a pressable: call cf.trackCampaignTap yourself.)
function Hero({ navigate }: { navigate: (path: string) => void }) {
  return (
    <CFCampaignBanner
      placement="home_hero"
      onPress={(c) => {
        const to = resolveDestination(c.actionUrl);
        if (to?.kind === 'app') navigate(to.path);
        else if (to) void Linking.openURL(to.url);
      }}
    />
  );
}
// 3. Later, on the goal: useCF().trackCampaignConversion(campaign)

// resolveDestination from the block sample.

// 1. The highest-priority campaign for the placement, and its impression.
let campaigns = try await client.getCampaigns(placement: "home_hero")
if let top = campaigns.first {
    try await client.trackCampaign(top, type: .impression)

    // 2. On tap: record the tap, then route actionURL through the same check.
    try await client.trackCampaign(top, type: .tap)
    switch resolveDestination(top.actionURL?.absoluteString ?? "") {
    case .app(let path)?: router.open(path)
    case .external(let url)?: _ = await UIApplication.shared.open(url)
    case nil: break
    }

    // 3. Later, when the person completes what the campaign offered:
    // try await client.trackCampaign(top, type: .conversion)
}

// resolveDestination from the block sample. From a coroutine.

// 1. The highest-priority campaign for the placement, and its impression.
//    trackCampaign: SDK 2.4.0 and later.
val top = client.getCampaigns("home_hero").firstOrNull()
if (top != null) {
    client.trackCampaign(top, EngagementType.Impression)

    // 2. On tap: record the tap, then route actionUrl through the same check.
    client.trackCampaign(top, EngagementType.Tap)
    when (val to = resolveDestination(top.actionUrl)) {
        is Destination.App -> router.open(to.path)
        is Destination.External -> context.startActivity(Intent(Intent.ACTION_VIEW, to.uri))
        null -> Unit
    }

    // 3. Later, when the person completes what the campaign offered:
    // client.trackCampaign(top, EngagementType.Conversion)
}

// resolveDestination from the block sample.
// trackCampaign* calls: SDK 2.4.0 and later.

// 1. The highest-priority campaign for the placement, and its impression.
final campaigns = await cf.getCampaigns('home_hero');
if (campaigns.isNotEmpty) {
  final top = campaigns.first;
  await cf.trackCampaignImpression(top);

  // 2. On tap: record the tap, then route the destination through the same check.
  //    CFCampaign has no actionUrl field: read ctaUrl from the content for the app's language.
  await cf.trackCampaignTap(top);
  final content = top.contentForLocale('ar') ?? top.content;
  final to = resolveDestination('${content['ctaUrl'] ?? ''}');
  if (to?.appPath != null) {
    router.go(to!.appPath!);
  } else if (to?.external != null) {
    await launchUrl(to!.external!);
  }

  // 3. Later, when the person completes what the campaign offered:
  // await cf.trackCampaignConversion(top);
}

# 1. The campaigns for the placement, highest priority first. The destination is ctaUrl in each
#    campaign's content (or in its metadata).
curl -X POST https://api.contentflow.click/sdk/v1/campaigns \
  -H "X-CF-Key: $CF_SDK_KEY" -H "X-CF-Device: $CF_DEVICE" -H 'Content-Type: application/json' \
  -d '{"placementId":"home_hero"}'

# 2. On tap: record it with the campaign and placement ids (routing happens in your app).
curl -X POST https://api.contentflow.click/sdk/v1/events \
  -H "X-CF-Key: $CF_SDK_KEY" -H "X-CF-Device: $CF_DEVICE" -H 'Content-Type: application/json' \
  -d '{"events":[{"type":"tap","campaignId":"'"$CAMPAIGN_ID"'","placementId":"home_hero"}]}'