@capacitor-community/admob 8.1.0 → 8.2.0-beta.pr454.sha49386d40323a

package/dist/esm/native-ads/native-ad-feed.d.ts

@@ -0,0 +1,72 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+import type { NativeAdDefinitions } from './native-ad-definitions.interface';
+import type { NativeAdEvent, NativeAdErrorEvent, NativeAdRevenueEvent } from './native-ad-event.interface';
+import type { NativeAdFeedOptions } from './native-ad-options.interface';
+import type { NativeAdPluginEvents } from './native-ad-plugin-events.enum';
+/**
+ * Experimental manager for native-ad integration research.
+ *
+ * A stable `slotKey`, rather than the element or array index, owns the native
+ * ad lifecycle. Virtual-scroller compatibility has not yet been validated.
+ *
+ * @experimental Native overlay gesture routing is still being validated on devices.
+ */
+export declare class NativeAdFeed {
+    private readonly options;
+    private readonly nativeScrollElement?;
+    private readonly sessionId;
+    private readonly slots;
+    private readonly elementSlots;
+    private readonly scrollRoots;
+    private readonly intersectionObserver?;
+    private readonly resizeObserver?;
+    private destroyed;
+    private nativeStarted;
+    private paused;
+    private layoutInvalidated;
+    private placementFrame?;
+    private lastPlacements?;
+    private lastPlacementWasDirect;
+    private placementAcknowledgementRequired;
+    private settleTimer?;
+    private placementUpdateTask?;
+    private operationTask;
+    private destroyTask?;
+    private updateDirty;
+    private placementSequence;
+    private readonly listenerHandles;
+    private constructor();
+    static create(options: NativeAdFeedOptions): Promise<NativeAdFeed>;
+    get feedId(): string;
+    addListener(eventName: NativeAdPluginEvents.Loaded | NativeAdPluginEvents.Clicked | NativeAdPluginEvents.AdImpression | NativeAdPluginEvents.Opened | NativeAdPluginEvents.Closed, listener: (event: NativeAdEvent) => void): Promise<PluginListenerHandle>;
+    addListener(eventName: NativeAdPluginEvents.FailedToLoad, listener: (event: NativeAdErrorEvent) => void): Promise<PluginListenerHandle>;
+    addListener(eventName: NativeAdPluginEvents.AdPaid, listener: (event: NativeAdRevenueEvent) => void): Promise<PluginListenerHandle>;
+    attach(slotKey: string, element: HTMLElement): void;
+    detach(element: HTMLElement): void;
+    reload(slotKey: string): Promise<void>;
+    /** Immediately hides this feed's overlays until {@link resume} is called. */
+    pause(): Promise<void>;
+    /** Re-evaluates slots and restores eligible overlays after the viewport settles. */
+    resume(): void;
+    /** Hides stale overlays and remeasures after an application-driven layout change. */
+    invalidateLayout(): Promise<void>;
+    destroy(): Promise<void>;
+    private readonly handleViewportMotion;
+    private schedulePlacementUpdate;
+    private updateScrollRoots;
+    private readonly handleVisibilityChange;
+    private scheduleEvaluation;
+    private evaluate;
+    private loadState;
+    private evictUnusedAds;
+    private occupiesNativeAd;
+    private getVisibleStates;
+    private isSupportedSize;
+    private removeStateAd;
+    private runOperation;
+    private destroyResources;
+    private requestPlacementUpdate;
+    private flushPlacementUpdates;
+    private assertActive;
+}
+export declare const configureNativeAdBridge: (adMobBridge: NativeAdDefinitions) => void;

package/dist/esm/native-ads/native-ad-feed.js

