react-native-update 8.5.4 → 8.5.6

package/.swcrc

@@ -0,0 +1,15 @@
+{
+  "jsc": {
+    "loose": true,
+    "target": "es2018",
+    "parser": {
+      "syntax": "typescript",
+      "tsx": false,
+      "decorators": false,
+      "dynamicImport": false
+    }
+  },
+  "module": {
+    "type": "commonjs"
+  }
+}

package/dist/endpoint.d.ts

@@ -0,0 +1,13 @@
+export declare function updateBackupEndpoints(): Promise<string[]>;
+export declare function getCheckUrl(APPKEY: any, endpoint?: string): string;
+/**
+ * @param {string} main - The main api endpoint
+ * @param {string[]} [backups] - The back up endpoints.
+ * @param {string} [backupQueryUrl] - An url that return a json file containing an array of endpoint.
+ *                                    like: ["https://backup.api/1", "https://backup.api/2"]
+ */
+export declare function setCustomEndpoints({ main, backups, backupQueryUrls, }: {
+    main: string;
+    backups?: string[];
+    backupQueryUrls?: string[];
+}): void;

package/dist/endpoint.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCustomEndpoints = exports.getCheckUrl = exports.updateBackupEndpoints = void 0;
+const utils_1 = require("./utils");
+let currentEndpoint = 'https://update.react-native.cn/api';
+let backupEndpoints = [
+    'https://pushy-koa-qgbgqmcpis.cn-beijing.fcapp.run',
+    'https://update.reactnative.cn/api',
+];
+let backupEndpointsQueryUrls = [
+    'https://gitee.com/sunnylqm/react-native-pushy/raw/master/endpoints.json',
+    'https://cdn.jsdelivr.net/gh/reactnativecn/react-native-pushy@master/endpoints.json',
+];
+function updateBackupEndpoints() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (backupEndpointsQueryUrls) {
+            try {
+                const resp = yield (0, utils_1.promiseAny)(backupEndpointsQueryUrls.map((queryUrl) => fetch(queryUrl)));
+                const remoteEndpoints = yield resp.json();
+                if (Array.isArray(remoteEndpoints)) {
+                    backupEndpoints = Array.from(new Set([...backupEndpoints, ...remoteEndpoints]));
+                    (0, utils_1.logger)('fetch remote endpoints:', remoteEndpoints);
+                    (0, utils_1.logger)('merged backup endpoints:', backupEndpoints);
+                }
+            }
+            catch (e) {
+                (0, utils_1.logger)('fetch remote endpoints failed');
+            }
+        }
+        return backupEndpoints;
+    });
+}
+exports.updateBackupEndpoints = updateBackupEndpoints;
+function getCheckUrl(APPKEY, endpoint = currentEndpoint) {
+    return `${endpoint}/checkUpdate/${APPKEY}`;
+}
+exports.getCheckUrl = getCheckUrl;
+/**
+ * @param {string} main - The main api endpoint
+ * @param {string[]} [backups] - The back up endpoints.
+ * @param {string} [backupQueryUrl] - An url that return a json file containing an array of endpoint.
+ *                                    like: ["https://backup.api/1", "https://backup.api/2"]
+ */
+function setCustomEndpoints({ main, backups, backupQueryUrls, }) {
+    currentEndpoint = main;
+    if (Array.isArray(backups) && backups.length > 0) {
+        backupEndpoints = backups;
+    }
+    if (Array.isArray(backupQueryUrls) && backupQueryUrls.length > 0) {
+        backupEndpointsQueryUrls = backupQueryUrls;
+    }
+}
+exports.setCustomEndpoints = setCustomEndpoints;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './main';
+export * from './simpleUpdate';

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./main"), exports);
+__exportStar(require("./simpleUpdate"), exports);

package/dist/main.d.ts

