capacitor-google-tag-manager 0.1.0

package/CapacitorGoogleTagManager.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name = 'CapacitorGoogleTagManager'
+  s.version = package['version']
+  s.summary = package['description']
+  s.license = package['license']
+  s.homepage = package['repository']['url']
+  s.author = package['author']
+  s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
+  s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}'
+  s.public_header_files = 'ios/Sources/GoogleTagManagerLinkage/include/*.h'
+  s.ios.deployment_target = '15.0'
+  s.dependency 'Capacitor'
+  # Any 9.x from 9.1.0, as in Package.swift. An app pins another one in its Podfile: pod 'GoogleTagManager', '9.3.0'
+  s.dependency 'GoogleTagManager', '~> 9.1'
+  s.swift_version = '5.9'
+end

package/Package.swift

@@ -0,0 +1,41 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+// The plugin's job is the dependency on Google's Tag Manager package: an app that installs the plugin gets the SDK linked
+// in, with the Firebase Analytics it depends on. Any 9.x is accepted; the app's Package.resolved records which one it
+// builds with, and the app moves it (Xcode's File > Packages > Update to Latest Package Versions, or an edit of
+// Package.resolved) without a release of this plugin.
+let package = Package(
+    name: "CapacitorGoogleTagManager",
+    platforms: [.iOS(.v15)],
+    products: [
+        .library(
+            name: "CapacitorGoogleTagManager",
+            targets: ["GoogleTagManagerPlugin"])
+    ],
+    dependencies: [
+        .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"),
+        .package(url: "https://github.com/googleanalytics/google-tag-manager-ios-sdk.git", "9.1.0"..<"10.0.0")
+    ],
+    targets: [
+        // References the SDK's classes so the linker takes its static archive into the app (see the .m file).
+        .target(
+            name: "GoogleTagManagerLinkage",
+            dependencies: [
+                .product(name: "GoogleTagManager", package: "google-tag-manager-ios-sdk")
+            ],
+            path: "ios/Sources/GoogleTagManagerLinkage"),
+        .target(
+            name: "GoogleTagManagerPlugin",
+            dependencies: [
+                "GoogleTagManagerLinkage",
+                .product(name: "Capacitor", package: "capacitor-swift-pm"),
+                .product(name: "Cordova", package: "capacitor-swift-pm")
+            ],
+            path: "ios/Sources/GoogleTagManagerPlugin"),
+        .testTarget(
+            name: "GoogleTagManagerPluginTests",
+            dependencies: ["GoogleTagManagerPlugin"],
+            path: "ios/Tests/GoogleTagManagerPluginTests")
+    ]
+)

package/README.md

