@billdog.io/react-native 1.0.0-beta.2

package/dist/xFlowTags.js

@@ -0,0 +1,385 @@
+"use strict";
+/**
+ * xFlow Tag Preprocessor — React Native SDK.
+ *
+ * Faithful port of src/lib/filters/xFlowTags.ts (the web reference). Implements
+ * the canonical grammar at src/schemas/xflow-grammar.md. Runs as a first pass
+ * before {{ }} interpolation. The conformance corpus
+ * (tests/parity/xflow-corpus/) is the cross-platform contract — web, iOS,
+ * Android, and React Native parsers must produce identical output.
+ *
+ * Tags: {% assign %} (with filter chains), {% if/elsif/else/endif %},
+ *       {% unless/endunless %}, {% case/when/else/endcase %}.
+ * Conditions: ==, !=, >, <, >=, <=, contains, and, or, unary !, postfix exists.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processXFlowTags = processXFlowTags;
+const valueUtils_1 = require("./valueUtils");
+const filters_1 = require("./filters");
+function processXFlowTags(text, variables) {
+    if (!text || typeof text !== 'string' || !text.includes('{%')) {
+        return { text: text !== null && text !== void 0 ? text : '', variables };
+    }
+    const vars = { ...variables };
+    const tokens = tokenize(text);
+    const output = processTokens(tokens, vars);
+    return { text: output, variables: vars };
+}
+function tokenize(text) {
+    const tokens = [];
+    let pos = 0;
+    while (pos < text.length) {
+        const tagStart = text.indexOf('{%', pos);
+        if (tagStart === -1) {
+            tokens.push({ type: 'text', content: text.slice(pos), raw: text.slice(pos) });
+            break;
+        }
+        if (tagStart > pos) {
+            const segment = text.slice(pos, tagStart);
+            tokens.push({ type: 'text', content: segment, raw: segment });
+        }
+        const tagEnd = text.indexOf('%}', tagStart);
+        if (tagEnd === -1) {
+            const segment = text.slice(tagStart);
+            tokens.push({ type: 'text', content: segment, raw: segment });
+            break;
+        }
+        const raw = text.slice(tagStart, tagEnd + 2);
+        const content = text.slice(tagStart + 2, tagEnd).trim();
+        tokens.push({ type: 'tag', content, raw });
+        pos = tagEnd + 2;
+    }
+    return tokens;
+}
+// ============= Token Processor =============
+function processTokens(tokens, vars) {
+    let output = '';
+    let i = 0;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.type === 'text') {
+            output += token.content;
+            i++;
+            continue;
+        }
+        const tagContent = token.content;
+        if (tagContent.startsWith('assign ')) {
+            processAssign(tagContent, vars);
+            i++;
+            continue;
+        }
+        if (tagContent.startsWith('if ')) {
+            const { result, endIndex } = processIfBlock(tokens, i, vars);
+            output += result;
+            i = endIndex + 1;
+            continue;
+        }
+        // {% unless X %}…{% endunless %} — Liquid's negated-if. Rewrite the open
+        // token to `if !(X)` and reuse processIfBlock (which also closes on
+        // `endunless`). elsif/else keep their if-semantics.
+        if (tagContent.startsWith('unless ')) {
+            const condition = tagContent.slice('unless '.length).trim();
+            const rewritten = tokens.slice();
+            rewritten[i] = { type: 'tag', content: `if !(${condition})`, raw: token.raw };
+            const { result, endIndex } = processIfBlock(rewritten, i, vars);
+            output += result;
+            i = endIndex + 1;
+            continue;
+        }
+        // {% case X %}{% when Y %}…{% else %}…{% endcase %}
+        if (tagContent.startsWith('case ')) {
+            const { result, endIndex } = processCaseBlock(tokens, i, vars);
+            output += result;
+            i = endIndex + 1;
+            continue;
+        }
+        // Unknown tag — keep raw.
+        output += token.raw;
+        i++;
+    }
+    return output;
+}
+// ============= Assign Processing =============
+function processAssign(tagContent, vars) {
+    const assignMatch = tagContent.match(/^assign\s+(\w+)\s*=\s*(.+)$/);
+    if (!assignMatch)
+        return;
+    const varName = assignMatch[1];
+    const expression = assignMatch[2].trim();
+    const { baseExpr, filterChain } = splitExpressionAndFilters(expression);
+    let value = resolveValue(baseExpr.trim(), vars);
+    if (filterChain) {
+        try {
+            value = (0, filters_1.applyFilterChain)(value, filterChain);
+        }
+        catch (error) {
+            console.warn(`[xFlowTags] Filter chain failed for assign "${varName}":`, error);
+        }
+    }
+    vars[varName] = value;
+}
+/** Split "value | filter1 | filter2" at the first unquoted pipe. */
+function splitExpressionAndFilters(expression) {
+    let inQuote = false;
+    let quoteChar = '';
+    for (let i = 0; i < expression.length; i++) {
+        const char = expression[i];
+        if ((char === '"' || char === "'") && expression[i - 1] !== '\\') {
+            if (!inQuote) {
+                inQuote = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar) {
+                inQuote = false;
+            }
+        }
+        else if (char === '|' && !inQuote) {
+            return {
+                baseExpr: expression.slice(0, i),
+                filterChain: expression.slice(i + 1).trim(),
+            };
+        }
+    }
+    return { baseExpr: expression, filterChain: null };
+}
+/**
+ * Process an {% if %} / {% unless %} block. `endif` and `endunless` are
+ * interchangeable terminators (grammar §2.3).
+ */
+function processIfBlock(tokens, startIndex, vars) {
+    const openingCondition = tokens[startIndex].content.slice(3).trim(); // remove "if "
+    const branches = [];
+    let currentCondition = openingCondition;
+    let currentBody = [];
+    let depth = 0;
+    let i = startIndex + 1;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.type === 'tag') {
+            const content = token.content;
+            if (content.startsWith('if ') || content.startsWith('unless ')) {
+                depth++;
+                currentBody.push(token);
+                i++;
+                continue;
+            }
+            if (content === 'endif' || content === 'endunless') {
+                if (depth > 0) {
+                    depth--;
+                    currentBody.push(token);
+                    i++;
+                    continue;
+                }
+                branches.push({ condition: currentCondition, bodyTokens: currentBody });
+                break;
+            }
+            if (depth === 0 && content.startsWith('elsif ')) {
+                branches.push({ condition: currentCondition, bodyTokens: currentBody });
+                currentCondition = content.slice(6).trim();
+                currentBody = [];
+                i++;
+                continue;
+            }
+            if (depth === 0 && content === 'else') {
+                branches.push({ condition: currentCondition, bodyTokens: currentBody });
+                currentCondition = null;
+                currentBody = [];
+                i++;
+                continue;
+            }
+        }
+        currentBody.push(token);
+        i++;
+    }
+    if (i >= tokens.length) {
+        branches.push({ condition: currentCondition, bodyTokens: currentBody });
+    }
+    for (const branch of branches) {
+        if (branch.condition === null || evaluateCondition(branch.condition, vars)) {
+            return { result: processTokens(branch.bodyTokens, vars), endIndex: i };
+        }
+    }
+    return { result: '', endIndex: i };
+}
+// ============= Case Block Processing =============
+/**
+ * Process {% case X %}{% when Y %}…{% when A, B %}…{% else %}…{% endcase %}.
+ * Evaluates X once; emits the first `when` whose value (any of its
+ * comma-separated candidates) is string-equal to X; falls back to `else`.
+ */
+function processCaseBlock(tokens, startIndex, vars) {
+    const caseExpr = tokens[startIndex].content.slice('case '.length).trim();
+    const caseValue = resolveValue(caseExpr, vars);
+    const branches = [];
+    let currentCondition = null;
+    let currentBody = [];
+    let inBranch = false;
+    let depth = 0;
+    let i = startIndex + 1;
+    while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.type === 'tag') {
+            const content = token.content;
+            if (content.startsWith('case ')) {
+                depth++;
+                currentBody.push(token);
+                i++;
+                continue;
+            }
+            if (content === 'endcase') {
+                if (depth > 0) {
+                    depth--;
+                    currentBody.push(token);
+                    i++;
+                    continue;
+                }
+                if (inBranch)
+                    branches.push({ condition: currentCondition, bodyTokens: currentBody });
+                break;
+            }
+            if (depth === 0 && content.startsWith('when ')) {
+                if (inBranch)
+                    branches.push({ condition: currentCondition, bodyTokens: currentBody });
+                currentCondition = content.slice('when '.length).trim();
+                currentBody = [];
+                inBranch = true;
+                i++;
+                continue;
+            }
+            if (depth === 0 && content === 'else') {
+                if (inBranch)
+                    branches.push({ condition: currentCondition, bodyTokens: currentBody });
+                currentCondition = null;
+                currentBody = [];
+                inBranch = true;
+                i++;
+                continue;
+            }
+        }
+        if (inBranch)
+            currentBody.push(token);
+        i++;
+    }
+    if (i >= tokens.length && inBranch) {
+        branches.push({ condition: currentCondition, bodyTokens: currentBody });
+    }
+    const caseStr = (0, valueUtils_1.stringify)(caseValue);
+    for (const branch of branches) {
+        if (branch.condition === null) {
+            // else branch
+            return { result: processTokens(branch.bodyTokens, vars), endIndex: i };
+        }
+        // when supports comma-separated candidates: `when "a", "b"`.
+        const candidates = branch.condition.split(',').map((c) => c.trim());
+        for (const candidate of candidates) {
+            if ((0, valueUtils_1.stringify)(resolveValue(candidate, vars)) === caseStr) {
+                return { result: processTokens(branch.bodyTokens, vars), endIndex: i };
+            }
+        }
+    }
+    return { result: '', endIndex: i };
+}
+// ============= Condition Evaluation =============
+function evaluateCondition(condition, vars) {
+    const trimmed = condition.trim();
+    // Unary `!` negation. Strips one optional outer paren pair so `!(a and b)`
+    // negates the whole inner condition.
+    if (trimmed.startsWith('!')) {
+        let inner = trimmed.slice(1).trim();
+        if (inner.startsWith('(') && inner.endsWith(')')) {
+            inner = inner.slice(1, -1).trim();
+        }
+        return !evaluateCondition(inner, vars);
+    }
+    const parts = splitLogical(trimmed);
+    if (parts.length === 1) {
+        return evaluateComparison(parts[0].expr.trim(), vars);
+    }
+    let result = evaluateComparison(parts[0].expr.trim(), vars);
+    for (let i = 1; i < parts.length; i++) {
+        const { operator, expr } = parts[i];
+        const right = evaluateComparison(expr.trim(), vars);
+        result = operator === 'and' ? result && right : result || right;
+    }
+    return result;
+}
+function splitLogical(condition) {
+    const segments = condition.split(/\b(and|or)\b/);
+    const result = [];
+    for (let i = 0; i < segments.length; i++) {
+        if (i === 0) {
+            result.push({ operator: null, expr: segments[0] });
+        }
+        else if (segments[i] === 'and' || segments[i] === 'or') {
+            result.push({ operator: segments[i], expr: segments[i + 1] || '' });
+            i++;
+        }
+    }
+    return result.length > 0 ? result : [{ operator: null, expr: condition }];
+}
+/** Evaluate "a == b", "a contains b", "a exists", or bare "a" (truthiness). */
+function evaluateComparison(expr, vars) {
+    // Postfix `exists` — checked before binary operators so an identifier
+    // containing "exists" isn't mis-parsed.
+    if (expr.endsWith(' exists')) {
+        const leftStr = expr.slice(0, -' exists'.length).trim();
+        if (leftStr) {
+            const value = resolveValue(leftStr, vars);
+            return value !== null && value !== undefined && (0, valueUtils_1.stringify)(value) !== '';
+        }
+    }
+    const operators = ['!=', '>=', '<=', '==', '>', '<', ' contains '];
+    for (const op of operators) {
+        const opIndex = expr.indexOf(op);
+        if (opIndex !== -1) {
+            const left = resolveValue(expr.slice(0, opIndex).trim(), vars);
+            const right = resolveValue(expr.slice(opIndex + op.length).trim(), vars);
+            return compareValues(left, right, op.trim());
+        }
+    }
+    return (0, valueUtils_1.isTruthy)(resolveValue(expr.trim(), vars));
+}
+function isNullishEqual(a, b) {
+    const an = a === null || a === undefined;
+    const bn = b === null || b === undefined;
+    if (an && bn)
+        return true;
+    if (an || bn)
+        return false;
+    return (0, valueUtils_1.stringify)(a) === (0, valueUtils_1.stringify)(b);
+}
+function compareValues(left, right, op) {
+    switch (op) {
+        case '==': return isNullishEqual(left, right);
+        case '!=': return !isNullishEqual(left, right);
+        case '>': return (0, valueUtils_1.toNumber)(left) > (0, valueUtils_1.toNumber)(right);
+        case '<': return (0, valueUtils_1.toNumber)(left) < (0, valueUtils_1.toNumber)(right);
+        case '>=': return (0, valueUtils_1.toNumber)(left) >= (0, valueUtils_1.toNumber)(right);
+        case '<=': return (0, valueUtils_1.toNumber)(left) <= (0, valueUtils_1.toNumber)(right);
+        case 'contains': {
+            if (Array.isArray(left)) {
+                return left.some((el) => (0, valueUtils_1.stringify)(el) === (0, valueUtils_1.stringify)(right));
+            }
+            return (0, valueUtils_1.stringify)(left).includes((0, valueUtils_1.stringify)(right));
+        }
+        default: return false;
+    }
+}
+// ============= Value Resolution =============
+function resolveValue(token, vars) {
+    if (!token)
+        return undefined;
+    if ((token.startsWith('"') && token.endsWith('"')) ||
+        (token.startsWith("'") && token.endsWith("'"))) {
+        return token.slice(1, -1);
+    }
+    if (token === 'true')
+        return true;
+    if (token === 'false')
+        return false;
+    if (token === 'nil' || token === 'null')
+        return null;
+    if (/^-?\d+(\.\d+)?$/.test(token))
+        return Number(token);
+    return (0, valueUtils_1.getNestedValue)(vars, token);
+}