@@ -0,0 +1,33 @@
+import { setCustomEndpoints } from './endpoint';
+import { CheckResult, ProgressData, UpdateAvailableResult, UpdateEventsListener } from './type';
+export { setCustomEndpoints };
+export declare const PushyModule: any;
+export declare const downloadRootDir: any;
+export declare const packageVersion: any;
+export declare const currentVersion: any;
+export declare const isFirstTime: any;
+export declare const isRolledBack: boolean;
+export declare const buildTime: any;
+export declare function getCurrentVersionInfo(): Promise<{
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+}>;
+export declare function onPushyEvents(customReporter: UpdateEventsListener): void;
+export declare const cInfo: {
+    pushy: any;
+    rn: string;
+    os: string;
+    uuid: any;
+};
+export declare function checkUpdate(APPKEY: string): Promise<CheckResult>;
+export declare function downloadUpdate(options: UpdateAvailableResult, eventListeners?: {
+    onDownloadProgress?: (data: ProgressData) => void;
+}): Promise<string | void>;
+export declare function switchVersion(hash: string): void;
+export declare function switchVersionLater(hash: string): void;
+export declare function markSuccess(): void;
+export declare function downloadAndInstallApk({ url, onDownloadProgress, }: {
+    url: string;
+    onDownloadProgress?: (data: ProgressData) => void;
+}): Promise<void>;

package/dist/main.js