@@ -0,0 +1,142 @@
+# capacitor-google-tag-manager
+
+Brings the [Google Tag Manager](https://developers.google.com/tag-platform/tag-manager) SDK into a Capacitor 8 app, on
+Android and iOS, so that a Tag Manager container the app ships is loaded and acts on the app's Firebase Analytics events.
+
+Tag Manager for Firebase has no API to call: once the SDK is linked into the app it finds the container and the Analytics
+events by itself. What it needs from a Capacitor app is to be in the native build, and that is all this plugin does. The
+one method it adds, `isAvailable`, tells from the web view whether the SDK made it into the build, because a build without
+it runs, ships its container and says nothing.
+
+## Install
+
+```bash
+npm install capacitor-google-tag-manager
+npx cap sync
+```
+
+Requires Capacitor 8, Android 8.0 (API 26) or newer and iOS 15 or newer. The SDK depends on Firebase Analytics, so the app
+needs Firebase set up as usual (for example with `@capacitor-firebase/analytics`); this plugin does not configure it.
+
+| Platform | What the plugin adds                                                                                                                                                                |
+| -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Android  | `com.google.android.gms:play-services-tagmanager`, 18.3.0 by default. The SDK's own manifest declares `TagManagerPreviewActivity` with the `tagmanager.c.<application id>` scheme. |
+| iOS      | Google's `google-tag-manager-ios-sdk` Swift package, any 9.x from 9.1.0, or the `GoogleTagManager` pod `~> 9.1` with CocoaPods; Firebase Analytics comes with either.              |
+| Web      | Nothing. A web build that wants Tag Manager loads gtm.js itself; `isAvailable` answers `false`.                                                                                     |
+
+### What stays in the app
+
+The plugin brings the SDK and nothing that belongs to one app:
+
+- **The container.** Export it from Tag Manager and put it where the SDK looks:
+  - Android: `android/app/src/main/assets/containers/GTM-XXXXXXX.json`.
+  - iOS: a folder reference named `container` in the app target's resources, holding `GTM-XXXXXXX.json`.
+- **The iOS preview scheme.** Tag Manager's preview opens the app through `tagmanager.c.<bundle id>`, which iOS learns
+  only from the app's `Info.plist`:
+
+  ```xml
+  <key>CFBundleURLTypes</key>
+  <array>
+    <dict>
+      <key>CFBundleURLName</key>
+      <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+      <key>CFBundleURLSchemes</key>
+      <array>
+        <string>tagmanager.c.$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+      </array>
+    </dict>
+  </array>
+  ```
+
+  On Android nothing is needed: the manifest merge puts the application id into the SDK's own preview activity.
+
+### Choosing the SDK version
+
+- **Android:** set `playServicesTagManagerVersion` in the app's `android/variables.gradle`:
+
+  ```groovy
+  ext {
+      playServicesTagManagerVersion = '18.3.0'
+  }
+  ```
+
+- **iOS, Swift Package Manager:** the plugin accepts any 9.x from 9.1.0, and the version the app builds with is the one in
+  its `Package.resolved` (`ios/App/App.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved`). Commit that
+  file, and move the version with Xcode's File > Packages > Update to Latest Package Versions, or by editing the pin and
+  resolving again (`xcodebuild -resolvePackageDependencies`). `npx cap sync` regenerates the app's `CapApp-SPM` package but
+  leaves `Package.resolved` alone, so the pin survives a sync.
+- **iOS, CocoaPods:** pin it in the `Podfile`: `pod 'GoogleTagManager', '9.1.0'`.
+
+The app should not declare the SDK itself as well: the plugin's declaration is the only one needed.
+
+### Why declaring the iOS SDK is not enough
+
+Google ships the iOS SDK as a static archive, and an app never calls it: `TAGManager` starts itself from `+load`. A linker
+takes a member of a static archive only when something references a symbol it defines, and Swift Package Manager links
+without `-ObjC`, so an app that merely depends on the package gets the SDK's (empty) framework folder in its bundle and
+none of its code. The plugin's `GoogleTagManagerLinkage` target references every class the SDK exports, which makes the
+linker take them; `isAvailable` then looks each of them up in the running app. CocoaPods links with `-ObjC` and is
+unaffected either way.
+
+## Use
+
+```typescript
+import { GoogleTagManager } from 'capacitor-google-tag-manager';
+
+const { available } = await GoogleTagManager.isAvailable();
+```
+
+## Development
+
+- `npm test` runs the TypeScript unit tests, `npm run test:parity` checks that both platforms implement exactly the API.
+- `npm run test:android` runs the JVM tests, which also find the SDK on the plugin's class path.
+- `npm run test:ios` runs the XCTest target on an iOS simulator, which also finds the SDK in the test binary.
+- `npm run example:android:build` and `npm run example:ios:build` build `example-app/`, a page that calls `isAvailable`, the
+  way an app installs the plugin.
+
+## API
+
+<docgen-index>
+
+* [`isAvailable()`](#isavailable)
+* [Interfaces](#interfaces)
+
+</docgen-index>
+
+<docgen-api>
+<!--Update the source file JSDoc comments and rerun docgen to update the docs below-->
+
+The plugin's job is to bring the Google Tag Manager SDK into the app's native build. The SDK then loads the container the
+app ships and acts on Firebase Analytics events by itself; it has no JavaScript API, and neither does this plugin beyond
+the one check below.
+
+### isAvailable()
+
+```typescript
+isAvailable() => Promise<AvailabilityResult>
+```
+
+Whether the Tag Manager SDK made it into the running app.
+
+A build that lost the SDK still runs, ships its container and logs nothing: the container is simply never loaded. This
+is the check that tells such a build apart from a healthy one, from the web view.
+
+**Returns:** <code>Promise&lt;<a href="#availabilityresult">AvailabilityResult</a>&gt;</code>
+
+**Since:** 0.1.0
+
+--------------------
+
+
+### Interfaces
+
+
+#### AvailabilityResult
+
+What `isAvailable` answers.
+
+| Prop            | Type                 | Description                                                                                                                                                                                                         |
+| --------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`available`** | <code>boolean</code> | `true` when the Google Tag Manager SDK's classes are in the running app: `TAGManager` on iOS, `com.google.android.gms.tagmanager.TagManagerService` on Android. Always `false` on the web, which has no native SDK. |
+
+</docgen-api>

package/android/build.gradle

@@ -0,0 +1,64 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    // The Tag Manager SDK this plugin brings. An app that needs another version sets playServicesTagManagerVersion in its
+    // variables.gradle, the way it sets the Capacitor versions; Gradle resolves one version for the whole app either way.
+    playServicesTagManagerVersion = project.hasProperty('playServicesTagManagerVersion') ? rootProject.ext.playServicesTagManagerVersion : '18.3.0'
+}
+
+buildscript {
+    ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '2.2.20'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:9.5.1'
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace = "io.github.maximbelov.googletagmanager"
+    compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 26
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36
+        versionCode 1
+        versionName "1.0"
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+    lintOptions {
+        abortOnError = false
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    // The whole point of the plugin. Its manifest (play-services-tagmanager-api) declares TagManagerService and
+    // TagManagerPreviewActivity, the latter with the tagmanager.c.${applicationId} scheme, which the app's manifest merge
+    // resolves to the app's own id, so the plugin's manifest repeats neither.
+    implementation "com.google.android.gms:play-services-tagmanager:$playServicesTagManagerVersion"
+    testImplementation "junit:junit:$junitVersion"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <!--
+      Nothing to declare here. The Tag Manager SDK's own manifest (play-services-tagmanager-api) brings TagManagerService,
+      the INTERNET and ACCESS_NETWORK_STATE permissions, and TagManagerPreviewActivity with its
+      tagmanager.c.${applicationId} scheme, and the app's manifest merge puts the app's id into that scheme. A second
+      declaration of the activity here would only be merged into the same element.
+    -->
+</manifest>

package/android/src/main/kotlin/io/github/maximbelov/googletagmanager/GoogleTagManagerPlugin.kt

@@ -0,0 +1,34 @@
+package io.github.maximbelov.googletagmanager
+
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+
+/**
+ * Google Tag Manager on Android. The plugin exists to put play-services-tagmanager into the app: the SDK finds the
+ * container in assets/containers and the Firebase Analytics events on its own, and its manifest brings the preview
+ * activity. What is left for the web view is the one question of whether the SDK is there.
+ */
+@CapacitorPlugin(name = "GoogleTagManager")
+class GoogleTagManagerPlugin : Plugin() {
+    @PluginMethod
+    fun isAvailable(call: PluginCall) {
+        call.resolve(JSObject().put("available", TagManagerSdk.isLinked(javaClass.classLoader)))
+    }
+}
+
+/** Whether the Tag Manager SDK's classes are on the app's class path. */
+object TagManagerSdk {
+    /** A class the SDK has had since it moved to Google Play services, and the one its manifest names as a service. */
+    const val SERVICE_CLASS = "com.google.android.gms.tagmanager.TagManagerService"
+
+    fun isLinked(loader: ClassLoader?, className: String = SERVICE_CLASS): Boolean =
+        try {
+            Class.forName(className, false, loader)
+            true
+        } catch (_: ClassNotFoundException) {
+            false
+        }
+}

package/dist/docs.json

@@ -0,0 +1,49 @@
+{
+  "api": {
+    "name": "GoogleTagManagerPlugin",
+    "slug": "googletagmanagerplugin",
+    "docs": "The plugin's job is to bring the Google Tag Manager SDK into the app's native build. The SDK then loads the container the\napp ships and acts on Firebase Analytics events by itself; it has no JavaScript API, and neither does this plugin beyond\nthe one check below.",
+    "tags": [],
+    "methods": [
+      {
+        "name": "isAvailable",
+        "signature": "() => Promise<AvailabilityResult>",
+        "parameters": [],
+        "returns": "Promise<AvailabilityResult>",
+        "tags": [
+          {
+            "name": "since",
+            "text": "0.1.0"
+          }
+        ],
+        "docs": "Whether the Tag Manager SDK made it into the running app.\n\nA build that lost the SDK still runs, ships its container and logs nothing: the container is simply never loaded. This\nis the check that tells such a build apart from a healthy one, from the web view.",
+        "complexTypes": [
+          "AvailabilityResult"
+        ],
+        "slug": "isavailable"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "AvailabilityResult",
+      "slug": "availabilityresult",
+      "docs": "What `isAvailable` answers.",
+      "tags": [],
+      "methods": [],
+      "properties": [
+        {
+          "name": "available",
+          "tags": [],
+          "docs": "`true` when the Google Tag Manager SDK's classes are in the running app: `TAGManager` on iOS,\n`com.google.android.gms.tagmanager.TagManagerService` on Android. Always `false` on the web, which has no native SDK.",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [],
+  "pluginConfigs": []
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * What `isAvailable` answers.
+ */
+export interface AvailabilityResult {
+    /**
+     * `true` when the Google Tag Manager SDK's classes are in the running app: `TAGManager` on iOS,
+     * `com.google.android.gms.tagmanager.TagManagerService` on Android. Always `false` on the web, which has no native SDK.
+     */
+    available: boolean;
+}
+/**
+ * The plugin's job is to bring the Google Tag Manager SDK into the app's native build. The SDK then loads the container the
+ * app ships and acts on Firebase Analytics events by itself; it has no JavaScript API, and neither does this plugin beyond
+ * the one check below.
+ */
+export interface GoogleTagManagerPlugin {
+    /**
+     * Whether the Tag Manager SDK made it into the running app.
+     *
+     * A build that lost the SDK still runs, ships its container and logs nothing: the container is simply never loaded. This
+     * is the check that tells such a build apart from a healthy one, from the web view.
+     *
+     * @since 0.1.0
+     */
+    isAvailable(): Promise<AvailabilityResult>;
+}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * What `isAvailable` answers.\n */\nexport interface AvailabilityResult {\n  /**\n   * `true` when the Google Tag Manager SDK's classes are in the running app: `TAGManager` on iOS,\n   * `com.google.android.gms.tagmanager.TagManagerService` on Android. Always `false` on the web, which has no native SDK.\n   */\n  available: boolean;\n}\n\n/**\n * The plugin's job is to bring the Google Tag Manager SDK into the app's native build. The SDK then loads the container the\n * app ships and acts on Firebase Analytics events by itself; it has no JavaScript API, and neither does this plugin beyond\n * the one check below.\n */\nexport interface GoogleTagManagerPlugin {\n  /**\n   * Whether the Tag Manager SDK made it into the running app.\n   *\n   * A build that lost the SDK still runs, ships its container and logs nothing: the container is simply never loaded. This\n   * is the check that tells such a build apart from a healthy one, from the web view.\n   *\n   * @since 0.1.0\n   */\n  isAvailable(): Promise<AvailabilityResult>;\n}\n"]}

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { GoogleTagManagerPlugin } from './definitions';
+declare const GoogleTagManager: GoogleTagManagerPlugin;
+export * from './definitions';
+export { GoogleTagManager };

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const GoogleTagManager = registerPlugin('GoogleTagManager', {
+    web: () => import('./web').then((m) => new m.GoogleTagManagerWeb()),
+});
+export * from './definitions';
+export { GoogleTagManager };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAIjD,MAAM,gBAAgB,GAAG,cAAc,CAAyB,kBAAkB,EAAE;IAClF,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;CACpE,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,CAAC","sourcesContent":["import { registerPlugin } from '@capacitor/core';\n\nimport type { GoogleTagManagerPlugin } from './definitions';\n\nconst GoogleTagManager = registerPlugin<GoogleTagManagerPlugin>('GoogleTagManager', {\n  web: () => import('./web').then((m) => new m.GoogleTagManagerWeb()),\n});\n\nexport * from './definitions';\nexport { GoogleTagManager };\n"]}

package/dist/esm/web.d.ts

@@ -0,0 +1,9 @@
+import { WebPlugin } from '@capacitor/core';
+import type { AvailabilityResult, GoogleTagManagerPlugin } from './definitions';
+/**
+ * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.
+ * A web build that wants Tag Manager loads gtm.js itself.
+ */
+export declare class GoogleTagManagerWeb extends WebPlugin implements GoogleTagManagerPlugin {
+    isAvailable(): Promise<AvailabilityResult>;
+}

package/dist/esm/web.js

@@ -0,0 +1,11 @@
+import { WebPlugin } from '@capacitor/core';
+/**
+ * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.
+ * A web build that wants Tag Manager loads gtm.js itself.
+ */
+export class GoogleTagManagerWeb extends WebPlugin {
+    async isAvailable() {
+        return { available: false };
+    }
+}
+//# sourceMappingURL=web.js.map

package/dist/esm/web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.js","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C;;;GAGG;AACH,MAAM,OAAO,mBAAoB,SAAQ,SAAS;IAChD,KAAK,CAAC,WAAW;QACf,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;IAC9B,CAAC;CACF","sourcesContent":["import { WebPlugin } from '@capacitor/core';\n\nimport type { AvailabilityResult, GoogleTagManagerPlugin } from './definitions';\n\n/**\n * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.\n * A web build that wants Tag Manager loads gtm.js itself.\n */\nexport class GoogleTagManagerWeb extends WebPlugin implements GoogleTagManagerPlugin {\n  async isAvailable(): Promise<AvailabilityResult> {\n    return { available: false };\n  }\n}\n"]}

package/dist/plugin.cjs.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+const GoogleTagManager = core.registerPlugin('GoogleTagManager', {
+    web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.GoogleTagManagerWeb()),
+});
+
+/**
+ * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.
+ * A web build that wants Tag Manager loads gtm.js itself.
+ */
+class GoogleTagManagerWeb extends core.WebPlugin {
+    async isAvailable() {
+        return { available: false };
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    GoogleTagManagerWeb: GoogleTagManagerWeb
+});
+
+exports.GoogleTagManager = GoogleTagManager;
+//# sourceMappingURL=plugin.cjs.js.map

package/dist/plugin.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.cjs.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst GoogleTagManager = registerPlugin('GoogleTagManager', {\n    web: () => import('./web').then((m) => new m.GoogleTagManagerWeb()),\n});\nexport * from './definitions';\nexport { GoogleTagManager };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\n/**\n * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.\n * A web build that wants Tag Manager loads gtm.js itself.\n */\nexport class GoogleTagManagerWeb extends WebPlugin {\n    async isAvailable() {\n        return { available: false };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;;AACK,MAAC,gBAAgB,GAAGA,mBAAc,CAAC,kBAAkB,EAAE;AAC5D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;AACvE,CAAC;;ACFD;AACA;AACA;AACA;AACO,MAAM,mBAAmB,SAASC,cAAS,CAAC;AACnD,IAAI,MAAM,WAAW,GAAG;AACxB,QAAQ,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE;AACnC,IAAI;AACJ;;;;;;;"}

package/dist/plugin.js

@@ -0,0 +1,28 @@
+var capacitorGoogleTagManager = (function (exports, core) {
+    'use strict';
+
+    const GoogleTagManager = core.registerPlugin('GoogleTagManager', {
+        web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.GoogleTagManagerWeb()),
+    });
+
+    /**
+     * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.
+     * A web build that wants Tag Manager loads gtm.js itself.
+     */
+    class GoogleTagManagerWeb extends core.WebPlugin {
+        async isAvailable() {
+            return { available: false };
+        }
+    }
+
+    var web = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        GoogleTagManagerWeb: GoogleTagManagerWeb
+    });
+
+    exports.GoogleTagManager = GoogleTagManager;
+
+    return exports;
+
+})({}, capacitorExports);
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sources":["esm/index.js","esm/web.js"],"sourcesContent":["import { registerPlugin } from '@capacitor/core';\nconst GoogleTagManager = registerPlugin('GoogleTagManager', {\n    web: () => import('./web').then((m) => new m.GoogleTagManagerWeb()),\n});\nexport * from './definitions';\nexport { GoogleTagManager };\n//# sourceMappingURL=index.js.map","import { WebPlugin } from '@capacitor/core';\n/**\n * A browser has no native Tag Manager SDK, so the answer is `false` rather than an error: the question has an answer here.\n * A web build that wants Tag Manager loads gtm.js itself.\n */\nexport class GoogleTagManagerWeb extends WebPlugin {\n    async isAvailable() {\n        return { available: false };\n    }\n}\n//# sourceMappingURL=web.js.map"],"names":["registerPlugin","WebPlugin"],"mappings":";;;AACK,UAAC,gBAAgB,GAAGA,mBAAc,CAAC,kBAAkB,EAAE;IAC5D,IAAI,GAAG,EAAE,MAAM,mDAAe,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,CAAC,mBAAmB,EAAE,CAAC;IACvE,CAAC;;ICFD;IACA;IACA;IACA;IACO,MAAM,mBAAmB,SAASC,cAAS,CAAC;IACnD,IAAI,MAAM,WAAW,GAAG;IACxB,QAAQ,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE;IACnC,IAAI;IACJ;;;;;;;;;;;"}

package/ios/Sources/GoogleTagManagerLinkage/GoogleTagManagerLinkage.m

@@ -0,0 +1,49 @@
+#import "GoogleTagManagerLinkage.h"
+
+// The Tag Manager SDK ships as a static archive, and nothing in an app calls it: TAGManager starts itself from +load and
+// then follows Firebase Analytics. A linker takes an archive member only when something references a symbol it defines,
+// and an app linked without -ObjC (Swift Package Manager adds none) therefore takes none of it. The archive's framework
+// directory still lands in the bundle, so the build looks complete while the SDK, and with it the container, is absent.
+//
+// So every class the archive exports is referenced here. The SDK publishes no headers for them, which is why they are
+// declared below, bare: the declarations only give the compiler a name, and each `[X class]` leaves an undefined
+// `_OBJC_CLASS_$_X` that the linker must resolve from the archive. CocoaPods links with -ObjC anyway; this costs it nothing.
+@interface TAGContainer : NSObject
+@end
+@interface TAGContainerLoader : NSObject
+@end
+@interface TAGDispatchScheduler : NSObject
+@end
+@interface TAGHit : NSObject
+@end
+@interface TAGHitSender : NSObject
+@end
+@interface TAGHitStore : NSObject
+@end
+@interface TAGJSExportedInstructions : NSObject
+@end
+@interface TAGLogger : NSObject
+@end
+@interface TAGManager : NSObject
+@end
+@interface TAGNetReachability : NSObject
+@end
+@interface TAGPendingEvent : NSObject
+@end
+@interface TAGRuntime : NSObject
+@end
+@interface TAGUniversalAnalytics : NSObject
+@end
+
+NSArray<NSString *> *GoogleTagManagerLinkedClassNames(void) {
+    NSArray<Class> *classes = @[
+        [TAGContainer class], [TAGContainerLoader class], [TAGDispatchScheduler class], [TAGHit class], [TAGHitSender class],
+        [TAGHitStore class], [TAGJSExportedInstructions class], [TAGLogger class], [TAGManager class],
+        [TAGNetReachability class], [TAGPendingEvent class], [TAGRuntime class], [TAGUniversalAnalytics class]
+    ];
+    NSMutableArray<NSString *> *names = [NSMutableArray arrayWithCapacity:classes.count];
+    for (Class cls in classes) {
+        [names addObject:NSStringFromClass(cls)];
+    }
+    return names;
+}

package/ios/Sources/GoogleTagManagerLinkage/include/GoogleTagManagerLinkage.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// The names of the Tag Manager SDK classes this target links into the app, in the order it references them.
+FOUNDATION_EXPORT NSArray<NSString *> *GoogleTagManagerLinkedClassNames(void);
+
+NS_ASSUME_NONNULL_END

package/ios/Sources/GoogleTagManagerPlugin/GoogleTagManagerPlugin.swift

@@ -0,0 +1,35 @@
+import Foundation
+import Capacitor
+#if canImport(GoogleTagManagerLinkage)
+import GoogleTagManagerLinkage
+#endif
+
+/// Whether the Tag Manager SDK's classes are in the running app.
+enum TagManagerSdk {
+    /// The classes the plugin links in. Calling this is also what keeps the linkage in the binary.
+    static var linkedClassNames: [String] {
+        GoogleTagManagerLinkedClassNames()
+    }
+
+    /// Asks the Objective-C runtime, by name, for every class the plugin links in, so the answer reflects the binary
+    /// that is running rather than what the plugin was compiled against.
+    static func isLinked(classNames: [String] = linkedClassNames) -> Bool {
+        !classNames.isEmpty && classNames.allSatisfy { NSClassFromString($0) != nil }
+    }
+}
+
+/// Google Tag Manager on iOS. The plugin exists to link the SDK into the app: the SDK finds the container in the app's
+/// `container` folder and the Firebase Analytics events on its own, and handles the `tagmanager.c.<bundle id>` preview
+/// links the app's Info.plist registers. What is left for the web view is the one question of whether the SDK is there.
+@objc(GoogleTagManagerPlugin)
+public class GoogleTagManagerPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "GoogleTagManagerPlugin"
+    public let jsName = "GoogleTagManager"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "isAvailable", returnType: CAPPluginReturnPromise)
+    ]
+
+    @objc func isAvailable(_ call: CAPPluginCall) {
+        call.resolve(["available": TagManagerSdk.isLinked()])
+    }
+}

package/ios/Tests/GoogleTagManagerPluginTests/GoogleTagManagerPluginTests.swift

@@ -0,0 +1,33 @@
+import XCTest
+import Capacitor
+@testable import GoogleTagManagerPlugin
+
+/// The JavaScript reaches the plugin by `jsName` and each method by its name: a rename on either side fails only at run
+/// time on a phone, so both are pinned here.
+final class GoogleTagManagerPluginTests: XCTestCase {
+    func testIsRegisteredUnderTheNameTheJavaScriptUses() {
+        let plugin = GoogleTagManagerPlugin()
+        XCTAssertEqual(plugin.jsName, "GoogleTagManager")
+        XCTAssertEqual(plugin.identifier, "GoogleTagManagerPlugin")
+    }
+
+    func testRegistersExactlyTheMethodsOfTheApi() {
+        let names = GoogleTagManagerPlugin().pluginMethods.map(\.name).sorted()
+        XCTAssertEqual(names, ["isAvailable"])
+        for name in names {
+            XCTAssertTrue(GoogleTagManagerPlugin().responds(to: NSSelectorFromString("\(name):")), "no @objc \(name)(_:)")
+        }
+    }
+
+    /// The test bundle links the plugin the way an app does, so the SDK has to be found here: a dependency that is
+    /// declared but never reaches the binary fails this rather than a phone.
+    func testFindsTheSdkInTheBinary() {
+        XCTAssertTrue(TagManagerSdk.linkedClassNames.contains("TAGManager"))
+        XCTAssertTrue(TagManagerSdk.isLinked())
+    }
+
+    func testReportsAClassThatIsNotThereAsMissing() {
+        XCTAssertFalse(TagManagerSdk.isLinked(classNames: ["TAGManager", "TAGNoSuchClass"]))
+        XCTAssertFalse(TagManagerSdk.isLinked(classNames: []))
+    }
+}

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "capacitor-google-tag-manager",
+  "version": "0.1.0",
+  "description": "Brings the Google Tag Manager SDK into a Capacitor app on Android and iOS, with its preview activity, so a container shipped with the app is loaded",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "CapacitorGoogleTagManager.podspec"
+  ],
+  "author": "Maxim Belov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MaximBelov/capacitor-google-tag-manager.git"
+  },
+  "bugs": {
+    "url": "https://github.com/MaximBelov/capacitor-google-tag-manager/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "google-tag-manager",
+    "gtm",
+    "tag-manager",
+    "firebase-analytics"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild build -scheme CapacitorGoogleTagManager -destination generic/platform=iOS -derivedDataPath build/ios-device",
+    "verify:android": "cd android && ./gradlew clean build test",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api GoogleTagManagerPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "npm run test:unit",
+    "test:unit": "vitest run",
+    "test:unit:coverage": "vitest run --coverage",
+    "test:parity": "node --test test/unit/platform-parity.test.mjs",
+    "test:android": "cd android && ./gradlew test",
+    "test:ios": "./scripts/test-ios.sh",
+    "example:install": "cd example-app && npm install --no-audit --no-fund",
+    "example:android:build": "npm run example:install && cd example-app && npm run build && npx cap sync android && cd android && ./gradlew assembleDebug",
+    "example:ios:build": "npm run example:install && cd example-app && npm run build && npx cap sync ios && xcodebuild build -project ios/App/App.xcodeproj -scheme App -destination generic/platform=iOS -derivedDataPath ../build/example-ios CODE_SIGNING_ALLOWED=NO"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.3.1",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.5.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^10.14.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-java": "^2.7.7",
+    "rimraf": "^6.1.0",
+    "rollup": "^4.53.2",
+    "swiftlint": "^2.0.0",
+    "typescript": "~6.0.3",
+    "@vitest/coverage-v8": "^5.1.0",
+    "vitest": "^5.1.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}