react-native-update 8.5.5 → 8.5.7

package/.cursor/mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "RadonAi": {
+      "url": "http://127.0.0.1:53976/mcp",
+      "type": "http",
+      "headers": {
+        "nonce": "199ac31c-50fd-441b-802e-5e8067371986"
+      }
+    }
+  }
+}

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,58 @@
+"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.updateBackupEndpoints = updateBackupEndpoints;
+exports.getCheckUrl = getCheckUrl;
+exports.setCustomEndpoints = setCustomEndpoints;
+const utils_1 = require("./utils");
+let currentEndpoint = 'https://update.react-native.cn/api';
+let backupEndpoints = ['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;
+    });
+}
+function getCheckUrl(APPKEY, endpoint = currentEndpoint) {
+    return `${endpoint}/checkUpdate/${APPKEY}`;
+}
+/**
+ * @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;
+    }
+}

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.cInfo = exports.buildTime = exports.isRolledBack = exports.isFirstTime = exports.currentVersion = exports.packageVersion = exports.downloadRootDir = exports.PushyModule = exports.setCustomEndpoints = void 0;
+exports.getCurrentVersionInfo = getCurrentVersionInfo;
+exports.onPushyEvents = onPushyEvents;
+exports.checkUpdate = checkUpdate;
+exports.downloadUpdate = downloadUpdate;
+exports.switchVersion = switchVersion;
+exports.switchVersionLater = switchVersionLater;
+exports.markSuccess = markSuccess;
+exports.downloadAndInstallApk = downloadAndInstallApk;
+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)) || {} : {};
+    });
+}
+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,
+            },
+        });
+    }
+}
+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 (0, utils_1.enhancedFetch)((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) => (0, utils_1.enhancedFetch)((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;
+    });
+}
+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;
+    });
+}
+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 });
+    }
+}
+function switchVersionLater(hash) {
+    (0, utils_1.assertRelease)();
+    if (assertHash(hash)) {
+        (0, utils_1.logger)('switchVersionLater: ' + hash);
+        exports.PushyModule.setNeedUpdate({ hash });
+    }
+}
+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' });
+}
+function downloadAndInstallApk(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ url, onDownloadProgress, }) {
+        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();
+    });
+}

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: {}): {
+        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;
+};