rn-update-cli 1.0.0

package/lib/utils/latest-version/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * [INPUT]: 依赖 npm/yarn 全局目录、registry HTTP、版本比较器、认证 token 与文件缓存
+ * [OUTPUT]: 对外提供 latestVersion 及版本类型，查询并比较 CLI 安装版本
+ * [POS]: CLI 自更新提示的版本解析底座，封装 registry 差异和本地全局安装布局
+ */
+import type { Agent } from 'http';
+interface RegistryVersions {
+    /**
+     * The latest version of the package found on the registry (if found).
+     */
+    latest?: string;
+    /**
+     * The next version of the package found on the registry (if found).
+     */
+    next?: string;
+    /**
+     * The latest version of the package found on the registry and satisfied by the wanted tag or version range.
+     */
+    wanted?: string;
+}
+interface InstalledVersions {
+    /**
+     * The current local installed version of the package (if installed).
+     */
+    local?: string;
+    /**
+     * The current npm global installed version of the package (if installed).
+     */
+    globalNpm?: string;
+    /**
+     * The current yarn global installed version of the package (if installed).
+     */
+    globalYarn?: string;
+}
+interface LatestVersionPackage extends InstalledVersions, RegistryVersions {
+    /**
+     * The name of the package.
+     */
+    name: string;
+    /**
+     * The tag or version range that was provided (if provided).
+     * @default "latest"
+     */
+    wantedTagOrRange?: string;
+    /**
+     * Whether the local or global installed versions (if any) could be upgraded or not, based on the wanted version.
+     */
+    updatesAvailable: {
+        local: string | false;
+        globalNpm: string | false;
+        globalYarn: string | false;
+    } | false;
+    /**
+     * Any error that might have occurred during the process.
+     */
+    error?: Error;
+}
+interface RequestOptions {
+    readonly ca?: string | Buffer | Array<string | Buffer>;
+    readonly rejectUnauthorized?: boolean;
+    readonly agent?: Agent | boolean;
+    readonly timeout?: number;
+}
+interface LatestVersionOptions {
+    /**
+     * Awaiting the api to return might take time, depending on the network, and might impact your package loading performance.
+     * You can use the cache mechanism to improve load performance and reduce unnecessary network requests.
+     * If `useCache` is not supplied, the api will always check for updates and wait for every requests to return before returning itself.
+     * If `useCache` is used (for each provided package):
+     * 1) a fresh cache (younger than `cacheMaxAge`, from the same registry) answers without any network request
+     * 2) otherwise the registry is queried and the cache refreshed; when that query fails, a stale cache (if any) is used instead.
+     * Combine with `unref` so a slow refresh never keeps the process alive.
+     * @default false
+     */
+    readonly useCache?: boolean;
+    /**
+     * How long the cache for the provided packages should be used before being refreshed (in milliseconds).
+     * If `useCache` is not supplied, this option has no effect.
+     * If `0` is used, the cache is always refreshed (a stale cache still serves as a fallback when the refresh fails).
+     * @default ONE_DAY
+     */
+    readonly cacheMaxAge?: number;
+    /**
+     * Do not let the registry request keep the process alive: its socket is `unref`'d, so the process may exit before the
+     * request completes (the returned promise then simply never settles). Use for opportunistic background checks.
+     * @default false
+     */
+    readonly unref?: boolean;
+    /**
+     * A JavaScript package registry url that implements the CommonJS Package Registry specification.
+     * @default "Looks at any registry urls in the .npmrc file or fallback to the default npm registry instead"
+     * @example <caption>.npmrc</caption>
+     * registry = 'https://custom-registry.com/'
+     * @pkgscope:registry = 'https://custom-registry.com/'
+     */
+    readonly registryUrl?: string;
+    /**
+     * Set of options to be passed down to Node.js http/https request.
+     * @example <caption>Behind a proxy with self-signed certificate</caption>
+     * { ca: [ fs.readFileSync('proxy-cert.pem') ] }
+     * @example <caption>Bypassing certificate validation</caption>
+     * { rejectUnauthorized: false }
+     */
+    readonly requestOptions?: RequestOptions;
+}
+interface LatestVersion {
+    /**
+     * Get latest versions of packages from of a package json like object.
+     * @param {PackageJson} item - A package json like object (with dependencies, devDependencies and peerDependencies attributes).
+     * @example { dependencies: { 'npm': 'latest' }, devDependencies: { 'npm': '1.3.2' }, peerDependencies: { '@scope/name': '^5.0.2' } }
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the `npm registry url` instead.
+     * @returns {Promise<LatestVersionPackage[]>}
+     */
+    (item: PackageJson, options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
+    /**
+     * Get latest version of a single package.
+     * @param {Package} item - A single package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
+     * @example 'npm', 'npm@1.3.2', '@scope/name@^5.0.2'
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
+     * @returns {Promise<LatestVersionPackage>}
+     */
+    (item: Package, options?: LatestVersionOptions): Promise<LatestVersionPackage>;
+    /**
+     * Get latest versions of a collection of packages.
+     * @param {Package[]} items - A collection of package object (represented by a string that should match the following format: `${'@' | ''}${string}@${string}`)
+     * @example ['npm', 'npm@1.3.2', '@scope/name@^5.0.2']
+     * @param {LatestVersionOptions} [options] - An object optionally specifying the use of the cache, the max age of the cache, the registry url and the http or https options.
+     * If `useCache` is not supplied, the default of `false` is used.
+     * If `cacheMaxAge` is not supplied, the default of `one day` is used.
+     * If `registryUrl` is not supplied, the default from `.npmrc` is used or a fallback to the npm registry url instead.
+     * @returns {Promise<LatestVersionPackage[]>}
+     */
+    (items: Package[], options?: LatestVersionOptions): Promise<LatestVersionPackage[]>;
+}
+type PackageRange = `${'@' | ''}${string}@${string}`;
+type Package = PackageRange | string;
+type PackageJsonDependencies = Record<string, string>;
+type PackageJson = Record<string, any> & ({
+    dependencies: PackageJsonDependencies;
+} | {
+    devDependencies: PackageJsonDependencies;
+} | {
+    peerDependencies: PackageJsonDependencies;
+});
+export declare const ONE_DAY: number;
+declare const latestVersion: LatestVersion;
+export type { LatestVersion, LatestVersionOptions, LatestVersionPackage, Package, PackageJson, PackageJsonDependencies, PackageRange, RegistryVersions, RequestOptions, };
+export default latestVersion;

package/lib/utils/latest-version/index.js

@@ -0,0 +1,331 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 npm/yarn 全局目录、registry HTTP、版本比较器、认证 token 与文件缓存
+ * [OUTPUT]: 对外提供 latestVersion 及版本类型，查询并比较 CLI 安装版本
+ * [POS]: CLI 自更新提示的版本解析底座，封装 registry 差异和本地全局安装布局
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ONE_DAY = void 0;
+const compare_versions_1 = require("compare-versions");
+const fs_1 = require("fs");
+const global_dirs_1 = require("global-dirs");
+const os_1 = require("os");
+const path_1 = require("path");
+const registry_auth_token_1 = __importDefault(require("registry-auth-token"));
+const registry_url_1 = __importDefault(require("registry-auth-token/registry-url"));
+const url_1 = require("url");
+const runtime_1 = require("../runtime");
+exports.ONE_DAY = 1000 * 60 * 60 * 24; // eslint-disable-line @typescript-eslint/naming-convention
+const isPackageJson = (obj) => {
+    return (obj.dependencies !== undefined ||
+        obj.devDependencies !== undefined ||
+        obj.peerDependencies !== undefined);
+};
+const resolveRegistryUrl = (pkgName, options) => {
+    const i = pkgName.indexOf('/');
+    const pkgScope = i !== -1 ? pkgName.slice(0, i) : '';
+    return options?.registryUrl ?? (0, registry_url_1.default)(pkgScope);
+};
+const downloadMetadata = (pkgName, options) => {
+    return new Promise((resolve, reject) => {
+        const registryUrl = resolveRegistryUrl(pkgName, options);
+        const pkgUrl = new url_1.URL(encodeURIComponent(pkgName).replace(/^%40/, '@'), registryUrl);
+        let requestOptions = {
+            headers: {
+                accept: 'application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*',
+            },
+            host: pkgUrl.hostname,
+            path: pkgUrl.pathname,
+            port: pkgUrl.port,
+        };
+        const authInfo = (0, registry_auth_token_1.default)(pkgUrl.toString(), { recursive: true });
+        if (authInfo && requestOptions.headers) {
+            requestOptions.headers.authorization =
+                `${authInfo.type} ${authInfo.token}`;
+        }
+        if (options?.requestOptions) {
+            requestOptions = { ...requestOptions, ...options.requestOptions };
+        }
+        if (requestOptions.agent === undefined) {
+            // HTTP(S)_PROXY / NO_PROXY, like every other request of the CLI
+            const agent = (0, runtime_1.proxyAgentFor)(pkgUrl.toString());
+            if (agent) {
+                requestOptions = { ...requestOptions, agent };
+            }
+        }
+        const { get } = require(pkgUrl.protocol === 'https:' ? 'https' : 'http');
+        const request = get(requestOptions, (res) => {
+            if (res.statusCode === 200) {
+                let rawData = '';
+                res.setEncoding('utf8');
+                res.on('data', (chunk) => (rawData += chunk));
+                res.once('error', (err) => {
+                    res.removeAllListeners();
+                    reject(`Request error (${err.message}): ${pkgUrl}`);
+                });
+                res.once('end', () => {
+                    res.removeAllListeners();
+                    try {
+                        const pkgMetadata = JSON.parse(rawData);
+                        resolve({
+                            name: pkgName,
+                            lastUpdateDate: Date.now(),
+                            versions: Object.keys(pkgMetadata.versions),
+                            distTags: pkgMetadata['dist-tags'],
+                            registryUrl,
+                        });
+                        return;
+                    }
+                    catch (err) {
+                        reject(err);
+                        return;
+                    }
+                });
+            }
+            else {
+                res.removeAllListeners();
+                res.resume(); // consume response data to free up memory
+                reject(`Request error (${res.statusCode}): ${pkgUrl}`);
+                return;
+            }
+        });
+        const abort = (error) => {
+            request.destroy();
+            reject(error);
+        };
+        request.once('timeout', () => {
+            abort(`Request timed out: ${pkgUrl}`);
+        });
+        request.once('error', (err) => {
+            abort(err);
+        });
+        request.on('close', () => {
+            request.removeAllListeners();
+        });
+        if (options?.unref) {
+            // A background check must never delay the process exit: drop the
+            // socket's ref (also for a pooled keep-alive socket, which the agent
+            // ref's again right before handing it out).
+            request.once('socket', (socket) => {
+                socket.unref?.();
+            });
+        }
+    });
+};
+const getCacheDir = (name = '@badisi/latest-version') => {
+    const homeDir = (0, os_1.homedir)();
+    if (process.env.XDG_CACHE_HOME) {
+        // an explicit override wins on every platform (also lets tests isolate)
+        return (0, path_1.join)(process.env.XDG_CACHE_HOME, name);
+    }
+    switch (process.platform) {
+        case 'darwin':
+            return (0, path_1.join)(homeDir, 'Library', 'Caches', name);
+        case 'win32':
+            return (0, path_1.join)(process.env.LOCALAPPDATA ?? (0, path_1.join)(homeDir, 'AppData', 'Local'), name, 'Cache');
+        default:
+            return (0, path_1.join)(process.env.XDG_CACHE_HOME ?? (0, path_1.join)(homeDir, '.cache'), name);
+    }
+};
+const saveMetadataToCache = (pkg) => {
+    try {
+        const filePath = (0, path_1.join)(getCacheDir(), `${pkg.name}.json`);
+        if (!(0, fs_1.existsSync)((0, path_1.dirname)(filePath))) {
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(filePath), { recursive: true });
+        }
+        (0, fs_1.writeFileSync)(filePath, JSON.stringify(pkg));
+    }
+    catch {
+        // a read-only or missing cache dir must not turn into an error
+    }
+};
+/**
+ * The cached metadata of a package (from the same registry), and whether it is
+ * still younger than `cacheMaxAge`. A stale entry is returned as well so it can
+ * serve as a fallback when the registry is unreachable.
+ */
+const getMetadataFromCache = (pkgName, options) => {
+    const maxAge = options?.cacheMaxAge ?? exports.ONE_DAY;
+    try {
+        const pkgCacheFilePath = (0, path_1.join)(getCacheDir(), `${pkgName}.json`);
+        if (!(0, fs_1.existsSync)(pkgCacheFilePath)) {
+            return undefined;
+        }
+        const metadata = JSON.parse((0, fs_1.readFileSync)(pkgCacheFilePath).toString());
+        if (!metadata ||
+            typeof metadata.lastUpdateDate !== 'number' ||
+            !metadata.distTags ||
+            metadata.registryUrl !== resolveRegistryUrl(pkgName, options)) {
+            return undefined;
+        }
+        const age = Date.now() - metadata.lastUpdateDate;
+        return { metadata, fresh: maxAge !== 0 && age >= 0 && age < maxAge };
+    }
+    catch {
+        return undefined; // unreadable / corrupt cache is the same as no cache
+    }
+};
+const getRegistryVersions = async (pkgName, tagOrRange, options) => {
+    let pkgMetadata;
+    if (pkgName.length && options?.useCache) {
+        const cached = getMetadataFromCache(pkgName, options);
+        if (cached?.fresh) {
+            pkgMetadata = cached.metadata;
+        }
+        else {
+            try {
+                pkgMetadata = await downloadMetadata(pkgName, options);
+                saveMetadataToCache(pkgMetadata);
+            }
+            catch (err) {
+                if (!cached) {
+                    throw err;
+                }
+                pkgMetadata = cached.metadata; // stale beats nothing
+            }
+        }
+    }
+    else if (pkgName.length) {
+        pkgMetadata = await downloadMetadata(pkgName, options);
+    }
+    const versions = {
+        latest: pkgMetadata?.distTags.latest,
+        next: pkgMetadata?.distTags.next,
+    };
+    if (tagOrRange && pkgMetadata?.distTags[tagOrRange]) {
+        versions.wanted = pkgMetadata.distTags[tagOrRange];
+    }
+    else if (tagOrRange && pkgMetadata?.versions.length) {
+        versions.wanted = maxSatisfying(pkgMetadata.versions, tagOrRange);
+    }
+    return versions;
+};
+/** the highest of `versions` within `range` (npm range syntax), if any */
+const maxSatisfying = (versions, range) => {
+    const matching = versions.filter((version) => {
+        try {
+            return (0, compare_versions_1.satisfies)(version, range);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!matching.length)
+        return undefined;
+    return matching.sort(compare_versions_1.compareVersions)[matching.length - 1];
+};
+/** `a > b` for two versions; invalid input counts as "not newer" */
+const gt = (a, b) => {
+    try {
+        return (0, compare_versions_1.compare)(a, b, '>');
+    }
+    catch {
+        return false;
+    }
+};
+const getInstalledVersion = (pkgName, location = 'local') => {
+    try {
+        if (location === 'globalNpm') {
+            return require((0, path_1.join)(global_dirs_1.npm.packages, pkgName, 'package.json'))
+                ?.version;
+        }
+        if (location === 'globalYarn') {
+            // Make sure package is globally installed by Yarn
+            const yarnGlobalPkg = require((0, path_1.resolve)(global_dirs_1.yarn.packages, '..', 'package.json'));
+            if (!yarnGlobalPkg?.dependencies?.[pkgName]) {
+                return undefined;
+            }
+            return require((0, path_1.join)(global_dirs_1.yarn.packages, pkgName, 'package.json'))
+                ?.version;
+        }
+        /**
+         * Compute the local paths manually as require.resolve() and require.resolve.paths()
+         * cannot be trusted anymore.
+         * @see https://github.com/nodejs/node/issues/33460
+         * @see https://github.com/nodejs/loaders/issues/26
+         */
+        const { root } = (0, path_1.parse)(process.cwd());
+        let path = process.cwd();
+        const localPaths = [(0, path_1.join)(path, 'node_modules')];
+        while (path !== root) {
+            path = (0, path_1.dirname)(path);
+            localPaths.push((0, path_1.join)(path, 'node_modules'));
+        }
+        for (const localPath of localPaths) {
+            const pkgPath = (0, path_1.join)(localPath, pkgName, 'package.json');
+            if ((0, fs_1.existsSync)(pkgPath)) {
+                return require(pkgPath)?.version;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const getInfo = async (pkg, options) => {
+    const i = pkg.lastIndexOf('@');
+    let pkgInfo = {
+        name: i > 1 ? pkg.slice(0, i) : pkg,
+        wantedTagOrRange: i > 1 ? pkg.slice(i + 1) : 'latest',
+        updatesAvailable: false,
+    };
+    try {
+        pkgInfo = {
+            ...pkgInfo,
+            local: getInstalledVersion(pkgInfo.name, 'local'),
+            globalNpm: getInstalledVersion(pkgInfo.name, 'globalNpm'),
+            globalYarn: getInstalledVersion(pkgInfo.name, 'globalYarn'),
+            ...(await getRegistryVersions(pkgInfo.name, pkgInfo.wantedTagOrRange, options)),
+        };
+        const local = pkgInfo.local && pkgInfo.wanted
+            ? gt(pkgInfo.wanted, pkgInfo.local)
+                ? pkgInfo.wanted
+                : false
+            : false;
+        const globalNpm = pkgInfo.globalNpm && pkgInfo.wanted
+            ? gt(pkgInfo.wanted, pkgInfo.globalNpm)
+                ? pkgInfo.wanted
+                : false
+            : false;
+        const globalYarn = pkgInfo.globalYarn && pkgInfo.wanted
+            ? gt(pkgInfo.wanted, pkgInfo.globalYarn)
+                ? pkgInfo.wanted
+                : false
+            : false;
+        pkgInfo.updatesAvailable =
+            local || globalNpm || globalYarn
+                ? { local, globalNpm, globalYarn }
+                : false;
+    }
+    catch (err) {
+        pkgInfo.error = err?.message ?? err;
+    }
+    return pkgInfo;
+};
+const latestVersion = async (arg, options) => {
+    const pkgs = [];
+    if (typeof arg === 'string') {
+        pkgs.push(arg);
+    }
+    else if (Array.isArray(arg)) {
+        pkgs.push(...arg);
+    }
+    else if (isPackageJson(arg)) {
+        const addDeps = (deps) => {
+            if (deps) {
+                pkgs.push(...Object.keys(deps).map((key) => `${key}@${deps[key]}`));
+            }
+        };
+        addDeps(arg.dependencies);
+        addDeps(arg.devDependencies);
+        addDeps(arg.peerDependencies);
+    }
+    const jobs = await Promise.allSettled(pkgs.map((pkg) => getInfo(pkg, options)));
+    const results = jobs.map((jobResult) => jobResult.value);
+    return typeof arg === 'string' ? results[0] : results;
+};
+exports.default = latestVersion;

package/lib/utils/options.d.ts

@@ -0,0 +1,10 @@
+/**
+ * [INPUT]: 依赖 CLI 参数对象与字符串/布尔/列表的约定
+ * [OUTPUT]: 对外提供命令选项读取、校验和对象状态转换函数
+ * [POS]: CLI 参数基础设施，统一命令模块的输入边界，不了解具体命令业务
+ */
+export declare function getBooleanOption(options: Record<string, unknown>, key: string, fallback?: boolean): boolean;
+export declare function getStringOption(options: Record<string, unknown>, key: string, fallback?: string): string;
+export declare function getOptionalStringOption(options: Record<string, unknown>, key: string): string | undefined;
+export declare function getStringListOption(options: Record<string, unknown>, key: string): string[] | undefined;
+export declare function toObjectState<T extends Record<string, unknown>>(value: unknown, fallback: T): T;

package/lib/utils/options.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * [INPUT]: 依赖 CLI 参数对象与字符串/布尔/列表的约定
+ * [OUTPUT]: 对外提供命令选项读取、校验和对象状态转换函数
+ * [POS]: CLI 参数基础设施，统一命令模块的输入边界，不了解具体命令业务
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBooleanOption = getBooleanOption;
+exports.getStringOption = getStringOption;
+exports.getOptionalStringOption = getOptionalStringOption;
+exports.getStringListOption = getStringListOption;
+exports.toObjectState = toObjectState;
+function getBooleanOption(options, key, fallback = false) {
+    const value = options[key];
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return value.toLowerCase() === 'true';
+    }
+    if (typeof value === 'number') {
+        return value !== 0;
+    }
+    return fallback;
+}
+function getStringOption(options, key, fallback = '') {
+    const value = options[key];
+    if (typeof value === 'string') {
+        return value;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return fallback;
+}
+function getOptionalStringOption(options, key) {
+    const value = options[key];
+    if (typeof value === 'string') {
+        return value || undefined;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    return undefined;
+}
+function getStringListOption(options, key) {
+    const value = options[key];
+    const rawValues = Array.isArray(value) ? value : [value];
+    const result = rawValues.flatMap((item) => {
+        if (typeof item === 'string') {
+            return item
+                .split(',')
+                .map((value) => value.trim())
+                .filter(Boolean);
+        }
+        if (typeof item === 'number' || typeof item === 'boolean') {
+            return [String(item)];
+        }
+        return [];
+    });
+    return result.length > 0 ? result : undefined;
+}
+function toObjectState(value, fallback) {
+    if (value && typeof value === 'object') {
+        return value;
+    }
+    return fallback;
+}

package/lib/utils/plugin-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * [INPUT]: 依赖文件系统与 CLI 插件配置文件格式
+ * [OUTPUT]: 对外提供 plugins，声明可参与 bundle 的插件及其参数映射
+ * [POS]: CLI 插件注册配置，只描述已支持的集成，不执行插件逻辑
+ */
+interface PluginConfig {
+    name: string;
+    bundleParams?: {
+        [key: string]: any;
+    };
+    detect: () => Promise<boolean>;
+}
+export declare const plugins: PluginConfig[];
+export {};

package/lib/utils/plugin-config.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * [INPUT]: 依赖文件系统与 CLI 插件配置文件格式
+ * [OUTPUT]: 对外提供 plugins，声明可参与 bundle 的插件及其参数映射
+ * [POS]: CLI 插件注册配置，只描述已支持的集成，不执行插件逻辑
+ */
+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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugins = void 0;
+const fs = __importStar(require("fs-extra"));
+exports.plugins = [
+    {
+        name: 'sentry',
+        bundleParams: {
+            sentry: true,
+            sourcemap: true,
+        },
+        detect: async () => {
+            try {
+                await fs.access('ios/sentry.properties');
+                return true;
+            }
+            catch {
+                try {
+                    await fs.access('android/sentry.properties');
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+        },
+    },
+];