@@ -0,0 +1,568 @@
+import { Capacitor } from '@capacitor/core';
+import { connectNativeAdElements, defineNativeAdElement } from './native-ad-element';
+import { measureNativeAdSlot, measureNativeAdScrollContainer, nativeAdAncestors } from './native-ad-geometry';
+import { NativeAdTemplate } from './native-ad-template.enum';
+const SCROLL_SETTLE_MS = 120;
+const MAX_NATIVE_ADS = 3;
+const MAX_ACTIVE_FEEDS = 2;
+const MIN_SMALL_SLOT_WIDTH = 120;
+const MIN_MEDIUM_SLOT_WIDTH = 144;
+const MIN_MEDIUM_SLOT_HEIGHT = 300;
+const MIN_SMALL_SLOT_HEIGHT = 120;
+const TEMPLATE_ATTRIBUTE = 'data-capacitor-admob-template';
+const applySlotDefaults = (element, template) => {
+    const root = element.getRootNode();
+    const container = root instanceof ShadowRoot ? root : element.ownerDocument.head;
+    if (!container.querySelector('style[data-capacitor-admob-defaults]')) {
+        const style = element.ownerDocument.createElement('style');
+        style.setAttribute('data-capacitor-admob-defaults', '');
+        // Prefer the first cascade layer; older WebViews use zero-specificity rules.
+        const defaults = `
+      :where([${TEMPLATE_ATTRIBUTE}]) { display: block; height: 320px; }
+      :where([${TEMPLATE_ATTRIBUTE}="small"]) { height: 120px; }
+    `;
+        style.textContent =
+            'CSSLayerBlockRule' in globalThis ? `@layer capacitor-admob-defaults { ${defaults} }` : defaults;
+        container.prepend(style);
+    }
+    element.setAttribute(TEMPLATE_ATTRIBUTE, template);
+};
+let bridge;
+let sessionSequence = 0;
+const feeds = new Map();
+const createSessionId = () => { var _a, _b, _c; return (_c = (_b = (_a = globalThis.crypto) === null || _a === void 0 ? void 0 : _a.randomUUID) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : `${Date.now()}-${++sessionSequence}-${Math.random().toString(36).slice(2)}`; };
+/**
+ * Experimental manager for native-ad integration research.
+ *
+ * A stable `slotKey`, rather than the element or array index, owns the native
+ * ad lifecycle. Virtual-scroller compatibility has not yet been validated.
+ *
+ * @experimental Native overlay gesture routing is still being validated on devices.
+ */
+export class NativeAdFeed {
+    constructor(options) {
+        var _a;
+        this.sessionId = createSessionId();
+        this.slots = new Map();
+        this.elementSlots = new Map();
+        this.scrollRoots = new Set();
+        this.destroyed = false;
+        this.nativeStarted = false;
+        this.paused = false;
+        this.layoutInvalidated = false;
+        this.lastPlacementWasDirect = false;
+        this.placementAcknowledgementRequired = false;
+        this.operationTask = Promise.resolve();
+        this.updateDirty = false;
+        this.placementSequence = 0;
+        this.listenerHandles = new Set();
+        this.handleViewportMotion = (event) => {
+            if (this.destroyed) {
+                return;
+            }
+            if (!(this.nativeScrollElement &&
+                event instanceof Event &&
+                ['scroll', 'touchmove', 'wheel'].includes(event.type))) {
+                this.schedulePlacementUpdate();
+            }
+            this.scheduleEvaluation();
+        };
+        this.handleVisibilityChange = () => {
+            if (this.destroyed) {
+                return;
+            }
+            if (document.hidden) {
+                this.layoutInvalidated = true;
+                void this.requestPlacementUpdate();
+                return;
+            }
+            this.scheduleEvaluation();
+        };
+        const id = options.feedId.trim();
+        if (!id) {
+            throw new Error('Native ad feed id must not be empty');
+        }
+        if (feeds.has(id)) {
+            throw new Error(`Native ad feed id already exists: ${id}`);
+        }
+        if (feeds.size >= MAX_ACTIVE_FEEDS) {
+            throw new Error(`At most ${MAX_ACTIVE_FEEDS} native ad feeds can be active`);
+        }
+        this.options = Object.assign(Object.assign({}, options), { feedId: id });
+        this.nativeScrollElement = Capacitor.getPlatform() === 'ios' ? options.scrollElement : undefined;
+        if (typeof IntersectionObserver !== 'undefined') {
+            this.intersectionObserver = new IntersectionObserver((entries) => {
+                for (const entry of entries) {
+                    const slotKey = this.elementSlots.get(entry.target);
+                    const state = slotKey ? this.slots.get(slotKey) : undefined;
+                    if (state) {
+                        state.intersecting = entry.isIntersecting;
+                    }
+                }
+                this.schedulePlacementUpdate();
+                this.scheduleEvaluation();
+            });
+        }
+        if (typeof ResizeObserver !== 'undefined') {
+            this.resizeObserver = new ResizeObserver(this.handleViewportMotion);
+            if (this.nativeScrollElement)
+                this.resizeObserver.observe(this.nativeScrollElement);
+        }
+        document.addEventListener('scroll', this.handleViewportMotion, true);
+        document.addEventListener('touchmove', this.handleViewportMotion, { capture: true, passive: true });
+        document.addEventListener('wheel', this.handleViewportMotion, { capture: true, passive: true });
+        window.addEventListener('resize', this.handleViewportMotion, { passive: true });
+        (_a = window.visualViewport) === null || _a === void 0 ? void 0 : _a.addEventListener('resize', this.handleViewportMotion, { passive: true });
+        document.addEventListener('visibilitychange', this.handleVisibilityChange);
+        document.addEventListener('load', this.handleViewportMotion, true);
+        feeds.set(id, this);
+    }
+    static async create(options) {
+        var _a;
+        if (!bridge) {
+            throw new Error('AdMob native ad bridge is not configured');
+        }
+        if (typeof document === 'undefined' || typeof window === 'undefined') {
+            throw new Error('NativeAdFeed can only be created in a browser environment');
+        }
+        if (options.isTesting !== true && !((_a = options.adId) === null || _a === void 0 ? void 0 : _a.trim())) {
+            throw new Error('adId is required unless isTesting is true');
+        }
+        const feed = new NativeAdFeed(options);
+        try {
+            await bridge.startNativeAdFeed({ feedId: feed.feedId, sessionId: feed.sessionId });
+            feed.nativeStarted = true;
+            defineNativeAdElement((feedId) => feeds.get(feedId));
+            connectNativeAdElements();
+            return feed;
+        }
+        catch (error) {
+            await feed.destroy();
+            throw error;
+        }
+    }
+    get feedId() {
+        return this.options.feedId;
+    }
+    async addListener(eventName, listener) {
+        this.assertActive();
+        if (!bridge) {
+            throw new Error('AdMob native ad bridge is not configured');
+        }
+        const nativeHandle = await bridge.addListener(eventName, (event) => {
+            if (event.feedId === this.options.feedId && event.sessionId === this.sessionId) {
+                const filteredListener = listener;
+                filteredListener(event);
+            }
+        });
+        if (this.destroyed) {
+            await nativeHandle.remove();
+            this.assertActive();
+        }
+        let removed = false;
+        const handle = {
+            remove: async () => {
+                if (removed) {
+                    return;
+                }
+                removed = true;
+                this.listenerHandles.delete(handle);
+                await nativeHandle.remove();
+            },
+        };
+        this.listenerHandles.add(handle);
+        return handle;
+    }
+    attach(slotKey, element) {
+        var _a, _b, _c;
+        this.assertActive();
+        const normalizedKey = slotKey.trim();
+        if (!normalizedKey) {
+            throw new Error('Native ad slotKey must not be empty');
+        }
+        const previousKey = this.elementSlots.get(element);
+        if (previousKey === normalizedKey) {
+            return;
+        }
+        if (previousKey && previousKey !== normalizedKey) {
+            this.detach(element);
+        }
+        const existing = this.slots.get(normalizedKey);
+        if ((existing === null || existing === void 0 ? void 0 : existing.element) && existing.element !== element) {
+            throw new Error(`Native ad slotKey is already attached: ${normalizedKey}`);
+        }
+        const state = existing !== null && existing !== void 0 ? existing : {
+            slotKey: normalizedKey,
+            generation: 0,
+            intersecting: !this.intersectionObserver,
+            status: 'idle',
+            lastUsed: Date.now(),
+            loadVersion: 0,
+        };
+        applySlotDefaults(element, (_a = this.options.template) !== null && _a !== void 0 ? _a : NativeAdTemplate.Medium);
+        state.element = element;
+        state.generation += 1;
+        state.lastUsed = Date.now();
+        this.slots.set(normalizedKey, state);
+        this.elementSlots.set(element, normalizedKey);
+        this.updateScrollRoots();
+        (_b = this.intersectionObserver) === null || _b === void 0 ? void 0 : _b.observe(element);
+        (_c = this.resizeObserver) === null || _c === void 0 ? void 0 : _c.observe(element);
+        this.scheduleEvaluation();
+    }
+    detach(element) {
+        var _a, _b;
+        const slotKey = this.elementSlots.get(element);
+        if (!slotKey) {
+            return;
+        }
+        const state = this.slots.get(slotKey);
+        if ((state === null || state === void 0 ? void 0 : state.element) === element) {
+            state.element = undefined;
+            state.intersecting = false;
+            state.generation += 1;
+            state.lastUsed = Date.now();
+        }
+        (_a = this.intersectionObserver) === null || _a === void 0 ? void 0 : _a.unobserve(element);
+        (_b = this.resizeObserver) === null || _b === void 0 ? void 0 : _b.unobserve(element);
+        this.elementSlots.delete(element);
+        this.updateScrollRoots();
+        void this.requestPlacementUpdate();
+        this.scheduleEvaluation();
+    }
+    async reload(slotKey) {
+        this.assertActive();
+        const normalizedKey = slotKey.trim();
+        const state = this.slots.get(normalizedKey);
+        if (!state) {
+            throw new Error(`Native ad slotKey is not registered: ${normalizedKey}`);
+        }
+        await this.runOperation(async () => {
+            await this.removeStateAd(state);
+            const protectedStates = new Set(this.getVisibleStates());
+            protectedStates.add(state);
+            await this.evictUnusedAds(protectedStates);
+            if ([...this.slots.values()].filter((slot) => this.occupiesNativeAd(slot)).length >= MAX_NATIVE_ADS) {
+                throw new Error('Native ad capacity is currently in use by visible slots');
+            }
+            await this.loadState(state);
+        });
+    }
+    /** Immediately hides this feed's overlays until {@link resume} is called. */
+    async pause() {
+        this.assertActive();
+        this.paused = true;
+        this.layoutInvalidated = true;
+        if (!(await this.requestPlacementUpdate())) {
+            throw new Error('Failed to hide native ad placements');
+        }
+    }
+    /** Re-evaluates slots and restores eligible overlays after the viewport settles. */
+    resume() {
+        this.assertActive();
+        this.paused = false;
+        this.scheduleEvaluation();
+    }
+    /** Hides stale overlays and remeasures after an application-driven layout change. */
+    async invalidateLayout() {
+        this.assertActive();
+        this.layoutInvalidated = true;
+        this.scheduleEvaluation();
+        if (!(await this.requestPlacementUpdate())) {
+            throw new Error('Failed to hide native ad placements');
+        }
+    }
+    async destroy() {
+        var _a, _b, _c;
+        if (!this.destroyed) {
+            this.destroyed = true;
+            feeds.delete(this.options.feedId);
+            document.removeEventListener('scroll', this.handleViewportMotion, true);
+            for (const root of this.scrollRoots) {
+                root.removeEventListener('scroll', this.handleViewportMotion, true);
+            }
+            this.scrollRoots.clear();
+            document.removeEventListener('touchmove', this.handleViewportMotion, true);
+            document.removeEventListener('wheel', this.handleViewportMotion, true);
+            window.removeEventListener('resize', this.handleViewportMotion);
+            (_a = window.visualViewport) === null || _a === void 0 ? void 0 : _a.removeEventListener('resize', this.handleViewportMotion);
+            document.removeEventListener('visibilitychange', this.handleVisibilityChange);
+            document.removeEventListener('load', this.handleViewportMotion, true);
+            if (this.settleTimer) {
+                clearTimeout(this.settleTimer);
+            }
+            if (this.placementFrame !== undefined) {
+                cancelAnimationFrame(this.placementFrame);
+                this.placementFrame = undefined;
+            }
+            (_b = this.intersectionObserver) === null || _b === void 0 ? void 0 : _b.disconnect();
+            (_c = this.resizeObserver) === null || _c === void 0 ? void 0 : _c.disconnect();
+        }
+        if (this.destroyTask) {
+            return this.destroyTask;
+        }
+        this.destroyTask = this.destroyResources();
+        try {
+            await this.destroyTask;
+        }
+        finally {
+            this.destroyTask = undefined;
+        }
+    }
+    schedulePlacementUpdate() {
+        if (this.destroyed || this.placementFrame !== undefined) {
+            return;
+        }
+        this.placementFrame = requestAnimationFrame(() => {
+            this.placementFrame = undefined;
+            void this.requestPlacementUpdate(true);
+        });
+    }
+    updateScrollRoots() {
+        const roots = new Set();
+        for (const element of this.elementSlots.keys()) {
+            for (const ancestor of [element, ...nativeAdAncestors(element)]) {
+                const root = ancestor.getRootNode();
+                if (root instanceof ShadowRoot)
+                    roots.add(root);
+            }
+        }
+        for (const root of this.scrollRoots) {
+            if (!roots.has(root)) {
+                root.removeEventListener('scroll', this.handleViewportMotion, true);
+                this.scrollRoots.delete(root);
+            }
+        }
+        for (const root of roots) {
+            if (!this.scrollRoots.has(root)) {
+                // Element scroll events do not cross a shadow boundary.
+                root.addEventListener('scroll', this.handleViewportMotion, true);
+                this.scrollRoots.add(root);
+            }
+        }
+    }
+    scheduleEvaluation() {
+        if (this.destroyed) {
+            return;
+        }
+        if (this.settleTimer) {
+            clearTimeout(this.settleTimer);
+        }
+        this.settleTimer = setTimeout(() => {
+            this.layoutInvalidated = false;
+            void this.runOperation(() => this.evaluate());
+        }, SCROLL_SETTLE_MS);
+    }
+    async evaluate() {
+        if (this.destroyed || this.paused || document.hidden) {
+            return;
+        }
+        const visibleStates = this.getVisibleStates();
+        for (const state of visibleStates) {
+            state.lastUsed = Date.now();
+        }
+        await this.evictUnusedAds(new Set(visibleStates));
+        const occupied = [...this.slots.values()].filter((state) => this.occupiesNativeAd(state)).length;
+        const loadable = visibleStates
+            .filter((state) => state.status === 'idle')
+            .slice(0, Math.max(0, MAX_NATIVE_ADS - occupied));
+        await Promise.allSettled(loadable.map((state) => this.loadState(state)));
+        void this.requestPlacementUpdate();
+    }
+    async loadState(state) {
+        var _a;
+        if (state.status !== 'idle' || !bridge) {
+            return;
+        }
+        state.status = 'loading';
+        const loadVersion = ++state.loadVersion;
+        try {
+            await bridge.loadNativeAd({
+                feedId: this.options.feedId,
+                sessionId: this.sessionId,
+                slotKey: state.slotKey,
+                template: (_a = this.options.template) !== null && _a !== void 0 ? _a : NativeAdTemplate.Medium,
+                style: this.options.style,
+                adId: this.options.adId,
+                isTesting: this.options.isTesting,
+                npa: this.options.npa,
+            });
+            if (state.loadVersion === loadVersion) {
+                state.status = 'loaded';
+                state.lastUsed = Date.now();
+            }
+        }
+        catch (error) {
+            if (state.loadVersion === loadVersion) {
+                state.status = 'failed';
+            }
+            throw error;
+        }
+    }
+    async evictUnusedAds(visibleStates) {
+        const occupied = [...this.slots.values()].filter((state) => this.occupiesNativeAd(state));
+        const requestedLoads = [...visibleStates].filter((state) => state.status === 'idle').length;
+        const evictionCount = Math.max(0, occupied.length + Math.min(requestedLoads, MAX_NATIVE_ADS) - MAX_NATIVE_ADS);
+        const evicted = occupied
+            .filter((state) => !visibleStates.has(state))
+            .sort((left, right) => left.lastUsed - right.lastUsed)
+            .slice(0, evictionCount);
+        await Promise.allSettled(evicted.map((state) => this.removeStateAd(state)));
+        const detached = [...this.slots.values()]
+            .filter((state) => !state.element && !this.occupiesNativeAd(state))
+            .sort((left, right) => right.lastUsed - left.lastUsed);
+        for (const state of detached.slice(MAX_NATIVE_ADS)) {
+            this.slots.delete(state.slotKey);
+        }
+    }
+    occupiesNativeAd(state) {
+        return ['loading', 'loaded', 'removing', 'removeFailed'].includes(state.status);
+    }
+    getVisibleStates() {
+        return [...this.slots.values()].filter((state) => {
+            const measured = state.element && state.intersecting ? measureNativeAdSlot(state.element) : undefined;
+            return Boolean(measured && this.isSupportedSize(measured));
+        });
+    }
+    isSupportedSize(measured) {
+        var _a, _b;
+        const minimumHeight = ((_a = this.options.template) !== null && _a !== void 0 ? _a : NativeAdTemplate.Medium) === NativeAdTemplate.Small
+            ? MIN_SMALL_SLOT_HEIGHT
+            : MIN_MEDIUM_SLOT_HEIGHT;
+        const minimumWidth = ((_b = this.options.template) !== null && _b !== void 0 ? _b : NativeAdTemplate.Medium) === NativeAdTemplate.Small
+            ? MIN_SMALL_SLOT_WIDTH
+            : MIN_MEDIUM_SLOT_WIDTH;
+        return measured.rect.width >= minimumWidth && measured.rect.height >= minimumHeight;
+    }
+    async removeStateAd(state) {
+        if (state.status === 'removing') {
+            return;
+        }
+        if (!bridge || state.status === 'idle' || state.status === 'failed') {
+            state.status = 'idle';
+            return;
+        }
+        state.status = 'removing';
+        const removeVersion = ++state.loadVersion;
+        await this.requestPlacementUpdate();
+        try {
+            await bridge.removeNativeAd({
+                feedId: this.options.feedId,
+                sessionId: this.sessionId,
+                slotKey: state.slotKey,
+            });
+            if (state.loadVersion === removeVersion) {
+                state.status = 'idle';
+            }
+        }
+        catch (error) {
+            if (state.loadVersion === removeVersion) {
+                state.status = 'removeFailed';
+            }
+            throw error;
+        }
+    }
+    runOperation(operation) {
+        const result = this.operationTask.then(operation);
+        this.operationTask = result.catch(() => undefined);
+        return result;
+    }
+    async destroyResources() {
+        await Promise.all([
+            ...[...this.listenerHandles].map((handle) => handle.remove()),
+            ...(this.nativeStarted && bridge
+                ? [bridge.destroyNativeAdFeed({ feedId: this.options.feedId, sessionId: this.sessionId })]
+                : []),
+        ]);
+        this.nativeStarted = false;
+        this.listenerHandles.clear();
+        this.slots.clear();
+        this.elementSlots.clear();
+    }
+    requestPlacementUpdate(allowDirect = false) {
+        this.updateDirty = true;
+        this.placementAcknowledgementRequired || (this.placementAcknowledgementRequired = !allowDirect);
+        if (!this.placementUpdateTask) {
+            this.placementUpdateTask = Promise.resolve().then(() => this.flushPlacementUpdates());
+        }
+        return this.placementUpdateTask;
+    }
+    async flushPlacementUpdates() {
+        if (!bridge || this.destroyed) {
+            return true;
+        }
+        try {
+            while (this.updateDirty && !this.destroyed) {
+                this.updateDirty = false;
+                const allowDirect = !this.placementAcknowledgementRequired;
+                this.placementAcknowledgementRequired = false;
+                const placements = [...this.slots.values()]
+                    .filter((state) => state.status === 'loaded')
+                    .map((state) => {
+                    const measured = state.element ? measureNativeAdSlot(state.element, this.nativeScrollElement) : undefined;
+                    const visible = Boolean(!this.paused && !this.layoutInvalidated && measured && this.isSupportedSize(measured) && !document.hidden);
+                    return {
+                        feedId: this.options.feedId,
+                        slotKey: state.slotKey,
+                        generation: state.generation,
+                        visible,
+                        rect: measured === null || measured === void 0 ? void 0 : measured.rect,
+                        clipRect: measured === null || measured === void 0 ? void 0 : measured.clipRect,
+                    };
+                });
+                const scrollContainer = this.nativeScrollElement
+                    ? measureNativeAdScrollContainer(this.nativeScrollElement)
+                    : undefined;
+                const serializedPlacements = JSON.stringify({ placements, scrollContainer });
+                if (serializedPlacements === this.lastPlacements && (allowDirect || !this.lastPlacementWasDirect)) {
+                    continue;
+                }
+                try {
+                    const batch = Object.assign({ feedId: this.options.feedId, sessionId: this.sessionId, sequence: ++this.placementSequence, placements }, (scrollContainer ? { scrollContainer } : {}));
+                    const channel = Capacitor.getPlatform() === 'android'
+                        ? window
+                            .capacitorAdMobPlacements
+                        : undefined;
+                    let sentDirectly = false;
+                    if (allowDirect && channel) {
+                        try {
+                            channel.postMessage(JSON.stringify(batch));
+                            sentDirectly = true;
+                        }
+                        catch (_a) {
+                            // Keep the acknowledged bridge available if the direct channel fails.
+                        }
+                    }
+                    if (!sentDirectly)
+                        await bridge.updateNativeAdPlacements(batch);
+                    this.lastPlacementWasDirect = sentDirectly;
+                    this.lastPlacements = serializedPlacements;
+                }
+                catch (_b) {
+                    this.lastPlacements = undefined;
+                    // Retry on the next scroll, resize, or lifecycle update without
+                    // creating an unhandled rejection from this fire-and-forget task.
+                    this.updateDirty = true;
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (_c) {
+            this.updateDirty = true;
+            return false;
+        }
+        finally {
+            this.placementUpdateTask = undefined;
+        }
+    }
+    assertActive() {
+        if (this.destroyed) {
+            throw new Error(`Native ad feed has been destroyed: ${this.options.feedId}`);
+        }
+    }
+}
+export const configureNativeAdBridge = (adMobBridge) => {
+    bridge = adMobBridge;
+};
+//# sourceMappingURL=native-ad-feed.js.map