rn-update-cli 1.0.0

package/lib/utils/zip-options.d.ts

@@ -0,0 +1,17 @@
+/**
+ * [INPUT]: 依赖文件系统、路径、文件前缀魔数与 ZIP 压缩等级约定
+ * [OUTPUT]: 对外提供 ZipEntryOptions、压缩阈值常量及条目压缩策略函数
+ * [POS]: CLI 归档压缩策略层，按 payload 类型选择安全且可复现的 ZIP 参数
+ */
+export type ZipEntryOptions = {
+    compress?: boolean;
+    compressionLevel?: number;
+};
+export declare const ZIP_ENTRY_SNIFF_BYTES = 64;
+export declare const MANIFEST_COMPRESSION_THRESHOLD_BYTES = 256;
+export declare const PAYLOAD_COMPRESSION_LEVEL = 6;
+export declare const MANIFEST_COMPRESSION_LEVEL = 9;
+export declare function zipOptionsForPatchEntry(): ZipEntryOptions;
+export declare function zipOptionsForManifestEntry(byteLength?: number): ZipEntryOptions;
+export declare function zipOptionsForPayloadEntry(fileName: string, prefix?: Buffer): ZipEntryOptions;
+export declare function zipOptionsForPayloadFile(filePath: string, entryName?: string): ZipEntryOptions;