@@ -0,0 +1,346 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadAndInstallApk = exports.markSuccess = exports.switchVersionLater = exports.switchVersion = exports.downloadUpdate = exports.checkUpdate = exports.cInfo = exports.onPushyEvents = exports.getCurrentVersionInfo = exports.buildTime = exports.isRolledBack = exports.isFirstTime = exports.currentVersion = exports.packageVersion = exports.downloadRootDir = exports.PushyModule = exports.setCustomEndpoints = void 0;
+const endpoint_1 = require("./endpoint");
+Object.defineProperty(exports, "setCustomEndpoints", { enumerable: true, get: function () { return endpoint_1.setCustomEndpoints; } });
+const react_native_1 = require("react-native");
+const utils_1 = require("./utils");
+const { version: v, } = require('react-native/Libraries/Core/ReactNativeVersion');
+const RNVersion = `${v.major}.${v.minor}.${v.patch}`;
+exports.PushyModule = react_native_1.NativeModules.Pushy;
+if (!exports.PushyModule) {
+    throw new Error('react-native-update模块无法加载，请对照安装文档检查配置。');
+}
+const PushyConstants = exports.PushyModule;
+exports.downloadRootDir = PushyConstants.downloadRootDir;
+exports.packageVersion = PushyConstants.packageVersion;
+exports.currentVersion = PushyConstants.currentVersion;
+exports.isFirstTime = PushyConstants.isFirstTime;
+const rolledBackVersion = PushyConstants.rolledBackVersion;
+exports.isRolledBack = typeof rolledBackVersion === 'string';
+exports.buildTime = PushyConstants.buildTime;
+let blockUpdate = PushyConstants.blockUpdate;
+let uuid = PushyConstants.uuid;
+if (react_native_1.Platform.OS === 'android' && !PushyConstants.isUsingBundleUrl) {
+    throw new Error('react-native-update模块无法加载，请对照文档检查Bundle URL的配置');
+}
+function setLocalHashInfo(hash, info) {
+    exports.PushyModule.setLocalHashInfo(hash, JSON.stringify(info));
+}
+function getLocalHashInfo(hash) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return JSON.parse(yield exports.PushyModule.getLocalHashInfo(hash));
+    });
+}
+function getCurrentVersionInfo() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return exports.currentVersion ? (yield getLocalHashInfo(exports.currentVersion)) || {} : {};
+    });
+}
+exports.getCurrentVersionInfo = getCurrentVersionInfo;
+const eventEmitter = new react_native_1.NativeEventEmitter(exports.PushyModule);
+if (!uuid) {
+    uuid = require('nanoid/non-secure').nanoid();
+    exports.PushyModule.setUuid(uuid);
+}
+const noop = () => { };
+let reporter = noop;
+function onPushyEvents(customReporter) {
+    reporter = customReporter;
+    if (exports.isRolledBack) {
+        report({
+            type: 'rollback',
+            data: {
+                rolledBackVersion,
+            },
+        });
+    }
+}
+exports.onPushyEvents = onPushyEvents;
+function report({ type, message = '', data = {}, }) {
+    (0, utils_1.logger)(type + ' ' + message);
+    reporter({
+        type,
+        data: Object.assign({ currentVersion: exports.currentVersion,
+            cInfo: exports.cInfo,
+            packageVersion: exports.packageVersion,
+            buildTime: exports.buildTime,
+            message }, data),
+    });
+}
+(0, utils_1.logger)('uuid: ' + uuid);
+exports.cInfo = {
+    pushy: require('../package.json').version,
+    rn: RNVersion,
+    os: react_native_1.Platform.OS + ' ' + react_native_1.Platform.Version,
+    uuid,
+};
+let lastChecking;
+const empty = {};
+let lastResult;
+function checkUpdate(APPKEY) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, utils_1.assertRelease)();
+        const now = Date.now();
+        if (lastResult && lastChecking && now - lastChecking < 1000 * 60) {
+            // logger('repeated checking, ignored');
+            return lastResult;
+        }
+        lastChecking = now;
+        if (blockUpdate && blockUpdate.until > Date.now() / 1000) {
+            report({
+                type: 'errorChecking',
+                message: `热更新已暂停，原因：${blockUpdate.reason}。请在"${new Date(blockUpdate.until * 1000).toLocaleString()}"之后重试。`,
+            });
+            return lastResult || empty;
+        }
+        report({ type: 'checking' });
+        const fetchPayload = {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                packageVersion: exports.packageVersion,
+                hash: exports.currentVersion,
+                buildTime: exports.buildTime,
+                cInfo: exports.cInfo,
+            }),
+        };
+        let resp;
+        try {
+            resp = yield fetch((0, endpoint_1.getCheckUrl)(APPKEY), fetchPayload);
+        }
+        catch (e) {
+            report({
+                type: 'errorChecking',
+                message: '无法连接主更新服务器，尝试备用节点',
+            });
+            const backupEndpoints = yield (0, endpoint_1.updateBackupEndpoints)();
+            if (backupEndpoints) {
+                try {
+                    resp = yield (0, utils_1.promiseAny)(backupEndpoints.map((endpoint) => fetch((0, endpoint_1.getCheckUrl)(APPKEY, endpoint), fetchPayload)));
+                }
+                catch (_a) { }
+            }
+        }
+        if (!resp) {
+            report({
+                type: 'errorChecking',
+                message: '无法连接更新服务器，请检查网络连接后重试',
+            });
+            return lastResult || empty;
+        }
+        const result = yield resp.json();
+        lastResult = result;
+        // @ts-ignore
+        checkOperation(result.op);
+        if (resp.status !== 200) {
+            report({
+                type: 'errorChecking',
+                //@ts-ignore
+                message: result.message,
+            });
+        }
+        return result;
+    });
+}
+exports.checkUpdate = checkUpdate;
+function checkOperation(op) {
+    if (!Array.isArray(op)) {
+        return;
+    }
+    op.forEach((action) => {
+        if (action.type === 'block') {
+            blockUpdate = {
+                reason: action.reason,
+                until: Math.round((Date.now() + action.duration) / 1000),
+            };
+            exports.PushyModule.setBlockUpdate(blockUpdate);
+        }
+    });
+}
+let downloadingThrottling = false;
+let downloadedHash;
+function downloadUpdate(options, eventListeners) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, utils_1.assertRelease)();
+        if (!options.update) {
+            return;
+        }
+        if (rolledBackVersion === options.hash) {
+            (0, utils_1.logger)(`rolledback hash ${rolledBackVersion}, ignored`);
+            return;
+        }
+        if (downloadedHash === options.hash) {
+            (0, utils_1.logger)(`duplicated downloaded hash ${downloadedHash}, ignored`);
+            return downloadedHash;
+        }
+        if (downloadingThrottling) {
+            (0, utils_1.logger)('repeated downloading, ignored');
+            return;
+        }
+        downloadingThrottling = true;
+        setTimeout(() => {
+            downloadingThrottling = false;
+        }, 3000);
+        let progressHandler;
+        if (eventListeners) {
+            if (eventListeners.onDownloadProgress) {
+                const downloadCallback = eventListeners.onDownloadProgress;
+                progressHandler = eventEmitter.addListener('RCTPushyDownloadProgress', (progressData) => {
+                    if (progressData.hash === options.hash) {
+                        downloadCallback(progressData);
+                    }
+                });
+            }
+        }
+        let succeeded = false;
+        report({ type: 'downloading' });
+        const diffUrl = (yield (0, utils_1.testUrls)(options.diffUrls)) || options.diffUrl;
+        if (diffUrl) {
+            (0, utils_1.logger)('downloading diff');
+            try {
+                yield exports.PushyModule.downloadPatchFromPpk({
+                    updateUrl: diffUrl,
+                    hash: options.hash,
+                    originHash: exports.currentVersion,
+                });
+                succeeded = true;
+            }
+            catch (e) {
+                (0, utils_1.logger)(`diff error: ${e.message}, try pdiff`);
+            }
+        }
+        if (!succeeded) {
+            const pdiffUrl = (yield (0, utils_1.testUrls)(options.pdiffUrls)) || options.pdiffUrl;
+            if (pdiffUrl) {
+                (0, utils_1.logger)('downloading pdiff');
+                try {
+                    yield exports.PushyModule.downloadPatchFromPackage({
+                        updateUrl: pdiffUrl,
+                        hash: options.hash,
+                    });
+                    succeeded = true;
+                }
+                catch (e) {
+                    (0, utils_1.logger)(`pdiff error: ${e.message}, try full patch`);
+                }
+            }
+        }
+        if (!succeeded) {
+            const updateUrl = (yield (0, utils_1.testUrls)(options.updateUrls)) || options.updateUrl;
+            if (updateUrl) {
+                (0, utils_1.logger)('downloading full patch');
+                try {
+                    yield exports.PushyModule.downloadFullUpdate({
+                        updateUrl: updateUrl,
+                        hash: options.hash,
+                    });
+                    succeeded = true;
+                }
+                catch (e) {
+                    (0, utils_1.logger)(`full patch error: ${e.message}`);
+                }
+            }
+        }
+        progressHandler && progressHandler.remove();
+        if (!succeeded) {
+            return report({ type: 'errorUpdate', data: { newVersion: options.hash } });
+        }
+        setLocalHashInfo(options.hash, {
+            name: options.name,
+            description: options.description,
+            metaInfo: options.metaInfo,
+        });
+        downloadedHash = options.hash;
+        return options.hash;
+    });
+}
+exports.downloadUpdate = downloadUpdate;
+function assertHash(hash) {
+    if (!downloadedHash) {
+        (0, utils_1.logger)(`no downloaded hash`);
+        return;
+    }
+    if (hash !== downloadedHash) {
+        (0, utils_1.logger)(`use downloaded hash ${downloadedHash} first`);
+        return;
+    }
+    return true;
+}
+function switchVersion(hash) {
+    (0, utils_1.assertRelease)();
+    if (assertHash(hash)) {
+        (0, utils_1.logger)('switchVersion: ' + hash);
+        exports.PushyModule.reloadUpdate({ hash });
+    }
+}
+exports.switchVersion = switchVersion;
+function switchVersionLater(hash) {
+    (0, utils_1.assertRelease)();
+    if (assertHash(hash)) {
+        (0, utils_1.logger)('switchVersionLater: ' + hash);
+        exports.PushyModule.setNeedUpdate({ hash });
+    }
+}
+exports.switchVersionLater = switchVersionLater;
+let marked = false;
+function markSuccess() {
+    (0, utils_1.assertRelease)();
+    if (marked) {
+        (0, utils_1.logger)('repeated markSuccess, ignored');
+        return;
+    }
+    marked = true;
+    exports.PushyModule.markSuccess();
+    report({ type: 'markSuccess' });
+}
+exports.markSuccess = markSuccess;
+function downloadAndInstallApk({ url, onDownloadProgress, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (react_native_1.Platform.OS !== 'android') {
+            return;
+        }
+        report({ type: 'downloadingApk' });
+        if (react_native_1.Platform.Version <= 23) {
+            try {
+                const granted = yield react_native_1.PermissionsAndroid.request(react_native_1.PermissionsAndroid.PERMISSIONS.WRITE_EXTERNAL_STORAGE);
+                if (granted !== react_native_1.PermissionsAndroid.RESULTS.GRANTED) {
+                    return report({ type: 'rejectStoragePermission' });
+                }
+            }
+            catch (err) {
+                return report({ type: 'errorStoragePermission' });
+            }
+        }
+        let hash = Date.now().toString();
+        let progressHandler;
+        if (onDownloadProgress) {
+            progressHandler = eventEmitter.addListener('RCTPushyDownloadProgress', (progressData) => {
+                if (progressData.hash === hash) {
+                    onDownloadProgress(progressData);
+                }
+            });
+        }
+        yield exports.PushyModule.downloadAndInstallApk({
+            url,
+            target: 'update.apk',
+            hash,
+        }).catch(() => {
+            report({ type: 'errowDownloadAndInstallApk' });
+        });
+        progressHandler && progressHandler.remove();
+    });
+}
+exports.downloadAndInstallApk = downloadAndInstallApk;

