native-update/dist/esm/app-update/app-update-checker.js

Foundation package for building a comprehensive update system for Capacitor apps. Provides architecture and interfaces but requires backend implementation.

import { Logger } from '../core/logger';
export class AppUpdateChecker {
    constructor(config) {
        this.config = config;
        this.logger = new Logger('AppUpdateChecker');
    }
    async checkServerVersion(_) {
        if (!this.config.updateUrl) {
            return {};
        }
        try {
            const url = new URL(`${this.config.updateUrl}/app-version`);
            url.searchParams.append('platform', this.getPlatform());
            url.searchParams.append('current', await this.getCurrentVersion());
            if (this.config.channel) {
                url.searchParams.append('channel', this.config.channel);
            }
            const response = await fetch(url.toString(), {
                method: 'GET',
                headers: {
                    Accept: 'application/json',
                    'X-App-Version': await this.getCurrentVersion(),
                    'X-App-Platform': this.getPlatform(),
                },
            });
            if (!response.ok) {
                throw new Error(`Server returned ${response.status}`);
            }
            const data = await response.json();
            return {
                availableVersion: data.version,
                updatePriority: data.priority,
                releaseNotes: data.releaseNotes,
                updateSize: data.size,
                updateURL: data.downloadUrl,
            };
        }
        catch (error) {
            this.logger.error('Failed to check server version', error);
            return {};
        }
    }
    compareVersions(version1, version2) {
        const v1Parts = version1.split('.').map(Number);
        const v2Parts = version2.split('.').map(Number);
        for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
            const v1Part = v1Parts[i] || 0;
            const v2Part = v2Parts[i] || 0;
            if (v1Part > v2Part)
                return 1;
            if (v1Part < v2Part)
                return -1;
        }
        return 0;
    }
    isUpdateRequired(currentVersion, availableVersion, minimumVersion) {
        // Check if current version is less than available
        if (this.compareVersions(currentVersion, availableVersion) < 0) {
            return true;
        }
        // Check if current version meets minimum requirement
        if (minimumVersion &&
            this.compareVersions(currentVersion, minimumVersion) < 0) {
            return true;
        }
        return false;
    }
    determineUpdatePriority(versionDiff, stalenessDays) {
        // Parse version difference
        const [major, minor] = versionDiff.split('.').map(Number);
        // Major version change = IMMEDIATE (priority 5)
        if (major > 0) {
            return 5;
        }
        // Minor version with high staleness = HIGH (priority 4)
        if (minor > 0 && stalenessDays && stalenessDays > 30) {
            return 4;
        }
        // Minor version = MEDIUM (priority 3)
        if (minor > 0) {
            return 3;
        }
        // Patch version = LOW (priority 1)
        return 1;
    }
    async getCurrentVersion() {
        // This would be implemented by the native platform
        return '1.0.0';
    }
    getPlatform() {
        // Detect platform
        if (typeof window !== 'undefined') {
            const userAgent = window.navigator.userAgent;
            if (/android/i.test(userAgent)) {
                return 'android';
            }
            else if (/iPad|iPhone|iPod/.test(userAgent)) {
                return 'ios';
            }
        }
        return 'web';
    }
}
//# sourceMappingURL=app-update-checker.js.map