package/ios/BillDogABTest.m

@@ -0,0 +1,50 @@
+//
+//  BillDogABTest.m
+//  @billdog.io/react-native
+//
+//  RCT_EXTERN bridge declarations for the BillDogABTest Swift module.
+//  ⚠️ Requires `pod install` + Xcode to compile/verify — no iOS toolchain in
+//  the authoring environment.
+//
+
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(BillDogABTest, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getVariant:(NSString *)experimentId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackConversion:(NSString *)experimentId
+                  value:(nonnull NSNumber *)value
+                  metadata:(NSDictionary *)metadata
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trackImpression:(NSString *)experimentId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setUserId:(NSString *)id
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setAttributes:(NSDictionary *)attributes
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getFeatureFlag:(NSString *)key
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(refreshExperiments:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(reset:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/BillDogABTest.swift

@@ -0,0 +1,188 @@
+//
+//  BillDogABTest.swift
+//  @billdog.io/react-native
+//
+//  React Native bridge → native `BillDogABTestManager`.
+//
+//  ⚠️ VERIFICATION: there is no iOS/CocoaPods toolchain in the authoring
+//  environment. This file is written to be internally consistent and
+//  compile-ready against the verified native signatures (cited inline as
+//  `BillDogABTest.swift:<line>` / `BillDog.swift:<line>`), but it REQUIRES a
+//  `pod install` + Xcode build to actually compile and run.
+//
+//  Manager is looked up per-call via `BillDog.shared.getModules()`
+//  (BillDog.swift:579). When the ABTest module is not registered (SDK not
+//  configured), every call is a best-effort no-op resolving nil/default —
+//  matching the JS side, which no-ops when the native module is unlinked.
+//
+
+import Foundation
+import React
+import BillDogFull
+
+@objc(BillDogABTest)
+class BillDogABTest: RCTEventEmitter {
+
+    private var hasListeners = false
+    private var busSubscriptionId: String?
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    override func supportedEvents() -> [String]! {
+        return ["onExperimentAssignmentChanged"]
+    }
+
+    override func startObserving() {
+        hasListeners = true
+        // Native emits `ab_variant_assigned` on the in-process EventBus
+        // (BillDogABTest.swift:297, BillDogEventBus.swift:42). The bus carries
+        // only {experiment_id, variant_id}, so the JS event body is a PARTIAL
+        // ExperimentAssignment (variantName/config/isControl are not on the bus).
+        busSubscriptionId = BillDogEventBus.shared.subscribe(
+            BillDogEventBus.EventTypes.abVariantAssigned
+        ) { [weak self] event in
+            guard let self = self, self.hasListeners else { return }
+            self.sendEvent(withName: "onExperimentAssignmentChanged", body: [
+                "experimentId": event.properties["experiment_id"] as? String ?? "",
+                "variantId": event.properties["variant_id"] as? String ?? ""
+            ])
+        }
+    }
+
+    override func stopObserving() {
+        hasListeners = false
+        if let id = busSubscriptionId {
+            BillDogEventBus.shared.unsubscribe(id) // BillDogEventBus.swift:95
+            busSubscriptionId = nil
+        }
+    }
+
+    // MARK: - Native manager access
+
+    // BillDog.shared.getModules() -> [BillDogModule]   (BillDog.swift:579)
+    // BillDogABTestManager: BillDogModule              (BillDogABTest.swift:6)
+    private func manager() -> BillDogABTestManager? {
+        return BillDog.shared.getModules()
+            .compactMap { $0 as? BillDogABTestManager }
+            .first
+    }
+
+    // MARK: - Lifecycle
+
+    // No native `initialize()` — the module is configured via BillDog.configure().
+    // Resolve as a best-effort no-op so the JS init handshake completes.
+    @objc
+    func initialize(_ resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        resolve(nil)
+    }
+
+    // MARK: - Variant assignment
+
+    @objc
+    func getVariant(_ experimentId: String,
+                    resolver resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        Task {
+            // mgr.getVariant(experimentId:) async -> ExperimentAssignment?  (BillDogABTest.swift:201)
+            // Serialized inline — the ExperimentAssignment type name is ambiguous
+            // (declared in two modules), so we never spell it, only read fields.
+            if let assignment = await mgr.getVariant(experimentId: experimentId) {
+                let config = assignment.config?.mapValues { $0.value } ?? [:]
+                resolve([
+                    "experimentId": assignment.experimentId,
+                    "variantId": assignment.variantId,
+                    "variantName": assignment.variantName,
+                    "config": config,
+                    "isControl": assignment.isControl
+                ])
+            } else {
+                resolve(nil)
+            }
+        }
+    }
+
+    // MARK: - Event tracking
+
+    @objc
+    func trackConversion(_ experimentId: String,
+                         value: NSNumber,
+                         metadata: NSDictionary,
+                         resolver resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.trackConversion(experimentId:value:metadata:)  (BillDogABTest.swift:245)
+        mgr.trackConversion(
+            experimentId: experimentId,
+            value: value.doubleValue,
+            metadata: metadata as? [String: Any]
+        )
+        resolve(nil)
+    }
+
+    @objc
+    func trackImpression(_ experimentId: String,
+                         resolver resolve: @escaping RCTPromiseResolveBlock,
+                         rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.trackImpression(experimentId:)  (BillDogABTest.swift:276)
+        mgr.trackImpression(experimentId: experimentId)
+        resolve(nil)
+    }
+
+    // MARK: - Identity / targeting
+
+    @objc
+    func setUserId(_ id: String,
+                   resolver resolve: @escaping RCTPromiseResolveBlock,
+                   rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.setUserId(_:)  (BillDogABTest.swift:65) — also triggers refresh
+        mgr.setUserId(id)
+        resolve(nil)
+    }
+
+    @objc
+    func setAttributes(_ attributes: NSDictionary,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.setAttributes(_:)  (BillDogABTest.swift:71)
+        mgr.setAttributes(attributes as? [String: Any] ?? [:])
+        resolve(nil)
+    }
+
+    // MARK: - Feature flags
+
+    @objc
+    func getFeatureFlag(_ key: String,
+                        resolver resolve: @escaping RCTPromiseResolveBlock,
+                        rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.getFeatureFlag(key:) -> Bool  (BillDogABTest.swift:220)
+        resolve(mgr.getFeatureFlag(key: key))
+    }
+
+    // MARK: - Refresh / reset
+
+    @objc
+    func refreshExperiments(_ resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.refreshExperiments()  (BillDogABTest.swift:191)
+        mgr.refreshExperiments()
+        resolve(nil)
+    }
+
+    @objc
+    func reset(_ resolve: @escaping RCTPromiseResolveBlock,
+               rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let mgr = manager() else { resolve(nil); return }
+        // mgr.reset()  (BillDogABTest.swift:306)
+        mgr.reset()
+        resolve(nil)
+    }
+}