package/dist/simpleUpdate.d.ts

@@ -0,0 +1,61 @@
+import React, { ComponentType } from 'react';
+import { NativeEventSubscription } from 'react-native';
+import { UpdateEventsListener } from './type';
+export declare function simpleUpdate(WrappedComponent: ComponentType, options?: {
+    appKey?: string;
+    onPushyEvents?: UpdateEventsListener;
+}): React.ComponentType | {
+    new (props: {} | Readonly<{}>): {
+        stateListener: NativeEventSubscription | null;
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        doUpdate: (info: any) => Promise<void>;
+        checkUpdate: () => Promise<void>;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: {}, context: any): {
+        stateListener: NativeEventSubscription | null;
+        componentDidMount(): void;
+        componentWillUnmount(): void;
+        doUpdate: (info: any) => Promise<void>;
+        checkUpdate: () => Promise<void>;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<{}>) => {} | Pick<{}, K> | null) | Pick<{}, K> | null, callback?: (() => void) | undefined): void;
+        forceUpdate(callback?: (() => void) | undefined): void;
+        readonly props: Readonly<{}>;
+        state: Readonly<{}>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<{}>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{}>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<{}>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any> | undefined;
+};

package/dist/simpleUpdate.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleUpdate = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const main_1 = require("./main");
+function simpleUpdate(WrappedComponent, options = {}) {
+    const { appKey, onPushyEvents: eventListeners } = options;
+    if (!appKey) {
+        throw new Error('appKey is required for simpleUpdate()');
+    }
+    if (typeof eventListeners === 'function') {
+        (0, main_1.onPushyEvents)(eventListeners);
+    }
+    return __DEV__
+        ? WrappedComponent
+        : class AppUpdate extends react_1.PureComponent {
+            constructor() {
+                super(...arguments);
+                this.stateListener = null;
+                this.doUpdate = (info) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const hash = yield (0, main_1.downloadUpdate)(info);
+                        if (!hash) {
+                            return;
+                        }
+                        this.stateListener && this.stateListener.remove();
+                        react_native_1.Alert.alert('提示', '下载完毕，是否立即更新?', [
+                            {
+                                text: '以后再说',
+                                style: 'cancel',
+                                onPress: () => {
+                                    (0, main_1.switchVersionLater)(hash);
+                                },
+                            },
+                            {
+                                text: '立即更新',
+                                style: 'default',
+                                onPress: () => {
+                                    (0, main_1.switchVersion)(hash);
+                                },
+                            },
+                        ]);
+                    }
+                    catch (err) {
+                        react_native_1.Alert.alert('更新失败', err.message);
+                    }
+                });
+                this.checkUpdate = () => __awaiter(this, void 0, void 0, function* () {
+                    let info;
+                    try {
+                        info = yield (0, main_1.checkUpdate)(appKey);
+                    }
+                    catch (err) {
+                        react_native_1.Alert.alert('更新检查失败', err.message);
+                        return;
+                    }
+                    if (info.expired) {
+                        react_native_1.Alert.alert('提示', '您的应用版本已更新，点击确定下载安装新版本', [
+                            {
+                                text: '确定',
+                                onPress: () => {
+                                    if (info.downloadUrl) {
+                                        if (react_native_1.Platform.OS === 'android' &&
+                                            info.downloadUrl.endsWith('.apk')) {
+                                            (0, main_1.downloadAndInstallApk)({
+                                                url: info.downloadUrl,
+                                            });
+                                        }
+                                        else {
+                                            react_native_1.Linking.openURL(info.downloadUrl);
+                                        }
+                                    }
+                                },
+                            },
+                        ]);
+                    }
+                    else if (info.update) {
+                        react_native_1.Alert.alert('提示', '检查到新的版本' + info.name + ',是否下载?\n' + info.description, [
+                            { text: '否', style: 'cancel' },
+                            {
+                                text: '是',
+                                style: 'default',
+                                onPress: () => {
+                                    this.doUpdate(info);
+                                },
+                            },
+                        ]);
+                    }
+                });
+            }
+            componentDidMount() {
+                if (main_1.isRolledBack) {
+                    react_native_1.Alert.alert('抱歉', '刚刚更新遭遇错误，已为您恢复到更新前版本');
+                }
+                else if (main_1.isFirstTime) {
+                    (0, main_1.markSuccess)();
+                }
+                this.stateListener = react_native_1.AppState.addEventListener('change', (nextAppState) => {
+                    if (nextAppState === 'active') {
+                        this.checkUpdate();
+                    }
+                });
+                this.checkUpdate();
+            }
+            componentWillUnmount() {
+                this.stateListener && this.stateListener.remove();
+            }
+            render() {
+                return <WrappedComponent {...this.props}/>;
+            }
+        };
+}
+exports.simpleUpdate = simpleUpdate;

