react-native-qpush 0.0.0-stage → 1.0.0

package/lib/core/QPushCore.js

@@ -0,0 +1,1387 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QPushCore = void 0;
+exports.languageFromLocale = languageFromLocale;
+const notification_1 = require("../notification");
+const types_1 = require("../types");
+const constants_1 = require("./constants");
+const events_1 = require("./events");
+const http_1 = require("./http");
+const logger_1 = require("./logger");
+const operationQueue_1 = require("./operationQueue");
+const operations_1 = require("./operations");
+const payload_1 = require("./payload");
+const state_1 = require("./state");
+const storage_1 = require("./storage");
+const subscription_1 = require("./subscription");
+const tags_1 = require("./tags");
+const url_1 = require("./url");
+const uuid_1 = require("./uuid");
+/** Aliases that cannot be set / removed through `addAlias` / `removeAlias`. */
+const RESERVED_ALIASES = ['qpush_id', 'onesignal_id', 'external_id'];
+function identityQPushId(identity) {
+    var _a;
+    if (!identity)
+        return undefined;
+    const id = (_a = identity.qpush_id) !== null && _a !== void 0 ? _a : identity.onesignal_id;
+    return typeof id === 'string' && id.length > 0 ? id : undefined;
+}
+function aliasesFromIdentity(identity) {
+    const aliases = {};
+    for (const key of Object.keys(identity)) {
+        const value = identity[key];
+        if (key === 'qpush_id' || key === 'onesignal_id')
+            continue;
+        if (typeof value === 'string')
+            aliases[key] = value;
+    }
+    return aliases;
+}
+function stringTags(tags) {
+    const result = {};
+    if (typeof tags !== 'object' || tags === null)
+        return result;
+    for (const [key, value] of Object.entries(tags)) {
+        if (value === null || value === undefined || value === '')
+            continue;
+        result[key] = typeof value === 'string' ? value : String(value);
+    }
+    return result;
+}
+function samePushState(a, b) {
+    return a.id === b.id && a.token === b.token && a.optedIn === b.optedIn;
+}
+function permissionToEnum(status) {
+    switch (status) {
+        case 'granted':
+            return types_1.NotificationPermission.Authorized;
+        case 'denied':
+            return types_1.NotificationPermission.Denied;
+        case 'provisional':
+            return types_1.NotificationPermission.Provisional;
+        case 'ephemeral':
+            return types_1.NotificationPermission.Ephemeral;
+        default:
+            return types_1.NotificationPermission.NotDetermined;
+    }
+}
+/** Language code from a locale (`pt-BR` -> `pt`, `iw` -> `he`). */
+function languageFromLocale(locale) {
+    var _a, _b;
+    if (!locale)
+        return undefined;
+    const code = (_a = locale.split(/[-_]/)[0]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    if (!code)
+        return undefined;
+    const legacy = { iw: 'he', in: 'id', ji: 'yi' };
+    return (_b = legacy[code]) !== null && _b !== void 0 ? _b : code;
+}
+/**
+ * The single implementation of the QPush user / subscription / HTTP state
+ * machine. Platform specifics are injected through {@link PlatformAdapter}.
+ */
+class QPushCore {
+    constructor(platform, logger = new logger_1.Logger()) {
+        this.platform = platform;
+        this.events = new events_1.EventHub();
+        this.loadPromise = null;
+        this.commandChain = Promise.resolve();
+        this.device = null;
+        this.initializeCalled = false;
+        this.started = false;
+        this.registrationSettled = false;
+        this.registering = false;
+        this.halted = false;
+        this.foregroundAt = null;
+        this.backgroundAt = null;
+        this.pendingColdSession = false;
+        this.appStateSubscription = null;
+        this.nativeSubscriptions = [];
+        this.pendingClicks = [];
+        this.clickFlushScheduled = false;
+        this.logger = logger;
+        this.state = (0, state_1.createDefaultState)(this.uuid());
+        this.stateWriter = new storage_1.SerialWriter(platform.native, constants_1.StorageKeys.state, (error) => this.logger.error('Failed to persist state', error));
+        this.http = new http_1.HttpClient({
+            fetch: platform.fetch,
+            getBaseUrl: () => { var _a; return (_a = this.state.config) === null || _a === void 0 ? void 0 : _a.serverUrl; },
+            getSubscriptionId: () => this.state.subscription.id,
+            scheduler: platform.scheduler,
+            logger: this.logger,
+            now: () => platform.now(),
+        });
+        this.queue = new operationQueue_1.OperationQueue({
+            store: platform.native,
+            storageKey: constants_1.StorageKeys.queue,
+            execute: (operation, item) => this.execute(operation, item),
+            canProcess: () => this.canProcess(),
+            scheduler: platform.scheduler,
+            now: () => platform.now(),
+            random: () => platform.random(),
+            logger: this.logger,
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Plumbing
+    // ---------------------------------------------------------------------------
+    uuid() {
+        return (0, uuid_1.generateUuid)(() => this.platform.random());
+    }
+    ensureLoaded() {
+        if (!this.loadPromise)
+            this.loadPromise = this.load();
+        return this.loadPromise;
+    }
+    async load() {
+        const saved = await (0, storage_1.readJson)(this.platform.native, constants_1.StorageKeys.state);
+        this.state = (0, state_1.sanitizeState)(saved, () => this.uuid());
+        await this.queue.load();
+        // Must be enqueued before any operation of this user (tags set before
+        // initialize, consent, ...). Execution waits until the SDK started.
+        this.ensureUserCreation();
+    }
+    /** Enqueues `createUser` for the current user unless it exists or is being created. */
+    ensureUserCreation() {
+        const user = this.state.user;
+        if (user.qpushId)
+            return;
+        const pending = this.queue.has((operation) => (operation.kind === 'createUser' || operation.kind === 'login') && operation.userLocalId === user.localId);
+        if (pending)
+            return;
+        this.queue.enqueue({
+            kind: 'createUser',
+            userLocalId: user.localId,
+            identity: user.externalId ? { external_id: user.externalId } : {},
+            transferSubscription: !!this.state.subscription.id,
+        });
+    }
+    /** Runs `fn` after state is loaded, serialized with every other command. */
+    command(fn) {
+        const next = this.commandChain
+            .then(() => this.ensureLoaded())
+            .then(fn)
+            .catch((error) => this.logger.error('Unexpected error', error));
+        this.commandChain = next;
+        return next;
+    }
+    /** Reads state after every previously issued command ran. */
+    async read(fn) {
+        let result;
+        await this.command(() => {
+            result = fn();
+        });
+        return result;
+    }
+    save() {
+        void this.stateWriter.write(JSON.stringify(this.state));
+    }
+    canProcess() {
+        return this.started && this.registrationSettled && !this.halted && this.hasConsent();
+    }
+    hasConsent() {
+        return !this.state.consentRequired || this.state.consentGiven;
+    }
+    sleep(ms) {
+        return new Promise((resolve) => this.platform.scheduler.setTimeout(resolve, ms));
+    }
+    get appId() {
+        var _a, _b;
+        return (0, url_1.encodeSegment)((_b = (_a = this.state.config) === null || _a === void 0 ? void 0 : _a.appId) !== null && _b !== void 0 ? _b : '');
+    }
+    /** Waits for pending commands, queue processing and storage writes (tests). */
+    async flush() {
+        await this.commandChain;
+        await this.queue.process();
+        await this.queue.idle();
+        await this.commandChain;
+        await this.queue.persisted();
+        await this.stateWriter.flush();
+    }
+    // ---------------------------------------------------------------------------
+    // Initialization & consent
+    // ---------------------------------------------------------------------------
+    setLogLevel(level) {
+        this.logger.setLevel(level);
+        try {
+            this.platform.native.setLogLevel(level);
+        }
+        catch {
+            // ignore
+        }
+    }
+    initialize(appId, options) {
+        var _a;
+        if (options && typeof options.logLevel === 'number')
+            this.setLogLevel(options.logLevel);
+        if (typeof appId !== 'string' || appId.trim() === '') {
+            this.logger.error('initialize: appId is required');
+            return;
+        }
+        const serverUrl = (0, url_1.normalizeServerUrl)((_a = options === null || options === void 0 ? void 0 : options.serverUrl) !== null && _a !== void 0 ? _a : types_1.QPUSH_CLOUD_API_URL);
+        if (!serverUrl) {
+            this.logger.error(`initialize: invalid serverUrl "${String(options === null || options === void 0 ? void 0 : options.serverUrl)}"`);
+            return;
+        }
+        const trimmedAppId = appId.trim();
+        if (serverUrl.startsWith('http://')) {
+            this.logger.warn('initialize: serverUrl uses plain HTTP. Use HTTPS in production. Release builds on Android block ' +
+                'cleartext traffic (delivery receipts and click reports are sent by native code); on iOS use an IP ' +
+                'address, or NSAllowsLocalNetworking for .local hostnames.');
+        }
+        this.initializeCalled = true;
+        this.attachNativeEvents();
+        void this.command(async () => {
+            var _a;
+            const previous = this.state.config;
+            if (previous && previous.appId === trimmedAppId && previous.serverUrl === serverUrl && this.started) {
+                this.logger.debug('initialize: already initialized');
+                return;
+            }
+            if (previous && (previous.appId !== trimmedAppId || previous.serverUrl !== serverUrl)) {
+                this.logger.info('initialize: app id or server changed, resetting local user and subscription');
+                this.resetForNewApp();
+            }
+            this.state.config = { appId: trimmedAppId, serverUrl };
+            this.save();
+            await this.writeNative(constants_1.NativeKeys.appId, trimmedAppId);
+            await this.writeNative(constants_1.NativeKeys.serverUrl, serverUrl);
+            await this.writeNative(constants_1.NativeKeys.subscriptionId, (_a = this.state.subscription.id) !== null && _a !== void 0 ? _a : null);
+            this.maybeStart();
+        });
+    }
+    resetForNewApp() {
+        const { consentRequired, consentGiven } = this.state;
+        const subscription = this.state.subscription;
+        this.queue.clear();
+        this.state = (0, state_1.createDefaultState)(this.uuid());
+        this.state.consentRequired = consentRequired;
+        this.state.consentGiven = consentGiven;
+        // Keep what belongs to the device, drop what belongs to the old app.
+        this.state.subscription = {
+            optedIn: subscription.optedIn,
+            permission: subscription.permission,
+            token: subscription.token,
+            tokenError: subscription.tokenError,
+        };
+        this.started = false;
+        this.registrationSettled = false;
+        this.halted = false;
+        this.ensureUserCreation();
+    }
+    async writeNative(key, value) {
+        try {
+            if (value === null)
+                await this.platform.native.removeItem(key);
+            else
+                await this.platform.native.setItem(key, value);
+        }
+        catch (error) {
+            this.logger.warn(`Could not persist ${key} natively`, error);
+        }
+    }
+    setConsentRequired(required) {
+        void this.command(() => {
+            this.state.consentRequired = !!required;
+            this.save();
+            this.maybeStart();
+        });
+    }
+    setConsentGiven(given) {
+        void this.command(() => {
+            this.state.consentGiven = !!given;
+            this.save();
+            this.maybeStart();
+            if (this.canProcess())
+                this.queue.kick();
+        });
+    }
+    maybeStart() {
+        if (!this.state.config || this.started)
+            return;
+        if (!this.hasConsent()) {
+            this.logger.info('Waiting for privacy consent (setConsentGiven(true)) before starting');
+            return;
+        }
+        this.started = true;
+        void this.start().catch((error) => this.logger.error('Start failed', error));
+    }
+    async start() {
+        try {
+            this.device = await this.platform.native.getDeviceInfo();
+            if (this.device && !this.device.language)
+                this.device.language = languageFromLocale(this.device.locale);
+        }
+        catch (error) {
+            this.logger.warn('Could not read device info', error);
+            this.device = { platform: this.platform.os };
+        }
+        await this.refreshPermission(true);
+        await this.command(() => {
+            this.ensureUserCreation();
+            // Pushes changed device fields (app version, OS version...) if any.
+            this.mutateSubscription(() => { });
+        });
+        this.attachAppState();
+        const appState = this.platform.appState.currentState;
+        if (appState === 'active' || appState == null || appState === 'unknown') {
+            await this.command(() => this.startSession());
+        }
+        else {
+            this.pendingColdSession = true;
+        }
+        await this.command(() => {
+            if (this.state.user.qpushId) {
+                this.queue.enqueue({ kind: 'fetchUser', userLocalId: this.state.user.localId });
+            }
+        });
+        await this.registerPush();
+        this.registrationSettled = true;
+        this.queue.kick();
+    }
+    /** Retries push registration when the app comes back without a token (offline start, FCM params added later). */
+    retryRegistrationIfNeeded() {
+        const sub = this.state.subscription;
+        if (!this.registrationSettled || this.registering || this.halted || sub.token)
+            return;
+        this.registering = true;
+        void this.registerPush()
+            .catch((error) => this.logger.warn('Push registration retry failed', error))
+            .finally(() => {
+            this.registering = false;
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Push registration & permission
+    // ---------------------------------------------------------------------------
+    async fetchParams() {
+        var _a;
+        const file = this.platform.os === 'android' ? 'android_params.js' : 'ios_params.js';
+        const path = `/apps/${this.appId}/${file}`;
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            const response = await this.http.request('GET', path);
+            if (response.ok) {
+                if (this.platform.os === 'android') {
+                    const fcm = response.data && 'fcm' in response.data ? (_a = response.data.fcm) !== null && _a !== void 0 ? _a : null : null;
+                    await this.command(() => {
+                        this.state.fcmParams = fcm;
+                        this.save();
+                    });
+                }
+                return 'ok';
+            }
+            if (response.status === 404)
+                return 'not_found';
+            if (!(0, http_1.isRetryableStatus)(response.status))
+                return 'unavailable';
+            if (attempt < 3)
+                await this.sleep(1000 * Math.pow(2, attempt - 1));
+        }
+        return 'unavailable';
+    }
+    async registerPush() {
+        var _a, _b, _c;
+        const params = await this.fetchParams();
+        if (params === 'not_found') {
+            this.halted = true;
+            this.logger.error(`App "${(_a = this.state.config) === null || _a === void 0 ? void 0 : _a.appId}" was not found on ${(_b = this.state.config) === null || _b === void 0 ? void 0 : _b.serverUrl}. ` +
+                'Check the app id and serverUrl; the SDK will not sync until the app restarts.');
+            return;
+        }
+        if (params === 'unavailable')
+            this.logger.warn('Could not fetch app params, using cached values');
+        const fcm = this.platform.os === 'android' ? (_c = this.state.fcmParams) !== null && _c !== void 0 ? _c : null : null;
+        let registration;
+        try {
+            registration = this.platform.native.registerForPush(fcm).then((result) => this.applyRegistration(result), (error) => this.logger.warn('Push registration failed', error));
+        }
+        catch (error) {
+            this.logger.warn('Push registration failed', error);
+            return;
+        }
+        let timer;
+        const timeout = new Promise((resolve) => {
+            timer = this.platform.scheduler.setTimeout(() => {
+                this.logger.warn('Push token not received yet, continuing without it');
+                resolve();
+            }, constants_1.PUSH_REGISTRATION_TIMEOUT_MS);
+        });
+        await Promise.race([registration, timeout]);
+        this.platform.scheduler.clearTimeout(timer);
+    }
+    applyRegistration(result) {
+        return this.command(() => {
+            if (!result)
+                return;
+            this.mutateSubscription(() => {
+                var _a;
+                const sub = this.state.subscription;
+                if (result.token) {
+                    sub.token = result.token;
+                    sub.tokenError = undefined;
+                }
+                else if (typeof result.notificationTypes === 'number' && result.notificationTypes < 0) {
+                    // A transient failure (e.g. offline) must not unsubscribe a device
+                    // that already has a valid token.
+                    if (!sub.token)
+                        sub.tokenError = result.notificationTypes;
+                    this.logger.warn(`Push registration error (${result.notificationTypes}): ${(_a = result.error) !== null && _a !== void 0 ? _a : 'unknown'}`);
+                }
+                else if (result.error) {
+                    this.logger.warn(`Push registration error: ${result.error}`);
+                }
+            });
+        });
+    }
+    applyToken(token) {
+        if (!token)
+            return;
+        void this.command(() => {
+            this.mutateSubscription(() => {
+                this.state.subscription.token = token;
+                this.state.subscription.tokenError = undefined;
+            });
+        });
+    }
+    /** Reads the OS permission and updates the subscription when it changed. */
+    async refreshPermission(emit) {
+        let status;
+        try {
+            status = await this.platform.native.getPermissionStatus();
+        }
+        catch (error) {
+            this.logger.warn('Could not read notification permission', error);
+            return this.read(() => this.state.subscription.permission);
+        }
+        await this.command(() => {
+            const previous = this.state.subscription.permission;
+            if (previous === status)
+                return;
+            this.mutateSubscription(() => {
+                this.state.subscription.permission = status;
+            });
+            const wasGranted = (0, subscription_1.isPermissionGranted)(previous);
+            const isGranted = (0, subscription_1.isPermissionGranted)(status);
+            if (emit && wasGranted !== isGranted) {
+                this.events.emit('permissionChange', isGranted, (error) => this.logger.error('permissionChange listener threw', error));
+            }
+        });
+        return status;
+    }
+    async requestPermission(fallbackToSettings) {
+        await this.ensureLoaded();
+        let granted = false;
+        try {
+            granted = await this.platform.native.requestPermission(!!fallbackToSettings);
+        }
+        catch (error) {
+            this.logger.error('requestPermission failed', error);
+        }
+        const status = await this.refreshPermission(true);
+        return granted || (0, subscription_1.isPermissionGranted)(status);
+    }
+    async registerForProvisionalAuthorization() {
+        await this.ensureLoaded();
+        let accepted = false;
+        try {
+            accepted = await this.platform.native.registerForProvisionalAuthorization();
+        }
+        catch (error) {
+            this.logger.error('registerForProvisionalAuthorization failed', error);
+        }
+        await this.refreshPermission(true);
+        return accepted;
+    }
+    async getPermission() {
+        await this.ensureLoaded();
+        return (0, subscription_1.isPermissionGranted)(await this.refreshPermission(true));
+    }
+    async permissionNative() {
+        await this.ensureLoaded();
+        return permissionToEnum(await this.refreshPermission(true));
+    }
+    async canRequestPermission() {
+        try {
+            return await this.platform.native.canRequestPermission();
+        }
+        catch {
+            return false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Subscription
+    // ---------------------------------------------------------------------------
+    subscriptionInputs() {
+        const sub = this.state.subscription;
+        return { token: sub.token, tokenError: sub.tokenError, permission: sub.permission, optedIn: sub.optedIn };
+    }
+    currentFields() {
+        return (0, subscription_1.buildSubscriptionFields)(this.subscriptionInputs(), this.device);
+    }
+    pushState() {
+        var _a, _b;
+        const sub = this.state.subscription;
+        return { id: (_a = sub.id) !== null && _a !== void 0 ? _a : null, token: (_b = sub.token) !== null && _b !== void 0 ? _b : null, optedIn: (0, subscription_1.computeOptedIn)(this.subscriptionInputs()) };
+    }
+    /** Applies a subscription change, emits `change` and schedules a sync. */
+    mutateSubscription(fn) {
+        const before = this.pushState();
+        fn();
+        const after = this.pushState();
+        this.save();
+        this.scheduleSyncIfDirty();
+        if (!samePushState(before, after)) {
+            this.events.emit('pushSubscriptionChange', { previous: before, current: after }, (error) => this.logger.error('pushSubscription change listener threw', error));
+        }
+    }
+    scheduleSyncIfDirty() {
+        const sub = this.state.subscription;
+        // A pending create sends the live subscription snapshot anyway.
+        if (!sub.id && this.queue.has((operation, item) => item.id !== this.queue.inFlight && (0, operations_1.createsSubscription)(operation))) {
+            return;
+        }
+        const dirty = sub.badgeResetPending || !(0, tags_1.isEmpty)((0, subscription_1.diffSubscription)(sub.synced, this.currentFields()));
+        if (dirty)
+            this.queue.enqueue({ kind: 'syncSubscription' });
+    }
+    setSubscriptionId(id) {
+        if (this.state.subscription.id === id)
+            return;
+        this.mutateSubscription(() => {
+            this.state.subscription.id = id;
+        });
+        void this.writeNative(constants_1.NativeKeys.subscriptionId, id !== null && id !== void 0 ? id : null);
+    }
+    optIn() {
+        void this.command(async () => {
+            this.mutateSubscription(() => {
+                this.state.subscription.optedIn = true;
+            });
+            if (this.state.subscription.permission === 'notDetermined') {
+                void this.requestPermission(false);
+            }
+        });
+    }
+    optOut() {
+        void this.command(() => {
+            this.mutateSubscription(() => {
+                this.state.subscription.optedIn = false;
+            });
+        });
+    }
+    getSubscriptionId() {
+        return this.read(() => { var _a; return (_a = this.state.subscription.id) !== null && _a !== void 0 ? _a : null; });
+    }
+    getSubscriptionToken() {
+        return this.read(() => { var _a; return (_a = this.state.subscription.token) !== null && _a !== void 0 ? _a : null; });
+    }
+    getOptedIn() {
+        return this.read(() => (0, subscription_1.computeOptedIn)(this.subscriptionInputs()));
+    }
+    // ---------------------------------------------------------------------------
+    // User
+    // ---------------------------------------------------------------------------
+    userState() {
+        var _a, _b;
+        return { qpushId: (_a = this.state.user.qpushId) !== null && _a !== void 0 ? _a : null, externalId: (_b = this.state.user.externalId) !== null && _b !== void 0 ? _b : null };
+    }
+    mutateUser(fn) {
+        const before = this.userState();
+        fn();
+        const after = this.userState();
+        this.save();
+        if (before.qpushId !== after.qpushId || before.externalId !== after.externalId) {
+            this.events.emit('userChange', { current: after }, (error) => this.logger.error('User change listener threw', error));
+        }
+    }
+    login(externalId) {
+        void this.command(() => {
+            if (typeof externalId !== 'string' || externalId.trim() === '') {
+                this.logger.error('login: externalId must be a non-empty string');
+                return;
+            }
+            const previous = this.state.user;
+            if (previous.externalId === externalId) {
+                this.logger.debug('login: already logged in with this external id');
+                return;
+            }
+            const anonymous = !previous.externalId;
+            const next = {
+                ...(0, state_1.createUser)(this.uuid()),
+                externalId,
+                // Identifying an anonymous user keeps its data (OneSignal semantics).
+                aliases: anonymous ? { ...previous.aliases, external_id: externalId } : { external_id: externalId },
+                tags: anonymous ? { ...previous.tags } : {},
+                language: previous.language,
+                languageExplicit: previous.languageExplicit,
+                timezone: previous.timezone,
+            };
+            this.mutateUser(() => {
+                this.state.user = next;
+            });
+            this.queue.enqueue({
+                kind: 'login',
+                userLocalId: next.localId,
+                externalId,
+                previousLocalId: previous.localId,
+                previousWasAnonymous: anonymous,
+            });
+        });
+    }
+    logout() {
+        void this.command(() => {
+            const previous = this.state.user;
+            if (!previous.externalId) {
+                this.logger.debug('logout: no user is logged in');
+                return;
+            }
+            const next = {
+                ...(0, state_1.createUser)(this.uuid()),
+                language: previous.language,
+                languageExplicit: previous.languageExplicit,
+                timezone: previous.timezone,
+            };
+            this.mutateUser(() => {
+                this.state.user = next;
+            });
+            this.queue.enqueue({
+                kind: 'createUser',
+                userLocalId: next.localId,
+                identity: {},
+                transferSubscription: true,
+            });
+        });
+    }
+    addTags(tags) {
+        void this.command(() => {
+            if (!tags || typeof tags !== 'object') {
+                this.logger.error('addTags: expected an object');
+                return;
+            }
+            const [normalized, rejected] = (0, tags_1.normalizeTags)(tags);
+            if (rejected.length > 0) {
+                this.logger.warn(`addTags: ignored invalid tags: ${rejected.join(', ')} (values must be strings or numbers)`);
+            }
+            const changes = (0, tags_1.changesForAdd)(this.state.user.tags, normalized);
+            this.applyLocalTagChanges(changes);
+        });
+    }
+    removeTags(keys) {
+        void this.command(() => {
+            if (!Array.isArray(keys)) {
+                this.logger.error('removeTags: expected an array of keys');
+                return;
+            }
+            this.applyLocalTagChanges((0, tags_1.changesForRemove)(keys));
+        });
+    }
+    applyLocalTagChanges(changes) {
+        if ((0, tags_1.isEmpty)(changes))
+            return;
+        this.state.user.tags = (0, tags_1.applyTagChanges)(this.state.user.tags, changes);
+        this.save();
+        this.queue.enqueue({ kind: 'updateUser', userLocalId: this.state.user.localId, tags: changes });
+    }
+    getTags() {
+        return this.read(() => ({ ...this.state.user.tags }));
+    }
+    addAliases(aliases) {
+        void this.command(() => {
+            if (!aliases || typeof aliases !== 'object') {
+                this.logger.error('addAliases: expected an object');
+                return;
+            }
+            const valid = {};
+            for (const [label, id] of Object.entries(aliases)) {
+                if (typeof label !== 'string' || label.trim() === '' || RESERVED_ALIASES.includes(label)) {
+                    this.logger.error(`addAlias: "${label}" cannot be used as an alias label (use login() for external_id)`);
+                    continue;
+                }
+                if (typeof id !== 'string' || id === '') {
+                    this.logger.error(`addAlias: the id for "${label}" must be a non-empty string`);
+                    continue;
+                }
+                valid[label] = id;
+            }
+            if ((0, tags_1.isEmpty)(valid))
+                return;
+            this.state.user.aliases = { ...this.state.user.aliases, ...valid };
+            this.save();
+            this.queue.enqueue({ kind: 'setAlias', userLocalId: this.state.user.localId, aliases: valid });
+        });
+    }
+    removeAliases(labels) {
+        void this.command(() => {
+            if (!Array.isArray(labels))
+                return;
+            for (const label of labels) {
+                if (typeof label !== 'string' || label === '' || RESERVED_ALIASES.includes(label)) {
+                    this.logger.error(`removeAlias: "${String(label)}" cannot be removed`);
+                    continue;
+                }
+                const aliases = { ...this.state.user.aliases };
+                delete aliases[label];
+                this.state.user.aliases = aliases;
+                this.queue.enqueue({ kind: 'removeAlias', userLocalId: this.state.user.localId, label });
+            }
+            this.save();
+        });
+    }
+    setLanguage(language) {
+        void this.command(() => {
+            if (typeof language !== 'string' || language.trim() === '') {
+                this.logger.error('setLanguage: language must be a non-empty string');
+                return;
+            }
+            this.state.user.language = language;
+            this.state.user.languageExplicit = true;
+            this.save();
+            this.queue.enqueue({
+                kind: 'updateUser',
+                userLocalId: this.state.user.localId,
+                properties: { language },
+            });
+        });
+    }
+    getQPushId() {
+        return this.read(() => { var _a; return (_a = this.state.user.qpushId) !== null && _a !== void 0 ? _a : null; });
+    }
+    getExternalId() {
+        return this.read(() => { var _a; return (_a = this.state.user.externalId) !== null && _a !== void 0 ? _a : null; });
+    }
+    // ---------------------------------------------------------------------------
+    // Sessions (AppState)
+    // ---------------------------------------------------------------------------
+    attachAppState() {
+        if (this.appStateSubscription)
+            return;
+        try {
+            this.appStateSubscription = this.platform.appState.addEventListener('change', (next) => this.onAppStateChange(next));
+        }
+        catch (error) {
+            this.logger.warn('Could not observe AppState', error);
+        }
+    }
+    startSession() {
+        var _a, _b;
+        const now = this.platform.now();
+        this.foregroundAt = now;
+        this.backgroundAt = null;
+        const user = this.state.user;
+        const properties = {};
+        const timezone = (_a = this.device) === null || _a === void 0 ? void 0 : _a.timezone;
+        if (timezone && timezone !== user.timezone) {
+            properties.timezone_id = timezone;
+            user.timezone = timezone;
+        }
+        const language = (_b = this.device) === null || _b === void 0 ? void 0 : _b.language;
+        if (!user.languageExplicit && language && language !== user.language) {
+            properties.language = language;
+            user.language = language;
+        }
+        const operation = {
+            kind: 'updateUser',
+            userLocalId: user.localId,
+            deltas: { session_count: 1 },
+        };
+        if (!(0, tags_1.isEmpty)(properties))
+            operation.properties = properties;
+        this.save();
+        this.queue.enqueue(operation);
+        this.logger.debug('New session');
+        void this.clearBadge(true);
+    }
+    onAppStateChange(next) {
+        if (next === 'active') {
+            void this.command(() => {
+                const now = this.platform.now();
+                if (this.pendingColdSession) {
+                    this.pendingColdSession = false;
+                    this.startSession();
+                }
+                else if (this.backgroundAt !== null && now - this.backgroundAt >= constants_1.SESSION_TIMEOUT_MS) {
+                    this.startSession();
+                }
+                else if (this.backgroundAt !== null) {
+                    this.foregroundAt = now;
+                    this.backgroundAt = null;
+                    void this.clearBadge(false);
+                }
+            });
+            void this.refreshPermission(true);
+            this.retryRegistrationIfNeeded();
+            this.queue.kick();
+        }
+        else if (next === 'background') {
+            void this.command(() => {
+                const now = this.platform.now();
+                if (this.foregroundAt !== null) {
+                    const seconds = Math.round((now - this.foregroundAt) / 1000);
+                    this.foregroundAt = null;
+                    if (seconds > 0) {
+                        this.queue.enqueue({
+                            kind: 'updateUser',
+                            userLocalId: this.state.user.localId,
+                            deltas: { session_time: seconds },
+                        });
+                    }
+                }
+                if (this.backgroundAt === null)
+                    this.backgroundAt = now;
+            }).then(() => this.flushInBackground());
+        }
+    }
+    async flushInBackground() {
+        if (!this.canProcess() || this.queue.size === 0)
+            return;
+        let taskId = -1;
+        try {
+            taskId = await this.platform.native.beginBackgroundTask();
+        }
+        catch {
+            taskId = -1;
+        }
+        let timer;
+        try {
+            await Promise.race([
+                this.queue.process().then(() => this.queue.idle()),
+                new Promise((resolve) => {
+                    timer = this.platform.scheduler.setTimeout(resolve, constants_1.BACKGROUND_FLUSH_TIMEOUT_MS);
+                }),
+            ]);
+        }
+        finally {
+            this.platform.scheduler.clearTimeout(timer);
+            if (taskId >= 0) {
+                try {
+                    this.platform.native.endBackgroundTask(taskId);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    async clearBadge(newSession) {
+        if (this.platform.os !== 'ios')
+            return;
+        let previous = 0;
+        try {
+            previous = await this.platform.native.clearBadge();
+        }
+        catch {
+            previous = 0;
+        }
+        if (previous > 0 || newSession) {
+            await this.command(() => {
+                this.mutateSubscription(() => {
+                    this.state.subscription.badgeResetPending = true;
+                });
+            });
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Notifications (native events)
+    // ---------------------------------------------------------------------------
+    /** Subscribes to native events and tells native that JS is ready. Idempotent. */
+    attachNativeEvents() {
+        if (this.nativeSubscriptions.length > 0)
+            return;
+        const source = this.platform.nativeEvents;
+        try {
+            this.nativeSubscriptions = [
+                source.addListener(constants_1.NativeEventNames.click, (payload) => this.handleNativeClick(payload)),
+                source.addListener(constants_1.NativeEventNames.foregroundWillDisplay, (payload) => this.handleNativeForeground(payload)),
+                source.addListener(constants_1.NativeEventNames.pushToken, (payload) => {
+                    if (payload && typeof payload.token === 'string')
+                        this.applyToken(payload.token);
+                }),
+            ];
+            this.platform.native.setJsReady();
+        }
+        catch (error) {
+            this.logger.error('Could not subscribe to native events', error);
+        }
+    }
+    handleNativeClick(payload) {
+        var _a;
+        const data = (0, payload_1.parseNotificationPayload)(payload === null || payload === void 0 ? void 0 : payload.rawPayload);
+        if (!data) {
+            this.logger.debug('Ignoring click on a non-QPush notification');
+            return;
+        }
+        const event = {
+            result: {},
+            notification: new notification_1.QPushNotification(data),
+        };
+        if (payload.actionId)
+            event.result.actionId = payload.actionId;
+        const url = (_a = payload.url) !== null && _a !== void 0 ? _a : undefined;
+        if (url)
+            event.result.url = url;
+        if (this.events.count('click') > 0) {
+            this.emitClick(event);
+        }
+        else {
+            this.pendingClicks.push(event);
+            if (this.pendingClicks.length > constants_1.MAX_PENDING_CLICKS)
+                this.pendingClicks.shift();
+        }
+    }
+    emitClick(event) {
+        this.events.emit('click', event, (error) => this.logger.error('click listener threw', error));
+    }
+    handleNativeForeground(payload) {
+        if (!payload || typeof payload.displayId !== 'string')
+            return;
+        const displayId = payload.displayId;
+        const data = (0, payload_1.parseNotificationPayload)(payload.rawPayload);
+        if (!data) {
+            this.platform.native.displayForegroundNotification(displayId);
+            return;
+        }
+        const event = new notification_1.NotificationWillDisplayEvent(data, () => this.platform.native.displayForegroundNotification(displayId));
+        this.events.emit('foregroundWillDisplay', event, (error) => this.logger.error('foregroundWillDisplay listener threw', error));
+        if (event.settle() === 'prevented') {
+            this.platform.native.preventForegroundDisplay(displayId);
+        }
+    }
+    addListener(event, listener) {
+        this.attachNativeEvents();
+        this.events.add(event, listener);
+        if (event === 'click' && this.pendingClicks.length > 0 && !this.clickFlushScheduled) {
+            // Deliver after the caller finished registering (cold start clicks).
+            this.clickFlushScheduled = true;
+            this.platform.scheduler.setTimeout(() => {
+                this.clickFlushScheduled = false;
+                const pending = this.pendingClicks;
+                this.pendingClicks = [];
+                for (const click of pending)
+                    this.emitClick(click);
+            }, 0);
+        }
+    }
+    removeListener(event, listener) {
+        this.events.remove(event, listener);
+    }
+    clearAll() {
+        try {
+            this.platform.native.clearAll();
+        }
+        catch (error) {
+            this.logger.error('clearAll failed', error);
+        }
+        void this.clearBadge(false);
+    }
+    removeNotification(notificationId) {
+        try {
+            this.platform.native.removeNotification(notificationId);
+        }
+        catch (error) {
+            this.logger.error('removeNotification failed', error);
+        }
+    }
+    removeGroupedNotifications(groupKey) {
+        try {
+            this.platform.native.removeGroupedNotifications(groupKey);
+        }
+        catch (error) {
+            this.logger.error('removeGroupedNotifications failed', error);
+        }
+    }
+    setAutoOpenUrls(enabled) {
+        try {
+            this.platform.native.setAutoOpenUrls(!!enabled);
+        }
+        catch (error) {
+            this.logger.error('setAutoOpenUrls failed', error);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Operation execution
+    // ---------------------------------------------------------------------------
+    async execute(operation, item) {
+        if (!this.state.config)
+            return { type: 'retry', countAttempt: false };
+        switch (operation.kind) {
+            case 'createUser':
+                return this.execCreateUser(operation);
+            case 'login':
+                return this.execLogin(operation);
+            case 'updateUser':
+                return this.execUpdateUser(operation);
+            case 'setAlias':
+                return this.execSetAlias(operation);
+            case 'removeAlias':
+                return this.execRemoveAlias(operation);
+            case 'fetchUser':
+                return this.execFetchUser(operation);
+            case 'syncSubscription':
+                return this.execSyncSubscription(item);
+            case 'createSubscription':
+                return this.execCreateSubscription(operation);
+            default:
+                return { type: 'drop', reason: 'unknown operation' };
+        }
+    }
+    userPath(qpushId) {
+        return `/apps/${this.appId}/users/by/qpush_id/${(0, url_1.encodeSegment)(qpushId)}`;
+    }
+    userProperties(localId) {
+        var _a, _b, _c, _d;
+        const user = this.state.user.localId === localId ? this.state.user : undefined;
+        const properties = {};
+        const language = (_a = user === null || user === void 0 ? void 0 : user.language) !== null && _a !== void 0 ? _a : (_b = this.device) === null || _b === void 0 ? void 0 : _b.language;
+        if (language)
+            properties.language = language;
+        if ((_c = this.device) === null || _c === void 0 ? void 0 : _c.timezone)
+            properties.timezone_id = this.device.timezone;
+        if ((_d = this.device) === null || _d === void 0 ? void 0 : _d.country)
+            properties.country = this.device.country;
+        return properties;
+    }
+    /** Tag changes still waiting in the queue for a user (to re-apply over server data). */
+    pendingTagChanges(localId) {
+        let changes = {};
+        for (const item of this.queue.pending) {
+            if (item.id === this.queue.inFlight)
+                continue;
+            const operation = item.operation;
+            if (operation.kind === 'updateUser' && operation.userLocalId === localId && operation.tags) {
+                changes = (0, tags_1.mergeTagChanges)(changes, operation.tags);
+            }
+        }
+        return changes;
+    }
+    pendingAliasChanges(localId, base) {
+        const aliases = { ...base };
+        for (const item of this.queue.pending) {
+            if (item.id === this.queue.inFlight)
+                continue;
+            const operation = item.operation;
+            if (operation.kind === 'setAlias' && operation.userLocalId === localId)
+                Object.assign(aliases, operation.aliases);
+            if (operation.kind === 'removeAlias' && operation.userLocalId === localId)
+                delete aliases[operation.label];
+        }
+        return aliases;
+    }
+    mapUser(localId, qpushId, identity) {
+        this.state.idMap[localId] = qpushId;
+        if (this.state.user.localId === localId) {
+            this.mutateUser(() => {
+                const user = this.state.user;
+                user.qpushId = qpushId;
+                if (identity) {
+                    user.aliases = this.pendingAliasChanges(localId, aliasesFromIdentity(identity));
+                    const externalId = identity.external_id;
+                    if (typeof externalId === 'string' && externalId)
+                        user.externalId = externalId;
+                }
+            });
+        }
+        this.pruneIdMap();
+        this.save();
+    }
+    /** Keeps only ids still referenced by the current user or pending operations. */
+    pruneIdMap() {
+        const referenced = new Set([this.state.user.localId]);
+        for (const item of this.queue.pending) {
+            const operation = item.operation;
+            if ('userLocalId' in operation)
+                referenced.add(operation.userLocalId);
+            if (operation.kind === 'login')
+                referenced.add(operation.previousLocalId);
+        }
+        for (const key of Object.keys(this.state.idMap)) {
+            if (!referenced.has(key))
+                delete this.state.idMap[key];
+        }
+    }
+    /** Picks this device's subscription in a user response. */
+    findOwnSubscription(subscriptions, sent) {
+        if (!Array.isArray(subscriptions) || subscriptions.length === 0)
+            return undefined;
+        const type = (0, subscription_1.subscriptionType)(this.platform.os);
+        if (sent.id) {
+            const byId = subscriptions.find((sub) => sub.id === sent.id);
+            if (byId)
+                return byId;
+        }
+        if (sent.token) {
+            const byToken = subscriptions.find((sub) => sub.token === sent.token);
+            if (byToken)
+                return byToken;
+        }
+        else {
+            const tokenless = subscriptions.filter((sub) => sub.type === type && !sub.token);
+            if (tokenless.length === 1)
+                return tokenless[0];
+        }
+        return subscriptions.length === 1 ? subscriptions[0] : undefined;
+    }
+    /** Applies a `POST /users` response (createUser, login fallback). */
+    applyCreatedUser(localId, data, sentFields, sentId, repushLocalTags) {
+        var _a, _b, _c;
+        const identity = ((_a = data === null || data === void 0 ? void 0 : data.identity) !== null && _a !== void 0 ? _a : {});
+        const qpushId = identityQPushId(identity);
+        if (!qpushId)
+            return { type: 'drop', reason: 'response without qpush_id' };
+        this.mapUser(localId, qpushId, identity);
+        if (this.state.user.localId === localId) {
+            const serverTags = stringTags((_b = data === null || data === void 0 ? void 0 : data.properties) === null || _b === void 0 ? void 0 : _b.tags);
+            const pending = this.pendingTagChanges(localId);
+            const local = this.state.user.tags;
+            // Re-push local tags the server does not have (never removals: a fresh
+            // install must not wipe the tags of a user it was re-attached to).
+            const missing = {};
+            if (repushLocalTags) {
+                for (const [key, value] of Object.entries(local)) {
+                    if (serverTags[key] !== value && !(key in pending))
+                        missing[key] = value;
+                }
+            }
+            this.state.user.tags = (0, tags_1.applyTagChanges)((0, tags_1.applyTagChanges)(serverTags, missing), pending);
+            if ((_c = this.device) === null || _c === void 0 ? void 0 : _c.timezone)
+                this.state.user.timezone = this.device.timezone;
+            if (!(0, tags_1.isEmpty)(missing)) {
+                this.queue.enqueue({ kind: 'updateUser', userLocalId: localId, tags: missing });
+            }
+        }
+        const own = this.findOwnSubscription(data === null || data === void 0 ? void 0 : data.subscriptions, { id: sentId, token: sentFields.token });
+        if (own === null || own === void 0 ? void 0 : own.id) {
+            this.state.subscription.synced = { ...sentFields };
+            this.setSubscriptionId(own.id);
+        }
+        else {
+            this.logger.warn('Could not identify this device subscription in the server response');
+        }
+        this.save();
+        this.scheduleSyncIfDirty();
+        return { type: 'success' };
+    }
+    async postUser(localId, identity, transferSubscription, repushLocalTags) {
+        const fields = this.currentFields();
+        const sentId = transferSubscription ? this.state.subscription.id : undefined;
+        const body = {
+            identity,
+            properties: this.userProperties(localId),
+            subscriptions: [(0, subscription_1.toSubscriptionPayload)(this.platform.os, fields, sentId)],
+        };
+        const response = await this.http.request('POST', `/apps/${this.appId}/users`, body);
+        if (!response.ok)
+            return (0, http_1.classifyResponse)(response);
+        return this.applyCreatedUser(localId, response.data, fields, sentId, repushLocalTags);
+    }
+    execCreateUser(operation) {
+        return this.postUser(operation.userLocalId, operation.identity, operation.transferSubscription, true);
+    }
+    async execLogin(operation) {
+        var _a, _b, _c, _d, _e;
+        const identity = { external_id: operation.externalId };
+        // 1. Identify the anonymous user (keeps its tags), like OneSignal.
+        const previousQPushId = this.state.idMap[operation.previousLocalId];
+        // Anonymous data carries over only when the anonymous user is identified
+        // (or never reached the server); it is discarded when switching users.
+        let carryAnonymousData = operation.previousWasAnonymous;
+        if (operation.previousWasAnonymous && previousQPushId) {
+            const response = await this.http.request('PATCH', `${this.userPath(previousQPushId)}/identity`, { identity });
+            if (response.ok) {
+                this.mapUser(operation.userLocalId, previousQPushId, (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.identity) !== null && _b !== void 0 ? _b : identity);
+                return { type: 'success' };
+            }
+            if (response.status !== 409 && response.status !== 404)
+                return (0, http_1.classifyResponse)(response);
+            carryAnonymousData = false;
+            this.logger.debug(`login: external id belongs to another user (${response.status}), switching user`);
+        }
+        // 2. Move this device's subscription to the user owning the external id.
+        const subscriptionId = this.state.subscription.id;
+        if (subscriptionId) {
+            const response = await this.http.request('PATCH', `/apps/${this.appId}/subscriptions/${(0, url_1.encodeSegment)(subscriptionId)}/owner`, { identity });
+            if (response.ok) {
+                const qpushId = identityQPushId((_c = response.data) === null || _c === void 0 ? void 0 : _c.identity);
+                if (!qpushId)
+                    return { type: 'drop', reason: 'owner response without qpush_id' };
+                this.mapUser(operation.userLocalId, qpushId, (_e = (_d = response.data) === null || _d === void 0 ? void 0 : _d.identity) !== null && _e !== void 0 ? _e : identity);
+                // The device switched to an existing user: refresh tags & aliases.
+                this.queue.enqueue({ kind: 'fetchUser', userLocalId: operation.userLocalId });
+                return { type: 'success' };
+            }
+            if (response.status !== 404)
+                return (0, http_1.classifyResponse)(response);
+            this.setSubscriptionId(undefined);
+            this.state.subscription.synced = undefined;
+        }
+        // 3. No subscription on the server yet: create the user with it.
+        return this.postUser(operation.userLocalId, identity, false, carryAnonymousData);
+    }
+    handleMissingUser(localId) {
+        delete this.state.idMap[localId];
+        if (this.state.user.localId !== localId)
+            return;
+        this.logger.warn('The current user no longer exists on the server, creating it again');
+        const previous = this.state.user;
+        const next = { ...previous, localId: this.uuid(), qpushId: undefined };
+        this.mutateUser(() => {
+            this.state.user = next;
+        });
+        this.queue.enqueue({
+            kind: 'createUser',
+            userLocalId: next.localId,
+            identity: next.externalId ? { external_id: next.externalId } : {},
+            transferSubscription: true,
+        });
+    }
+    resolveQPushId(localId) {
+        var _a;
+        return (_a = this.state.idMap[localId]) !== null && _a !== void 0 ? _a : (this.state.user.localId === localId ? this.state.user.qpushId : undefined);
+    }
+    async execUpdateUser(operation) {
+        var _a;
+        const qpushId = this.resolveQPushId(operation.userLocalId);
+        if (!qpushId)
+            return { type: 'drop', reason: 'user was never created on the server' };
+        const properties = { ...((_a = operation.properties) !== null && _a !== void 0 ? _a : {}) };
+        if (!(0, tags_1.isEmpty)(operation.tags))
+            properties.tags = operation.tags;
+        const body = {};
+        if (!(0, tags_1.isEmpty)(properties))
+            body.properties = properties;
+        if (!(0, tags_1.isEmpty)(operation.deltas))
+            body.deltas = operation.deltas;
+        if ((0, tags_1.isEmpty)(body))
+            return { type: 'success' };
+        const response = await this.http.request('PATCH', this.userPath(qpushId), body);
+        if (response.status === 404) {
+            this.handleMissingUser(operation.userLocalId);
+            return { type: 'drop', reason: 'user not found' };
+        }
+        return (0, http_1.classifyResponse)(response);
+    }
+    async execSetAlias(operation) {
+        var _a;
+        const qpushId = this.resolveQPushId(operation.userLocalId);
+        if (!qpushId)
+            return { type: 'drop', reason: 'user was never created on the server' };
+        const response = await this.http.request('PATCH', `${this.userPath(qpushId)}/identity`, { identity: operation.aliases });
+        if (response.ok) {
+            if (((_a = response.data) === null || _a === void 0 ? void 0 : _a.identity) && this.state.user.localId === operation.userLocalId) {
+                this.mapUser(operation.userLocalId, qpushId, response.data.identity);
+            }
+            return { type: 'success' };
+        }
+        if (response.status === 409) {
+            this.logger.error(`addAlias: alias already claimed by another user (${Object.keys(operation.aliases).join(', ')})`);
+            if (this.state.user.localId === operation.userLocalId) {
+                const aliases = { ...this.state.user.aliases };
+                for (const [label, id] of Object.entries(operation.aliases))
+                    if (aliases[label] === id)
+                        delete aliases[label];
+                this.state.user.aliases = aliases;
+                this.save();
+            }
+            return { type: 'drop', reason: 'alias_claimed' };
+        }
+        if (response.status === 404) {
+            this.handleMissingUser(operation.userLocalId);
+            return { type: 'drop', reason: 'user not found' };
+        }
+        return (0, http_1.classifyResponse)(response);
+    }
+    async execRemoveAlias(operation) {
+        const qpushId = this.resolveQPushId(operation.userLocalId);
+        if (!qpushId)
+            return { type: 'drop', reason: 'user was never created on the server' };
+        const response = await this.http.request('DELETE', `${this.userPath(qpushId)}/identity/${(0, url_1.encodeSegment)(operation.label)}`);
+        return (0, http_1.classifyResponse)(response);
+    }
+    async execFetchUser(operation) {
+        var _a, _b, _c;
+        const qpushId = this.resolveQPushId(operation.userLocalId);
+        if (!qpushId)
+            return { type: 'drop', reason: 'user was never created on the server' };
+        const response = await this.http.request('GET', this.userPath(qpushId));
+        if (response.status === 404) {
+            this.handleMissingUser(operation.userLocalId);
+            return { type: 'drop', reason: 'user not found' };
+        }
+        if (!response.ok)
+            return (0, http_1.classifyResponse)(response);
+        if (this.state.user.localId === operation.userLocalId && response.data) {
+            const identity = ((_a = response.data.identity) !== null && _a !== void 0 ? _a : {});
+            this.mapUser(operation.userLocalId, (_b = identityQPushId(identity)) !== null && _b !== void 0 ? _b : qpushId, identity);
+            const serverTags = stringTags((_c = response.data.properties) === null || _c === void 0 ? void 0 : _c.tags);
+            this.state.user.tags = (0, tags_1.applyTagChanges)(serverTags, this.pendingTagChanges(operation.userLocalId));
+            this.save();
+        }
+        return { type: 'success' };
+    }
+    async execSyncSubscription(item) {
+        var _a;
+        const sub = this.state.subscription;
+        if (!sub.id) {
+            // A pending create carries the live snapshot; nothing to do now.
+            if (this.queue.has((operation, other) => other.id !== item.id && (0, operations_1.createsSubscription)(operation))) {
+                return { type: 'success' };
+            }
+            if (!this.state.user.qpushId)
+                return { type: 'success' };
+            return this.execCreateSubscription({ kind: 'createSubscription', userLocalId: this.state.user.localId });
+        }
+        const fields = this.currentFields();
+        const patch = (0, subscription_1.diffSubscription)(sub.synced, fields);
+        const resetBadge = !!sub.badgeResetPending;
+        if (resetBadge)
+            patch.badge_count = 0;
+        if ((0, tags_1.isEmpty)(patch))
+            return { type: 'success' };
+        const response = await this.http.request('PATCH', `/apps/${this.appId}/subscriptions/${(0, url_1.encodeSegment)(sub.id)}`, { subscription: patch });
+        if (response.ok) {
+            const { badge_count: _ignored, ...sent } = patch;
+            void _ignored;
+            sub.synced = { ...((_a = sub.synced) !== null && _a !== void 0 ? _a : {}), ...sent };
+            if (resetBadge)
+                sub.badgeResetPending = false;
+            this.save();
+            this.scheduleSyncIfDirty();
+            return { type: 'success' };
+        }
+        if (response.status === 404) {
+            this.logger.warn('Subscription not found on the server, creating it again');
+            sub.synced = undefined;
+            this.setSubscriptionId(undefined);
+            this.queue.enqueue({ kind: 'createSubscription', userLocalId: this.state.user.localId });
+            return { type: 'drop', reason: 'subscription not found' };
+        }
+        return (0, http_1.classifyResponse)(response);
+    }
+    async execCreateSubscription(operation) {
+        var _a, _b;
+        if (this.state.subscription.id)
+            return { type: 'success' };
+        const qpushId = this.resolveQPushId(operation.userLocalId);
+        if (!qpushId)
+            return { type: 'drop', reason: 'user was never created on the server' };
+        const fields = this.currentFields();
+        const response = await this.http.request('POST', `${this.userPath(qpushId)}/subscriptions`, { subscription: (0, subscription_1.toSubscriptionPayload)(this.platform.os, fields) });
+        if (response.ok) {
+            const id = (_b = (_a = response.data) === null || _a === void 0 ? void 0 : _a.subscription) === null || _b === void 0 ? void 0 : _b.id;
+            if (!id)
+                return { type: 'drop', reason: 'response without subscription id' };
+            this.state.subscription.synced = { ...fields };
+            this.setSubscriptionId(id);
+            this.scheduleSyncIfDirty();
+            return { type: 'success' };
+        }
+        if (response.status === 404) {
+            this.handleMissingUser(operation.userLocalId);
+            return { type: 'drop', reason: 'user not found' };
+        }
+        return (0, http_1.classifyResponse)(response);
+    }
+    /** @internal Used by the facade to know whether `initialize` was called. */
+    get isInitialized() {
+        return this.initializeCalled;
+    }
+}
+exports.QPushCore = QPushCore;