npm - react-native-cliqit - Versions diffs - 0.0.1 - Mend

react-native-cliqit 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/android/src/main/java/com/cliqit/sdk/CliqItWebFingerprint.kt ADDED Viewed

@@ -0,0 +1,230 @@
+package com.cliqit.sdk
+import android.annotation.SuppressLint
+import android.content.Context
+import android.os.Handler
+import android.os.Looper
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import org.json.JSONObject
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+/**
+ * Hidden WebView probe — same signals as iOS CliqItWebFingerprintCollector
+ * (canvas / WebGL / audio / clock skew). Runs on main thread; blocks caller briefly.
+ */
+internal object CliqItWebFingerprint {
+  data class Result(
+    val canvasHash: String?,
+    val webglHash: String?,
+    val webglVendor: String?,
+    val gpuRenderer: String?,
+    val audioFingerprint: String?,
+    val clockSkewMs: Int?,
+  )
+  private val htmlPage = """
+    <!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"></head><body>
+    <canvas id="c" width="280" height="80"></canvas>
+    <script>
+    function __cliqItHash(str) {
+      var h = 2166136261 >>> 0;
+      for (var i = 0; i < str.length; i++) {
+        h ^= str.charCodeAt(i);
+        h = Math.imul(h, 16777619) >>> 0;
+      }
+      return (h >>> 0).toString(16);
+    }
+    function __cliqItCanvas() {
+      try {
+        var c = document.getElementById('c') || document.createElement('canvas');
+        c.width = 280; c.height = 80;
+        var ctx = c.getContext('2d');
+        if (!ctx) return null;
+        ctx.textBaseline = 'alphabetic';
+        ctx.fillStyle = '#f60';
+        ctx.fillRect(10, 1, 140, 24);
+        var grad = ctx.createLinearGradient(0, 0, 200, 60);
+        grad.addColorStop(0, '#069');
+        grad.addColorStop(1, 'rgba(102,204,0,0.7)');
+        ctx.fillStyle = grad;
+        ctx.font = '16px Arial';
+        ctx.fillText('CliqIt,fp', 2, 20);
+        ctx.font = '14px "Courier New"';
+        ctx.fillText('mmmmmmmmmlli', 2, 42);
+        ctx.font = '12px Georgia';
+        ctx.fillText('Cwm fjord bank', 2, 60);
+        ctx.beginPath();
+        ctx.arc(220, 40, 18, 0, Math.PI * 2);
+        ctx.strokeStyle = '#c33';
+        ctx.stroke();
+        return __cliqItHash(c.toDataURL());
+      } catch (e) { return null; }
+    }
+    function __cliqItWebGL() {
+      try {
+        var c = document.createElement('canvas');
+        c.width = 16; c.height = 16;
+        var gl = c.getContext('webgl') || c.getContext('experimental-webgl');
+        if (!gl) return { hash: null, vendor: null, renderer: null };
+        var dbg = gl.getExtension('WEBGL_debug_renderer_info');
+        var vendor = dbg ? String(gl.getParameter(dbg.UNMASKED_VENDOR_WEBGL)) : String(gl.getParameter(gl.VENDOR));
+        var renderer = dbg ? String(gl.getParameter(dbg.UNMASKED_RENDERER_WEBGL)) : String(gl.getParameter(gl.RENDERER));
+        var params = [
+          String(gl.getParameter(gl.VERSION) || ''),
+          String(gl.getParameter(gl.SHADING_LANGUAGE_VERSION) || ''),
+          vendor || '',
+          renderer || '',
+          String(gl.getParameter(gl.MAX_TEXTURE_SIZE) || ''),
+          String(gl.getParameter(gl.MAX_RENDERBUFFER_SIZE) || ''),
+          (gl.getSupportedExtensions() || []).join(',')
+        ].join('|');
+        return { hash: __cliqItHash(params), vendor: vendor || null, renderer: renderer || null };
+      } catch (e) {
+        return { hash: null, vendor: null, renderer: null };
+      }
+    }
+    function __cliqItAudio() {
+      return new Promise(function(resolve) {
+        var settled = false;
+        function done(v) { if (settled) return; settled = true; resolve(v); }
+        try {
+          var AC = window.OfflineAudioContext || window.webkitOfflineAudioContext;
+          if (!AC) { done(null); return; }
+          var ctx = new AC(1, 44100, 44100);
+          var osc = ctx.createOscillator();
+          var comp = ctx.createDynamicsCompressor();
+          osc.type = 'triangle';
+          osc.frequency.value = 10000;
+          comp.threshold.value = -50;
+          comp.knee.value = 40;
+          comp.ratio.value = 12;
+          comp.attack.value = 0;
+          comp.release.value = 0.25;
+          osc.connect(comp);
+          comp.connect(ctx.destination);
+          osc.start(0);
+          ctx.oncomplete = function(ev) {
+            try {
+              var data = ev.renderedBuffer.getChannelData(0);
+              var sum = 0;
+              for (var i = 4500; i < 5000; i++) sum += Math.abs(data[i]);
+              done(__cliqItHash(String(sum)));
+            } catch (e) { done(null); }
+          };
+          ctx.startRendering();
+          setTimeout(function() { done(null); }, 700);
+        } catch (e) { done(null); }
+      });
+    }
+    window.__cliqItCollectFingerprint = async function() {
+      var gl = __cliqItWebGL();
+      var skew = null;
+      try {
+        if (window.performance && typeof performance.now === 'function' && performance.timeOrigin) {
+          skew = Date.now() - (performance.timeOrigin + performance.now());
+        }
+      } catch (e) {}
+      var audio = await __cliqItAudio();
+      return {
+        canvasHash: __cliqItCanvas(),
+        webglHash: gl.hash,
+        webglVendor: gl.vendor,
+        webglRenderer: gl.renderer,
+        audioHash: audio,
+        clockSkewMs: skew
+      };
+    };
+    </script></body></html>
+  """.trimIndent()
+  @SuppressLint("SetJavaScriptEnabled")
+  fun collect(context: Context, timeoutMs: Long = 3500L): Result? {
+    val latch = CountDownLatch(1)
+    val holder = AtomicReference<Result?>(null)
+    val appCtx = context.applicationContext
+    Handler(Looper.getMainLooper()).post {
+      var webView: WebView? = null
+      try {
+        webView = WebView(appCtx).apply {
+          settings.javaScriptEnabled = true
+          settings.domStorageEnabled = false
+          // Keep off-screen; do not attach to a window.
+          webViewClient = object : WebViewClient() {
+            override fun onPageFinished(view: WebView?, url: String?) {
+              view?.evaluateJavascript(
+                "(async function(){ try { return JSON.stringify(await window.__cliqItCollectFingerprint()); } catch(e) { return null; } })()",
+              ) { value ->
+                holder.set(parseJsResult(value))
+                try {
+                  view.destroy()
+                } catch (_: Exception) {
+                }
+                latch.countDown()
+              }
+            }
+          }
+          loadDataWithBaseURL(
+            "https://localhost/",
+            htmlPage,
+            "text/html",
+            "UTF-8",
+            null,
+          )
+        }
+      } catch (_: Exception) {
+        try {
+          webView?.destroy()
+        } catch (_: Exception) {
+        }
+        latch.countDown()
+      }
+    }
+    latch.await(timeoutMs, TimeUnit.MILLISECONDS)
+    return holder.get()
+  }
+  private fun parseJsResult(raw: String?): Result? {
+    if (raw.isNullOrBlank() || raw == "null") return null
+    // evaluateJavascript wraps strings in JSON quotes
+    val unquoted = try {
+      org.json.JSONTokener(raw).nextValue()?.let { v ->
+        when (v) {
+          is String -> v
+          else -> raw.trim().removeSurrounding("\"")
+            .replace("\\\"", "\"")
+            .replace("\\\\", "\\")
+        }
+      } ?: return null
+    } catch (_: Exception) {
+      raw.trim().removeSurrounding("\"")
+        .replace("\\\"", "\"")
+        .replace("\\\\", "\\")
+    }
+    return try {
+      val json = JSONObject(unquoted)
+      fun opt(key: String): String? =
+        if (!json.has(key) || json.isNull(key)) null
+        else json.optString(key, "").takeIf { it.isNotEmpty() && it != "null" }
+      val skew = when {
+        !json.has("clockSkewMs") || json.isNull("clockSkewMs") -> null
+        else -> json.optDouble("clockSkewMs").takeUnless { it.isNaN() }?.toInt()
+      }
+      Result(
+        canvasHash = opt("canvasHash"),
+        webglHash = opt("webglHash"),
+        webglVendor = opt("webglVendor"),
+        gpuRenderer = opt("webglRenderer"),
+        audioFingerprint = opt("audioHash"),
+        clockSkewMs = skew,
+      )
+    } catch (_: Exception) {
+      null
+    }
+  }
+}