package/dist/type.d.ts

@@ -0,0 +1,51 @@
+export interface ExpiredResult {
+    upToDate?: false;
+    expired: true;
+    downloadUrl: string;
+}
+export interface UpTodateResult {
+    expired?: false;
+    upToDate: true;
+    paused?: 'app' | 'package';
+}
+export interface UpdateAvailableResult {
+    expired?: false;
+    upToDate?: false;
+    update: true;
+    name: string;
+    hash: string;
+    description: string;
+    metaInfo: string;
+    pdiffUrl: string;
+    pdiffUrls?: string[];
+    diffUrl?: string;
+    diffUrls?: string[];
+    updateUrl?: string;
+    updateUrls?: string[];
+}
+export type CheckResult = ExpiredResult | UpTodateResult | UpdateAvailableResult | {};
+export interface ProgressData {
+    hash: string;
+    received: number;
+    total: number;
+}
+export type EventType = 'rollback' | 'errorChecking' | 'checking' | 'downloading' | 'errorUpdate' | 'markSuccess' | 'downloadingApk' | 'rejectStoragePermission' | 'errorStoragePermission' | 'errowDownloadAndInstallApk';
+export interface EventData {
+    currentVersion: string;
+    cInfo: {
+        pushy: string;
+        rn: string;
+        os: string;
+        uuid: string;
+    };
+    packageVersion: string;
+    buildTime: number;
+    message?: string;
+    rolledBackVersion?: string;
+    newVersion?: string;
+    [key: string]: any;
+}
+export type UpdateEventsListener = ({ type, data, }: {
+    type: EventType;
+    data: EventData;
+}) => void;

