@capacitor-community/admob 8.2.0 → 8.2.1-beta.pr490.shaf4a3cab095f4

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

@@ -0,0 +1,643 @@
+import { Capacitor } from '@capacitor/core';
+import { bindProjectionPlacement } from '@webview-native-ui/engine';
+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)}`; };
+/**
+ * Manages native ad placement and lifecycle in a scrolling feed.
+ *
+ * A stable `slotKey`, rather than the element or array index, owns the native
+ * ad lifecycle. Virtual-scroller compatibility has not yet been validated.
+ */
+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 (event instanceof Event &&
+                event.type === 'load' &&
+                event.target instanceof HTMLImageElement &&
+                event.target.dataset['admobSnapshot'] !== undefined)
+                return;
+            if (!(event instanceof Event) || !['scroll', 'touchmove', 'wheel'].includes(event.type)) {
+                for (const state of this.slots.values())
+                    state.lastPlacement = undefined;
+            }
+            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`);
+        }
+        if (options.androidScrollSnapshot && Capacitor.getPlatform() !== 'android') {
+            throw new Error('androidScrollSnapshot requires Android');
+        }
+        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, _d, _e;
+        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;
+        if (this.options.androidScrollSnapshot) {
+            const owner = ((_b = state.projectionOwner) !== null && _b !== void 0 ? _b : (state.projectionOwner = `admob-${crypto.randomUUID()}`));
+            element.dataset['admobProjection'] = owner;
+            state.projectionSelector = `[data-admob-projection="${owner}"]`;
+            (_c = state.placementBinding) === null || _c === void 0 ? void 0 : _c.dispose();
+            state.placementBinding = bindProjectionPlacement(element, () => {
+                const placement = this.measurePlacement(state);
+                state.lastPlacement = placement;
+                // The reveal request applies this exact placement; keep batch deduplication in sync.
+                if (this.lastPlacements) {
+                    const previous = JSON.parse(this.lastPlacements);
+                    previous.placements = previous.placements.map((item) => item.slotKey === state.slotKey ? placement : item);
+                    this.lastPlacements = JSON.stringify(previous);
+                }
+                return Object.assign(Object.assign({}, placement), { sessionId: this.sessionId, sequence: ++this.placementSequence });
+            }, () => {
+                if (state.element !== element || this.destroyed)
+                    return;
+                state.lastPlacement = undefined;
+                this.lastPlacements = undefined;
+                this.schedulePlacementUpdate();
+            });
+        }
+        state.generation += 1;
+        state.lastUsed = Date.now();
+        this.slots.set(normalizedKey, state);
+        this.elementSlots.set(element, normalizedKey);
+        this.updateScrollRoots();
+        (_d = this.intersectionObserver) === null || _d === void 0 ? void 0 : _d.observe(element);
+        (_e = this.resizeObserver) === null || _e === void 0 ? void 0 : _e.observe(element);
+        this.scheduleEvaluation();
+    }
+    detach(element) {
+        var _a, _b, _c;
+        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) {
+            (_a = state.placementBinding) === null || _a === void 0 ? void 0 : _a.dispose();
+            state.placementBinding = undefined;
+            state.lastPlacement = undefined;
+            if (state.projectionOwner)
+                delete element.dataset['admobProjection'];
+            state.element = undefined;
+            state.intersecting = false;
+            state.generation += 1;
+            state.lastUsed = Date.now();
+        }
+        (_b = this.intersectionObserver) === null || _b === void 0 ? void 0 : _b.unobserve(element);
+        (_c = this.resizeObserver) === null || _c === void 0 ? void 0 : _c.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);
+            await this.requestPlacementUpdate();
+        });
+    }
+    /** 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();
+        for (const state of this.slots.values())
+            state.lastPlacement = undefined;
+        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(async () => {
+                await 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)));
+        await this.requestPlacementUpdate();
+    }
+    async loadState(state) {
+        var _a;
+        if (state.status !== 'idle' || !bridge) {
+            return;
+        }
+        state.status = 'loading';
+        const loadVersion = ++state.loadVersion;
+        try {
+            await bridge.loadNativeAd(Object.assign({ 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 }, (state.projectionSelector ? { projectionSelector: state.projectionSelector } : {})));
+            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) => {
+            var _a;
+            if (this.reuseProjectedPlacement(state))
+                return state.intersecting && !!((_a = state.lastPlacement) === null || _a === void 0 ? void 0 : _a.visible);
+            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() {
+        var _a;
+        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();
+        for (const state of this.slots.values())
+            (_a = state.placementBinding) === null || _a === void 0 ? void 0 : _a.dispose();
+        this.slots.clear();
+        this.elementSlots.clear();
+    }
+    reuseProjectedPlacement(state) {
+        var _a, _b, _c;
+        return Boolean(((_a = state.placementBinding) === null || _a === void 0 ? void 0 : _a.projected) &&
+            ((_b = state.lastPlacement) === null || _b === void 0 ? void 0 : _b.visible) &&
+            ((_c = state.element) === null || _c === void 0 ? void 0 : _c.isConnected) &&
+            !this.paused &&
+            !this.destroyed &&
+            !document.hidden &&
+            state.status === 'loaded' &&
+            state.lastPlacement.generation === state.generation);
+    }
+    measurePlacement(state) {
+        const measured = state.element ? measureNativeAdSlot(state.element, this.nativeScrollElement) : undefined;
+        return {
+            feedId: this.options.feedId,
+            slotKey: state.slotKey,
+            generation: state.generation,
+            visible: Boolean(!this.paused &&
+                !this.destroyed &&
+                state.status === 'loaded' &&
+                (!this.layoutInvalidated || this.options.androidScrollSnapshot) &&
+                measured &&
+                this.isSupportedSize(measured) &&
+                !document.hidden),
+            rect: measured === null || measured === void 0 ? void 0 : measured.rect,
+            clipRect: measured === null || measured === void 0 ? void 0 : measured.clipRect,
+        };
+    }
+    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 retainedSlots = new Set();
+                const placements = [...this.slots.values()]
+                    .filter((state) => state.status === 'loaded')
+                    .map((state) => {
+                    if (this.reuseProjectedPlacement(state)) {
+                        retainedSlots.add(state.slotKey);
+                        return state.lastPlacement;
+                    }
+                    return (state.lastPlacement = this.measurePlacement(state));
+                });
+                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: placements.map((placement) => {
+                            return retainedSlots.has(placement.slotKey)
+                                ? {
+                                    feedId: placement.feedId,
+                                    slotKey: placement.slotKey,
+                                    generation: placement.generation,
+                                    visible: true,
+                                    retain: true,
+                                }
+                                : placement;
+                        }) }, (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