@pushmesh/sdk 0.7.2

package/ios/PushMeshApnsModule.m

@@ -0,0 +1,76 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <UIKit/UIKit.h>
+
+/**
+ * Bridge old-arch (interop) do módulo Swift PushMeshApns.
+ * Ver ios/PushMeshApns.swift — APNs direto, sem Firebase.
+ */
+/**
+ * Gancho de CARREGAMENTO: instala o wrapper do delegate de notificações assim
+ * que o app termina de abrir.
+ *
+ * O UNUserNotificationCenter só entrega o `didReceive` (o toque que abriu o
+ * app) para quem JÁ é delegate quando o launch termina. Como o módulo React
+ * nasce depois disso, o toque com o app FECHADO se perdia em silêncio: clique
+ * não contabilizava e a pm_url não abria. Observar
+ * UIApplicationDidFinishLaunchingNotification a partir do +load é o momento
+ * mais cedo possível sem exigir uma linha no AppDelegate do cliente — a
+ * premissa zero-config continua de pé.
+ */
+@interface PushMeshApnsBootstrap : NSObject
+@end
+
+@implementation PushMeshApnsBootstrap
+
++ (void)load {
+  // O gancho do setDelegate: entra JÁ (antes de qualquer delegate existir).
+  {
+    Class cls = NSClassFromString(@"PushMeshApns");
+    SEL sel = NSSelectorFromString(@"instalarGanchoSetDelegate");
+    if (cls && [cls respondsToSelector:sel]) {
+      #pragma clang diagnostic push
+      #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+      [cls performSelector:sel];
+      #pragma clang diagnostic pop
+    }
+  }
+  [[NSNotificationCenter defaultCenter]
+      addObserverForName:UIApplicationDidFinishLaunchingNotification
+                  object:nil
+                   queue:[NSOperationQueue mainQueue]
+              usingBlock:^(NSNotification *_Nonnull note) {
+                Class cls = NSClassFromString(@"PushMeshApns");
+                SEL sel = NSSelectorFromString(@"instalarSwizzleDelegate");
+                if (cls && [cls respondsToSelector:sel]) {
+                  // performSelector em classe conhecida e seletor sem argumentos
+                  #pragma clang diagnostic push
+                  #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
+                  [cls performSelector:sel];
+                  #pragma clang diagnostic pop
+                }
+              }];
+}
+
+@end
+
+@interface RCT_EXTERN_MODULE(PushMeshApns, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(register)
+
+RCT_EXTERN_METHOD(getToken:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(perfilDispositivo:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getPendingClick:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+// Atalho direto para a tela de Notificações do app (iOS 16+). Sem esta linha o
+// método existe no Swift e o JS não o enxerga — o SDK cairia sempre no
+// fallback e o conserto não teria efeito nenhum.
+RCT_EXTERN_METHOD(abrirAjustesDeNotificacao:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/PushMeshSwizzleRegistro.swift

@@ -0,0 +1,141 @@
+import Foundation
+import ObjectiveC
+
+/**
+ * REGISTRO DE SWIZZLE — a memória de "quem era o IMP original", POR CLASSE.
+ *
+ * POR QUE ISTO EXISTE (lei nascida de defeito real, 2026-08): o SDK embrulha
+ * os callbacks do delegate (APNs e UNUserNotificationCenter) por method
+ * swizzling — é o preço do zero-config. Guardar o IMP original numa ÚNICA
+ * variável estática funciona enquanto existe UMA classe de delegate na vida do
+ * processo. No mundo real — migração saindo de outro SDK de push, que é o
+ * caminho de produção deste SDK — o delegate TROCA de classe, e aí a estática
+ * única vira bomba:
+ *
+ *   A→B→A ........: embrulhamos a classe A; depois a B (a estática passa a
+ *                   apontar para o original de B); o host volta a pôr um
+ *                   delegate da classe A. Ao re-embrulhar A, o "original" que
+ *                   o runtime devolve É O NOSSO PRÓPRIO BLOCO, instalado ali
+ *                   na primeira vez. Encadear nele = chamar a si mesmo =
+ *                   recursão infinita = stack overflow no app do cliente, no
+ *                   primeiro push que chegar.
+ *   encadeamento ..: o SDK que substitui o delegate costuma GUARDAR o anterior
+ *                   e encaminhar a ele (padrão de mercado). Com a estática
+ *                   única, o bloco instalado na classe A encadeava o IMP de B
+ *                   — corpo de outra classe rodando com `self` de A (layout de
+ *                   ivars errado) — e o ciclo B→A→B se fechava.
+ *
+ * Daí as duas leis desta casa:
+ *   1. o original é lembrado por PAR (classe, seletor) e resolvido pela classe
+ *      do ALVO em tempo de CHAMADA — nunca por "quem foi embrulhado por
+ *      último";
+ *   2. um IMP NOSSO jamais é capturado como "original": todo IMP que
+ *      instalamos fica marcado, então auto-encadeamento é impossível por
+ *      construção, não por disciplina de quem escreve o próximo bloco.
+ *
+ * Aqui NÃO entra UIKit nem React de propósito: só runtime ObjC. É o que
+ * permite compilar esta lógica sozinha e exercitá-la de verdade num binário de
+ * teste — ver `__tests__/ios/cenario_swizzle.swift`, rodado pelo
+ * `__tests__/ios-swizzle.test.ts` (o SDK não tem harness nativo).
+ */
+enum PushMeshSwizzleRegistro {
+
+  /// Par (classe, seletor): a identidade do que embrulhamos. A classe entra
+  /// como ObjectIdentifier (endereço do metatipo) e o seletor como texto —
+  /// ambos estáveis durante todo o processo.
+  private struct Chave: Hashable {
+    let classe: ObjectIdentifier
+    let seletor: String
+
+    init(_ classe: AnyClass, _ seletor: Selector) {
+      self.classe = ObjectIdentifier(classe)
+      self.seletor = NSStringFromSelector(seletor)
+    }
+  }
+
+  /// A instalação roda na main queue, mas a LEITURA acontece dentro do bloco
+  /// swizzlado — e nada garante que todo SDK vizinho respeite a main thread.
+  /// Dicionário/Set corrompido é crash pior que o que estamos consertando.
+  private static let trava = NSLock()
+  private static var originais: [Chave: IMP] = [:]
+  private static var embrulhadas: Set<Chave> = []
+  /// Endereços dos IMPs que NÓS instalamos (lei 2).
+  private static var nossos: Set<UInt> = []
+
+  private static func endereco(_ imp: IMP) -> UInt {
+    UInt(bitPattern: unsafeBitCast(imp, to: UnsafeRawPointer.self))
+  }
+
+  /// true quando o IMP é um bloco NOSSO — o que jamais pode virar "original".
+  static func ehNosso(_ imp: IMP?) -> Bool {
+    guard let imp = imp else { return false }
+    trava.lock()
+    defer { trava.unlock() }
+    return nossos.contains(endereco(imp))
+  }
+
+  /// true quando este par (classe, seletor) já está embrulhado — é o que torna
+  /// o A→B→A um no-op em vez de uma re-captura venenosa.
+  static func jaEmbrulhada(_ classe: AnyClass, _ seletor: Selector) -> Bool {
+    trava.lock()
+    defer { trava.unlock() }
+    return embrulhadas.contains(Chave(classe, seletor))
+  }
+
+  /**
+   * Instala `nossoImp` na classe SEMPRE preservando o original DELA:
+   * - a classe define o método → troca o IMP, original capturado antes;
+   * - a classe só HERDA o método → adiciona override na subclasse (a
+   *   superclasse NÃO é tocada) e o original capturado é o IMP herdado;
+   * - ninguém responde → só adiciona (nada a encadear);
+   * - o IMP que está lá é NOSSO (A→B→A, ou subclasse que herdou nosso bloco)
+   *   → não captura nada: o original verdadeiro já está no registro, sob esta
+   *   classe ou sob alguma ancestral.
+   *
+   * Idempotente por par (classe, seletor): devolve `false` quando não havia
+   * nada a fazer, para quem chama não logar embrulho que não aconteceu.
+   */
+  @discardableResult
+  static func instalar(classe: AnyClass, seletor: Selector, tipos: String, nossoImp: IMP) -> Bool {
+    trava.lock()
+    defer { trava.unlock() }
+
+    let chave = Chave(classe, seletor)
+    guard !embrulhadas.contains(chave) else { return false }
+
+    // marca ANTES de capturar: se o que está instalado for nosso, a captura
+    // abaixo já sabe reconhecer.
+    nossos.insert(endereco(nossoImp))
+
+    let atual: IMP? = class_respondsToSelector(classe, seletor)
+      ? class_getMethodImplementation(classe, seletor)
+      : nil
+    if let atual = atual, !nossos.contains(endereco(atual)) {
+      originais[chave] = atual
+    }
+
+    if !class_addMethod(classe, seletor, nossoImp, tipos),
+       let metodo = class_getInstanceMethod(classe, seletor) {
+      method_setImplementation(metodo, nossoImp)
+    }
+    embrulhadas.insert(chave)
+    return true
+  }
+
+  /**
+   * Resolução PURA a partir da classe em que o bloco foi INSTALADO (o chamador
+   * captura essa classe no embrulho — resolver pela classe do alvo reabria o
+   * ciclo da subclasse que sobrescreve e chama super). Não achando na própria
+   * classe, SOBE a hierarquia: cobre o original registrado num ancestral.
+   */
+  static func original(paraClasse classe: AnyClass?, seletor: Selector) -> IMP? {
+    trava.lock()
+    defer { trava.unlock() }
+    var atual: AnyClass? = classe
+    while let c = atual {
+      if let imp = originais[Chave(c, seletor)] { return imp }
+      atual = class_getSuperclass(c)
+    }
+    return nil
+  }
+}

package/package.json

@@ -0,0 +1,113 @@
+{
+  "name": "@pushmesh/sdk",
+  "version": "0.7.2",
+  "description": "SDK React Native do PUSHMESH — push com recibo real de entrega, reativação de permissão e banners in-app. API clássica inclusa.",
+  "license": "MIT",
+  "private": false,
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/cjs/index.d.ts",
+      "import": "./dist/cjs/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./compat": {
+      "types": "./dist/cjs/compat.d.ts",
+      "import": "./dist/cjs/compat.js",
+      "require": "./dist/cjs/compat.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "pushmesh-doctor": "./dist/cjs/doctor.js"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "android",
+    "ios",
+    "pushmesh-sdk.podspec",
+    "react-native.config.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "https://pushmesh.io",
+  "bugs": {
+    "url": "https://pushmesh.io/suporte"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "prebuild": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.types.json && node scripts/minify.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "jest",
+    "test:types": "tsd",
+    "size": "node scripts/check-size.mjs",
+    "version": "node scripts/sync-versao.mjs",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run build && npm test && npm run test:types && npm run size"
+  },
+  "peerDependencies": {
+    "@notifee/react-native": ">=7.0.0",
+    "@react-native-async-storage/async-storage": ">=1.17.0",
+    "react": ">=17.0.0",
+    "react-native": ">=0.71.0"
+  },
+  "devDependencies": {
+    "@notifee/react-native": "^9.1.8",
+    "@react-native-async-storage/async-storage": "^2.1.2",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.0",
+    "@types/react": "^19.0.0",
+    "@types/react-test-renderer": "^19.0.0",
+    "jest": "^29.7.0",
+    "react": "19.2.0",
+    "react-native": "0.83.1",
+    "react-test-renderer": "19.2.0",
+    "terser": "^5.49.0",
+    "ts-jest": "^29.2.5",
+    "tsd": "^0.31.2",
+    "typescript": "^5.7.0"
+  },
+  "tsd": {
+    "directory": "__tests__/types"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "roots": [
+      "<rootDir>/__tests__"
+    ],
+    "testMatch": [
+      "**/*.test.ts",
+      "**/*.test.tsx"
+    ],
+    "moduleNameMapper": {
+      "^react-native$": "<rootDir>/__mocks__/react-native.ts",
+      "^@notifee/react-native$": "<rootDir>/__mocks__/notifee.ts",
+      "^@react-native-async-storage/async-storage$": "<rootDir>/__mocks__/async-storage.ts"
+    }
+  },
+  "keywords": [
+    "pushmesh",
+    "react-native",
+    "push-notifications",
+    "push",
+    "notifications",
+    "fcm",
+    "apns",
+    "firebase-cloud-messaging",
+    "in-app-messaging",
+    "in-app-message",
+    "delivery-receipt",
+    "android",
+    "ios",
+    "sdk"
+  ]
+}

package/pushmesh-sdk.podspec

@@ -0,0 +1,32 @@
+require 'json'
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+# Podspec do SDK PUSHMESH — modo zero-config iOS: APNs DIRETO.
+# NENHUMA dependency de Firebase (essa é a feature): o servidor envia push
+# via APNs HTTP/2 com a .p8 cadastrada no painel; o app só precisa da
+# capability Push Notifications.
+Pod::Spec.new do |s|
+  s.name         = "pushmesh-sdk"
+  s.version      = package["version"]
+  s.summary      = "SDK React Native do PUSHMESH — push com recibo real de entrega, zero-config (Android FCM por código, iOS APNs direto)."
+  s.homepage     = "https://pushmesh.io"
+  s.license      = package["license"]
+  s.authors      = "PushMesh"
+  s.platforms    = { :ios => min_ios_version_supported } # alinha com o mínimo exigido pelo RN do host (15.1 no RN 0.83)
+  # O autolinking do RN instala este pod por CAMINHO (react-native.config.js →
+  # podspecPath), a partir do que o npm já baixou em node_modules — o `source`
+  # nunca é buscado nessa rota. Ele aponta para o tarball do npm (a distribuição
+  # oficial) só para o podspec ser válido fora do autolinking.
+  s.source       = {
+    :http => "https://registry.npmjs.org/#{package['name']}/-/sdk-#{s.version}.tgz",
+  }
+  s.source_files = "ios/**/*.{swift,h,m,mm}"
+  # A Notification Service Extension NÃO entra no pod do app: ela é um ALVO
+  # SEPARADO do Xcode (outro processo, outro binário). Sem esta exclusão o
+  # glob acima a compilaria dentro do app — código morto no app, e a extensão
+  # continuaria sem existir onde precisa. Instalação: ios/NotificationService/LEIA-ME.md
+  s.exclude_files = "ios/NotificationService/**/*"
+  s.swift_version = "5.0"
+
+  s.dependency "React-Core"
+end

package/react-native.config.js

@@ -0,0 +1,17 @@
+/**
+ * Autolinking dos módulos nativos do modo zero-config:
+ * Android (Firebase por código) e iOS (APNs direto, sem Firebase).
+ */
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android',
+        packageImportPath: 'import io.pushmesh.sdk.PushMeshFirebasePackage;',
+      },
+      ios: {
+        podspecPath: './pushmesh-sdk.podspec',
+      },
+    },
+  },
+};