package/dist/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function promiseAny<T>(promises: Promise<T>[]): Promise<T>;
+export declare function logger(...args: any[]): void;
+export declare function assertRelease(): void;
+export declare const testUrls: (urls?: string[]) => Promise<{} | null>;

package/dist/utils.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testUrls = exports.assertRelease = exports.logger = exports.promiseAny = void 0;
+const react_native_1 = require("react-native");
+function promiseAny(promises) {
+    return new Promise((resolve, reject) => {
+        let count = 0;
+        promises.forEach((promise) => {
+            Promise.resolve(promise)
+                .then(resolve)
+                .catch(() => {
+                count++;
+                if (count === promises.length) {
+                    reject(new Error('All promises were rejected'));
+                }
+            });
+        });
+    });
+}
+exports.promiseAny = promiseAny;
+function logger(...args) {
+    console.log('Pushy: ', ...args);
+}
+exports.logger = logger;
+function assertRelease() {
+    if (__DEV__) {
+        throw new Error('react-native-update 只能在 RELEASE 版本中运行.');
+    }
+}
+exports.assertRelease = assertRelease;
+const ping = react_native_1.Platform.OS === 'web'
+    ? Promise.resolve
+    : (url) => __awaiter(void 0, void 0, void 0, function* () {
+        let pingFinished = false;
+        return Promise.race([
+            fetch(url, {
+                method: 'HEAD',
+            })
+                .then(({ status, statusText }) => {
+                pingFinished = true;
+                if (status === 200) {
+                    return url;
+                }
+                logger('ping failed', url, status, statusText);
+                throw new Error('Ping failed');
+            })
+                .catch((e) => {
+                pingFinished = true;
+                logger('ping error', url, e);
+                throw e;
+            }),
+            new Promise((_, reject) => setTimeout(() => {
+                reject(new Error('Ping timeout'));
+                if (!pingFinished) {
+                    logger('ping timeout', url);
+                }
+            }, 2000)),
+        ]);
+    });
+const testUrls = (urls) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(urls === null || urls === void 0 ? void 0 : urls.length)) {
+        return null;
+    }
+    try {
+        const ret = yield promiseAny(urls.map(ping));
+        if (ret) {
+            return ret;
+        }
+    }
+    catch (_a) { }
+    logger('all ping failed, use first url:', urls[0]);
+    return urls[0];
+});
+exports.testUrls = testUrls;