package/ios/CliqItModule.m ADDED Viewed

@@ -0,0 +1,14 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+@interface RCT_EXTERN_MODULE(CliqItModule, RCTEventEmitter)
+RCT_EXTERN_METHOD(configure:(NSString *)apiKey)
+RCT_EXTERN_METHOD(handleUrl:(NSString *)urlString)
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+@end

package/ios/CliqItModule.swift ADDED Viewed

@@ -0,0 +1,238 @@
+import CliqIt
+import Foundation
+import React
+@objc(CliqItModule)
+class CliqItModule: RCTEventEmitter {
+  private var hasListeners = false
+  // ponytail: RN listeners attach after configure; buffer one shot so events aren't dropped
+  private var pendingDeepLink: [String: Any]?
+  private var pendingDeferredMatch: [String: Any]?
+  private var pendingLinkLookup: [String: Any]?
+  private var pendingVerify: [String: Any]?
+  override static func requiresMainQueueSetup() -> Bool { true }
+  override func supportedEvents() -> [String]! {
+    ["CliqItDeepLink", "CliqItDeferredMatch", "CliqItLinkLookup", "CliqItVerify"]
+  }
+  override func startObserving() {
+    hasListeners = true
+    flushPending()
+  }
+  override func stopObserving() {
+    hasListeners = false
+  }
+  @objc
+  func configure(_ apiKey: String) {
+    // Handlers that may fire during configure must be registered first where possible.
+    CliqItSDK.shared.onVerify { [weak self] result in
+      self?.emitVerify(result)
+    }
+    // SDK requires configure() before onDeepLink / onDeferredMatch.
+    CliqItSDK.shared.configure(apiKey: apiKey)
+    CliqItSDK.shared.onDeepLink { [weak self] payload in
+      self?.emitDeepLink(payload)
+    }
+    CliqItSDK.shared.onDeferredMatch { [weak self] outcome in
+      self?.emitDeferred(outcome)
+    }
+    CliqItSDK.shared.onDirectLinkLookup { [weak self] result in
+      self?.emitLinkLookup(result)
+    }
+    // Cold start after a prior match: SDK won't run again — tell JS instead of hanging forever.
+    if CliqItSDK.shared.hasDeferredMatchBeenReported,
+       !CliqItSDK.shared.isDeferredMatchInFlight
+    {
+      emitBody(
+        event: "CliqItDeferredMatch",
+        body: [
+          "status": "alreadyReported",
+          "note": "Deferred match already ran on this install. Delete the app (or clear UserDefaults) to retest.",
+        ],
+        pendingKey: \.pendingDeferredMatch
+      )
+    }
+  }
+  @objc
+  func handleUrl(_ urlString: String) {
+    guard let url = URL(string: urlString) else { return }
+    _ = CliqItSDK.shared.handle(url: url)
+  }
+  override func constantsToExport() -> [AnyHashable: Any]! {
+    [
+      "LinkField": [
+        "destination": CliqItLinkField.destination.rawValue,
+        "iosDestination": CliqItLinkField.iosDestination.rawValue,
+        "androidDestination": CliqItLinkField.androidDestination.rawValue,
+        "ogTitle": CliqItLinkField.ogTitle.rawValue,
+        "ogDescription": CliqItLinkField.ogDescription.rawValue,
+        "ogImage": CliqItLinkField.ogImage.rawValue,
+        "ogUrl": CliqItLinkField.ogUrl.rawValue,
+        "slug": CliqItLinkField.slug.rawValue,
+        "webFallback": CliqItLinkField.webFallback.rawValue,
+        "showInterstitial": CliqItLinkField.showInterstitial.rawValue,
+        "isDeepLink": CliqItLinkField.isDeepLink.rawValue,
+        "appleTeamId": CliqItLinkField.appleTeamId.rawValue,
+        "iosBundleId": CliqItLinkField.iosBundleId.rawValue,
+        "androidPackageName": CliqItLinkField.androidPackageName.rawValue,
+        "resolvedPath": CliqItLinkField.resolvedPath.rawValue,
+      ],
+    ]
+  }
+  // MARK: - Emit / buffer
+  private func emitDeepLink(_ payload: CliqItPayload) {
+    let body: [String: Any] = [
+      "url": payload.url.absoluteString,
+      "path": payload.path,
+      "pathComponents": payload.pathComponents,
+      "query": payload.queryParameters,
+      "source": payload.source.rawValue,
+      "isDeferred": payload.isDeferred,
+    ]
+    emitBody(event: "CliqItDeepLink", body: body, pendingKey: \.pendingDeepLink)
+  }
+  private func emitDeferred(_ outcome: CliqItDeferredMatchOutcome) {
+    let body: [String: Any]
+    switch outcome {
+    case .matched(let info):
+      body = [
+        "status": "matched",
+        "destinationPath": info.destinationPath as Any,
+        "slug": info.slug as Any,
+        "tier": info.tier as Any,
+        "score": info.score as Any,
+        "confidence": info.confidence as Any,
+      ]
+    case .notMatched(let info):
+      body = [
+        "status": "notMatched",
+        "tier": info.tier as Any,
+        "score": info.score as Any,
+      ]
+    case .failed(let error):
+      body = [
+        "status": "failed",
+        "error": error.localizedDescription,
+      ]
+    @unknown default:
+      return
+    }
+    emitBody(event: "CliqItDeferredMatch", body: body, pendingKey: \.pendingDeferredMatch)
+  }
+  private func emitLinkLookup(_ result: Result<CliqItLinkDetails, CliqItDeferredMatchError>) {
+    let body: [String: Any]
+    switch result {
+    case .success(let details):
+      body = [
+        "status": "resolved",
+        "destination": details[.destination] as Any,
+        "iosDestination": details[.iosDestination] as Any,
+        "androidDestination": details[.androidDestination] as Any,
+        "ogTitle": details[.ogTitle] as Any,
+        "ogDescription": details[.ogDescription] as Any,
+        "ogImage": details[.ogImage] as Any,
+        "ogUrl": details[.ogUrl] as Any,
+        "slug": details[.slug] as Any,
+        "webFallback": details[.webFallback] as Any,
+        "showInterstitial": details[.showInterstitial] as Any,
+        "isDeepLink": details[.isDeepLink] as Any,
+        "appleTeamId": details[.appleTeamId] as Any,
+        "iosBundleId": details[.iosBundleId] as Any,
+        "androidPackageName": details[.androidPackageName] as Any,
+        "resolvedPath": details[.resolvedPath] as Any,
+      ]
+    case .failure(let error):
+      body = [
+        "status": "failed",
+        "error": error.localizedDescription,
+      ]
+    }
+    emitBody(event: "CliqItLinkLookup", body: body, pendingKey: \.pendingLinkLookup)
+  }
+  private func emitVerify(_ outcome: CliqItVerifyOutcome) {
+    var body: [String: Any] = [:]
+    switch outcome {
+    case .passed(let r):
+      body = verifyBody(status: "ok", result: r)
+    case .mismatched(let r):
+      body = verifyBody(status: "mismatch", result: r)
+      body["message"] = r.mismatchMessage
+    case .error(let error):
+      body = [
+        "status": "failed",
+        "ok": false,
+        "error": error.localizedDescription,
+      ]
+    }
+    if let raw = CliqItSDK.shared.currentVerifyJSON {
+      body["raw"] = raw
+    }
+    emitBody(event: "CliqItVerify", body: body, pendingKey: \.pendingVerify)
+  }
+  private func verifyBody(status: String, result: CliqItVerifyResult) -> [String: Any] {
+    var checks: [String: Any] = [:]
+    for (key, check) in result.checks {
+      checks[key] = [
+        "actual": check.actual as Any,
+        "expected": check.expected as Any,
+        "match": check.match,
+      ]
+    }
+    return [
+      "status": status,
+      "ok": result.ok,
+      "appId": result.appId as Any,
+      "appName": result.appName as Any,
+      "checks": checks,
+      "message": result.mismatchMessage,
+    ]
+  }
+  private func emitBody(
+    event: String,
+    body: [String: Any],
+    pendingKey: ReferenceWritableKeyPath<CliqItModule, [String: Any]?>
+  ) {
+    if hasListeners {
+      sendEvent(withName: event, body: body)
+    } else {
+      self[keyPath: pendingKey] = body
+    }
+  }
+  private func flushPending() {
+    if let deep = pendingDeepLink {
+      pendingDeepLink = nil
+      sendEvent(withName: "CliqItDeepLink", body: deep)
+    }
+    if let match = pendingDeferredMatch {
+      pendingDeferredMatch = nil
+      sendEvent(withName: "CliqItDeferredMatch", body: match)
+    }
+    if let lookup = pendingLinkLookup {
+      pendingLinkLookup = nil
+      sendEvent(withName: "CliqItLinkLookup", body: lookup)
+    }
+    if let verify = pendingVerify {
+      pendingVerify = nil
+      sendEvent(withName: "CliqItVerify", body: verify)
+    }
+  }
+}

package/ios/Frameworks/CliqIt.xcframework/Info.plist ADDED Viewed

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>CliqIt.framework/CliqIt</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>CliqIt.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>CliqIt.framework/CliqIt</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>CliqIt.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/ios/Frameworks/CliqIt.xcframework/ios-arm64/CliqIt.framework/CliqIt ADDED Viewed

Binary file