package/lib/utils/zip-options.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * [INPUT]: 依赖文件系统、路径、文件前缀魔数与 ZIP 压缩等级约定
+ * [OUTPUT]: 对外提供 ZipEntryOptions、压缩阈值常量及条目压缩策略函数
+ * [POS]: CLI 归档压缩策略层，按 payload 类型选择安全且可复现的 ZIP 参数
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MANIFEST_COMPRESSION_LEVEL = exports.PAYLOAD_COMPRESSION_LEVEL = exports.MANIFEST_COMPRESSION_THRESHOLD_BYTES = exports.ZIP_ENTRY_SNIFF_BYTES = void 0;
+exports.zipOptionsForPatchEntry = zipOptionsForPatchEntry;
+exports.zipOptionsForManifestEntry = zipOptionsForManifestEntry;
+exports.zipOptionsForPayloadEntry = zipOptionsForPayloadEntry;
+exports.zipOptionsForPayloadFile = zipOptionsForPayloadFile;
+const fs = __importStar(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.ZIP_ENTRY_SNIFF_BYTES = 64;
+exports.MANIFEST_COMPRESSION_THRESHOLD_BYTES = 256;
+// Deflate level for the bundle/asset payload. Level 9 measured ~4x the CPU
+// of level 6 on Hermes bytecode for ~0.6% smaller output, so 6 is the sweet
+// spot; the manifest is tiny, so it can afford 9.
+exports.PAYLOAD_COMPRESSION_LEVEL = 6;
+exports.MANIFEST_COMPRESSION_LEVEL = 9;
+const alreadyCompressedExtensions = new Set([
+    '.7z',
+    '.aab',
+    '.apk',
+    '.br',
+    '.bz2',
+    '.gif',
+    '.gz',
+    '.heic',
+    '.jpeg',
+    '.jpg',
+    '.lzma',
+    '.mp3',
+    '.mp4',
+    '.ogg',
+    '.png',
+    '.webm',
+    '.webp',
+    '.woff',
+    '.woff2',
+    '.xz',
+    '.zip',
+    '.zst',
+]);
+const HERMES_MAGIC = Buffer.from([
+    0xc6, 0x1f, 0xbc, 0x03, 0xc1, 0x03, 0x19, 0x1f,
+]);
+const HERMES_DELTA_MAGIC = Buffer.from([
+    0x39, 0xe0, 0x43, 0xfc, 0x3e, 0xfc, 0xe6, 0xe0,
+]);
+function startsWith(bytes, signature) {
+    return (bytes.length >= signature.length &&
+        bytes.subarray(0, signature.length).equals(signature));
+}
+function hasHermesBytecodeMagic(bytes) {
+    return (startsWith(bytes, HERMES_MAGIC) || startsWith(bytes, HERMES_DELTA_MAGIC));
+}
+function hasAlreadyCompressedMagic(bytes) {
+    if (bytes.length < 2) {
+        return false;
+    }
+    if (startsWith(bytes, Buffer.from([0x89, 0x50, 0x4e, 0x47]))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from([0xff, 0xd8, 0xff]))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from('GIF87a', 'ascii')) ||
+        startsWith(bytes, Buffer.from('GIF89a', 'ascii'))) {
+        return true;
+    }
+    if (bytes.length >= 12 &&
+        bytes.subarray(0, 4).equals(Buffer.from('RIFF', 'ascii')) &&
+        bytes.subarray(8, 12).equals(Buffer.from('WEBP', 'ascii'))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from([0x50, 0x4b, 0x03, 0x04])) ||
+        startsWith(bytes, Buffer.from([0x50, 0x4b, 0x05, 0x06])) ||
+        startsWith(bytes, Buffer.from([0x50, 0x4b, 0x07, 0x08]))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from([0x1f, 0x8b]))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from('BZh', 'ascii'))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from([0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00]))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from([0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from([0x28, 0xb5, 0x2f, 0xfd]))) {
+        return true;
+    }
+    if (bytes.length >= 12 && bytes.subarray(4, 8).equals(Buffer.from('ftyp'))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from('OggS', 'ascii'))) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from('ID3', 'ascii'))) {
+        return true;
+    }
+    if (bytes[0] === 0xff && bytes.length >= 2 && (bytes[1] & 0xe0) === 0xe0) {
+        return true;
+    }
+    if (startsWith(bytes, Buffer.from('wOFF', 'ascii')) ||
+        startsWith(bytes, Buffer.from('wOF2', 'ascii'))) {
+        return true;
+    }
+    return false;
+}
+function readFilePrefix(filePath) {
+    const buffer = Buffer.alloc(exports.ZIP_ENTRY_SNIFF_BYTES);
+    const fd = fs.openSync(filePath, 'r');
+    try {
+        const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        return buffer.subarray(0, bytesRead);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function zipOptionsForPatchEntry() {
+    return { compress: false };
+}
+function zipOptionsForManifestEntry(byteLength = 0) {
+    if (byteLength >= exports.MANIFEST_COMPRESSION_THRESHOLD_BYTES) {
+        return { compressionLevel: exports.MANIFEST_COMPRESSION_LEVEL };
+    }
+    return { compress: false };
+}
+function zipOptionsForPayloadEntry(fileName, prefix) {
+    if (prefix && prefix.length > 0) {
+        if (hasHermesBytecodeMagic(prefix)) {
+            // Hermes bytecode is binary, but still benefits significantly from zip deflate.
+            return { compress: true, compressionLevel: exports.PAYLOAD_COMPRESSION_LEVEL };
+        }
+        if (hasAlreadyCompressedMagic(prefix)) {
+            return { compress: false };
+        }
+    }
+    const extension = path_1.default.extname(fileName).toLowerCase();
+    if (alreadyCompressedExtensions.has(extension)) {
+        return { compress: false };
+    }
+    return { compress: true, compressionLevel: exports.PAYLOAD_COMPRESSION_LEVEL };
+}
+function zipOptionsForPayloadFile(filePath, entryName = filePath) {
+    return zipOptionsForPayloadEntry(entryName, readFilePrefix(filePath));
+}

package/lib/utils/zip-range.d.ts

@@ -0,0 +1,148 @@
+/**
+ * [INPUT]: 依赖 HTTP Range/If-Range 响应、ZIP 中央目录、流与 ZIP 条目读取器
+ * [OUTPUT]: 对外提供远程 ZIP 定位、范围读取、缓存读取器和协议错误类型
+ * [POS]: CLI 远程制品按需读取底座，减少 Hermes base 与 bundle 获取的网络/磁盘开销
+ */
+import { Readable } from 'stream';
+import { type Entry, RandomAccessReader, type ZipFile } from 'yauzl';
+export declare const ZIP_STORED = 0;
+export declare const ZIP_DEFLATED = 8;
+export interface ZipEntryLocation {
+    fileName: string;
+    /** absolute offset of the compressed data, past the local file header */
+    dataOffset: number;
+    compressedSize: number;
+    uncompressedSize: number;
+    /** 0 = stored, 8 = deflate; anything else cannot be inflated here */
+    compressionMethod: number;
+}
+/** Data location of the first entry matching `matches` in a local zip. */
+export declare function locateZipEntry(zipPath: string, matches: (name: string) => boolean): Promise<ZipEntryLocation | null>;
+/**
+ * Content and data location of the first matching entry in one pass over the
+ * archive (publish needs both: the bundle to hash and cache, its location to
+ * report to the server).
+ */
+export declare function readZipEntryWithLocation(zipPath: string, matches: (name: string) => boolean): Promise<{
+    data: Buffer;
+    location: ZipEntryLocation;
+} | null>;
+/**
+ * The `bundleOffset` / `bundleCompressedSize` / `bundleCompression` fields for
+ * version/create and package/create, or nothing when the entry cannot be
+ * fetched by a single Range request (unknown, empty or exotic compression).
+ */
+export declare function bundleLocationFields(location: ZipEntryLocation | null | undefined): Record<string, number>;
+/** Deadlines for the Range requests; every field has a default. */
+export interface RangeOptions {
+    /** reads of at most CHUNK_BYTES (tail, headers, directory pages), default 20 s */
+    headerTimeoutMs?: number;
+    /** base deadline for larger reads (entry data, a prefetched directory), default 30 s */
+    dataTimeoutMs?: number;
+    /** added to `dataTimeoutMs` per MB requested, default 1 s */
+    dataTimeoutPerMbMs?: number;
+}
+/** The server answered a Range request with the whole body (HTTP 200). */
+export declare class RangeUnsupportedError extends Error {
+    readonly response: Response;
+    constructor(response: Response);
+}
+interface ContentRange {
+    start: number;
+    end: number;
+    total: number;
+}
+export declare function parseContentRange(header: string | null): ContentRange | null;
+/**
+ * The validator to send as `If-Range` on later requests for the same object,
+ * so a replaced archive answers 200 (handled like a server without Range)
+ * instead of mixing bytes of two versions. Weak ETags are not allowed there.
+ */
+export declare function rangeValidator(headers: Headers): string | undefined;
+/**
+ * Fetch one entry whose compressed bytes are already located (the ppk's own
+ * publish-time report) and decompress it. Returns the raw entry content.
+ */
+export declare function fetchZipEntryData(url: string, location: Pick<ZipEntryLocation, 'dataOffset' | 'compressedSize' | 'compressionMethod'>, options?: RangeOptions): Promise<{
+    data: Buffer;
+    fetchedBytes: number;
+    totalBytes: number;
+}>;
+export interface HttpRangeReaderOptions extends RangeOptions {
+    /** validator of the archive (see `rangeValidator`), sent as If-Range */
+    ifRange?: string;
+}
+interface Chunk {
+    start: number;
+    data: Buffer;
+}
+/**
+ * yauzl reader over HTTP Range. Header reads (EOCD, central directory, local
+ * file headers) are widened to CHUNK_BYTES and cached. Chunks are kept as
+ * fetched — only overlapping ones are merged, touching ones are read across —
+ * so an entry's bytes are held once, and a read reuses whatever prefix the
+ * cache holds (typically the bytes following the local file header) before
+ * requesting the rest. Every request after the first carries If-Range and
+ * must report the same archive size.
+ */
+export declare class HttpRangeReader extends RandomAccessReader {
+    private readonly url;
+    readonly totalSize: number;
+    private readonly options;
+    /** sorted by `start`, never overlapping */
+    private chunks;
+    /** span a header read inside it should widen to (see `hintEntry`) */
+    private hint;
+    requests: number;
+    fetchedBytes: number;
+    constructor(url: string, totalSize: number, tail?: Chunk, options?: HttpRangeReaderOptions);
+    /**
+     * The next entry to be read: yauzl first reads its local file header, and
+     * widening that read to the entry's data makes the data stream a cache hit
+     * — one request for header + bundle instead of two. The central directory
+     * may understate the local header's extra field, hence the slack.
+     */
+    hintEntry(entry: Entry): void;
+    /** Cache `data` at `start`, merging with any chunk it overlaps. */
+    addChunk(start: number, data: Buffer): void;
+    /** Fetch `[start, end)` into the cache in one request. */
+    prefetch(start: number, end: number): Promise<void>;
+    private requestOptions;
+    private fetchBuffer;
+    /**
+     * Contiguous cached pieces starting exactly at `start`, up to `end`: views
+     * into one chunk or into a run of touching chunks, possibly ending short.
+     */
+    private cachedPieces;
+    /** start of the cached run (touching chunks) holding byte `end - 1` */
+    private cachedSuffixStart;
+    /** start of the first cached chunk at or after `position` */
+    private nextCachedStart;
+    _readStreamForRange(start: number, end: number): Readable;
+    read(buffer: Buffer, offset: number, length: number, position: number, callback: (err: Error | null, bytesRead?: number) => void): void;
+}
+export declare function parseEndOfCentralDirectory(tail: Buffer): {
+    cdOffset: number;
+    cdSize: number;
+} | null;
+export type RemoteZip = {
+    kind: 'zip';
+    zipFile: ZipFile;
+    reader: HttpRangeReader;
+}
+/** the server ignored Range: the whole archive is streaming in `response` */
+ | {
+    kind: 'full';
+    response: Response;
+};
+/**
+ * Open a remote zip by fetching its tail (EOCD + central directory for
+ * typical archives) and letting yauzl read the rest on demand.
+ */
+export declare function openRemoteZip(url: string, options?: RangeOptions): Promise<RemoteZip>;
+/**
+ * Read the first matching entry of an opened remote zip, then close it. With
+ * `reader` given, the entry's header and data are fetched in one request.
+ */
+export declare function readRemoteZipEntry(zipFile: ZipFile, matches: (name: string) => boolean, reader?: HttpRangeReader): Promise<Buffer | null>;
+export {};