package/lib/endpoint.ts

@@ -24,7 +24,7 @@ export async function updateBackupEndpoints() {
         logger('fetch remote endpoints:', remoteEndpoints);
         logger('merged backup endpoints:', backupEndpoints);
       }
-    } catch (e) {
+    } catch (e: any) {
       logger('fetch remote endpoints failed');
     }
   }

package/lib/main.ts

@@ -154,7 +154,7 @@ export async function checkUpdate(APPKEY: string) {
   let resp;
   try {
     resp = await fetch(getCheckUrl(APPKEY), fetchPayload);
-  } catch (e) {
+  } catch (e: any) {
     report({
       type: 'errorChecking',
       message: '无法连接主更新服务器，尝试备用节点',
@@ -265,7 +265,7 @@ export async function downloadUpdate(
         originHash: currentVersion,
       });
       succeeded = true;
-    } catch (e) {
+    } catch (e: any) {
       logger(`diff error: ${e.message}, try pdiff`);
     }
   }
@@ -279,7 +279,7 @@ export async function downloadUpdate(
           hash: options.hash,
         });
         succeeded = true;
-      } catch (e) {
+      } catch (e: any) {
         logger(`pdiff error: ${e.message}, try full patch`);
       }
     }
@@ -294,7 +294,7 @@ export async function downloadUpdate(
           hash: options.hash,
         });
         succeeded = true;
-      } catch (e) {
+      } catch (e: any) {
         logger(`full patch error: ${e.message}`);
       }
     }
@@ -371,7 +371,7 @@ export async function downloadAndInstallApk({
       if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
         return report({ type: 'rejectStoragePermission' });
       }
-    } catch (err) {
+    } catch (err: any) {
       return report({ type: 'errorStoragePermission' });
     }
   }

package/lib/simpleUpdate.tsx

@@ -34,7 +34,7 @@ export function simpleUpdate(
   return __DEV__
     ? WrappedComponent
     : class AppUpdate extends PureComponent {
-        stateListener: NativeEventSubscription;
+        stateListener: NativeEventSubscription | null = null;
         componentDidMount() {
           if (isRolledBack) {
             Alert.alert('抱歉', '刚刚更新遭遇错误，已为您恢复到更新前版本');
@@ -77,7 +77,7 @@ export function simpleUpdate(
                 },
               },
             ]);
-          } catch (err) {
+          } catch (err: any) {
             Alert.alert('更新失败', err.message);
           }
         };
@@ -86,7 +86,7 @@ export function simpleUpdate(
           let info;
           try {
             info = await checkUpdate(appKey!);
-          } catch (err) {
+          } catch (err: any) {
             Alert.alert('更新检查失败', err.message);
             return;
           }

package/lib/utils.ts

@@ -4,7 +4,7 @@ export function promiseAny<T>(promises: Promise<T>[]) {
   return new Promise<T>((resolve, reject) => {
     let count = 0;
 
-    promises.forEach(promise => {
+    promises.forEach((promise) => {
       Promise.resolve(promise)
         .then(resolve)
         .catch(() => {
@@ -44,7 +44,7 @@ const ping =
               logger('ping failed', url, status, statusText);
               throw new Error('Ping failed');
             })
-            .catch(e => {
+            .catch((e) => {
               pingFinished = true;
               logger('ping error', url, e);
               throw e;
@@ -60,15 +60,16 @@ const ping =
         ]);
       };
 
-
 export const testUrls = async (urls?: string[]) => {
   if (!urls?.length) {
     return null;
   }
-  const ret = await promiseAny(urls.map(ping));
-  if (ret) {
-    return ret;
-  }
+  try {
+    const ret = await promiseAny(urls.map(ping));
+    if (ret) {
+      return ret;
+    }
+  } catch {}
   logger('all ping failed, use first url:', urls[0]);
   return urls[0];
 };

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "react-native-update",
-  "version": "8.5.4",
+  "version": "8.5.6",
   "description": "react-native hot update",
-  "main": "lib/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "prepublish": "yarn submodule",
+    "prepublish": "yarn submodule && yarn build",
+    "build": "yarn clean && tsc",
+    "clean": "rm -rf dist",
     "submodule": "git submodule update --init --recursive",
     "test": "echo \"Error: no test specified\" && exit 1",
     "build-lib": "yarn submodule && $ANDROID_HOME/ndk/20.1.5948944/ndk-build NDK_PROJECT_PATH=android APP_BUILD_SCRIPT=android/jni/Android.mk NDK_APPLICATION_MK=android/jni/Application.mk NDK_LIBS_OUT=android/lib"
@@ -25,7 +28,7 @@
     "url": "https://github.com/reactnativecn/react-native-pushy/issues"
   },
   "peerDependencies": {
-    "react-native": ">=0.57.0"
+    "react-native": "*"
   },
   "homepage": "https://github.com/reactnativecn/react-native-pushy#readme",
   "dependencies": {

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "noImplicitAny": false,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "jsx": "react-native",
+    "lib": ["es2016", "dom"],
+    "moduleResolution": "node"
+  },
+  "include": ["lib/**/*"],
+  "exclude": ["node_modules", "dist", "Example"]
+}