@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.41

package/ios/HotUpdater/Internal/TarBrDecompressionStrategy.swift

@@ -1,39 +0,0 @@
-import Foundation
-
-/**
- * Strategy for handling TAR+Brotli compressed files
- */
-class TarBrDecompressionStrategy: DecompressionStrategy {
-    private static let MIN_FILE_SIZE: UInt64 = 10
-
-    func isValid(file: String) -> Bool {
-        guard FileManager.default.fileExists(atPath: file) else {
-            NSLog("[TarBrStrategy] Invalid file: doesn't exist")
-            return false
-        }
-
-        do {
-            let attributes = try FileManager.default.attributesOfItem(atPath: file)
-            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_FILE_SIZE else {
-                NSLog("[TarBrStrategy] Invalid file: too small")
-                return false
-            }
-        } catch {
-            NSLog("[TarBrStrategy] Invalid file: cannot read attributes - \(error.localizedDescription)")
-            return false
-        }
-
-        return StreamingTarArchiveExtractor.containsTarEntries(file: file, algorithm: .brotli)
-    }
-
-    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        NSLog("[TarBrStrategy] Starting extraction of \(file) to \(destination)")
-        try StreamingTarArchiveExtractor.extractCompressedTar(
-            file: file,
-            to: destination,
-            algorithm: .brotli,
-            progressHandler: progressHandler
-        )
-        NSLog("[TarBrStrategy] Successfully extracted all entries")
-    }
-}

package/ios/HotUpdater/Internal/TarGzDecompressionStrategy.swift

@@ -1,59 +0,0 @@
-import Foundation
-
-/**
- * Strategy for handling TAR+GZIP compressed files
- */
-class TarGzDecompressionStrategy: DecompressionStrategy {
-    private static let MIN_FILE_SIZE: UInt64 = 10
-
-    func isValid(file: String) -> Bool {
-        guard FileManager.default.fileExists(atPath: file) else {
-            NSLog("[TarGzStrategy] Invalid file: doesn't exist")
-            return false
-        }
-
-        do {
-            let attributes = try FileManager.default.attributesOfItem(atPath: file)
-            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_FILE_SIZE else {
-                NSLog("[TarGzStrategy] Invalid file: too small")
-                return false
-            }
-        } catch {
-            NSLog("[TarGzStrategy] Invalid file: cannot read attributes - \(error.localizedDescription)")
-            return false
-        }
-
-        // Check GZIP magic bytes (0x1F 0x8B)
-        guard let fileHandle = FileHandle(forReadingAtPath: file) else {
-            NSLog("[TarGzStrategy] Invalid file: cannot open file")
-            return false
-        }
-
-        defer {
-            fileHandle.closeFile()
-        }
-
-        guard let header = try? ArchiveExtractionUtilities.readUpToCount(from: fileHandle, count: 2),
-              header.count == 2 else {
-            NSLog("[TarGzStrategy] Invalid file: cannot read header")
-            return false
-        }
-
-        let isGzip = header[0] == 0x1F && header[1] == 0x8B
-        if !isGzip {
-            NSLog("[TarGzStrategy] Invalid file: wrong magic bytes (expected 0x1F 0x8B, got 0x\(String(format: "%02X", header[0])) 0x\(String(format: "%02X", header[1])))")
-        }
-        return isGzip
-    }
-
-    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        NSLog("[TarGzStrategy] Starting extraction of \(file) to \(destination)")
-        try StreamingTarArchiveExtractor.extractCompressedTar(
-            file: file,
-            to: destination,
-            algorithm: .gzip,
-            progressHandler: progressHandler
-        )
-        NSLog("[TarGzStrategy] Successfully extracted all entries")
-    }
-}

package/ios/HotUpdater/Internal/ZipArchiveExtractor.swift

@@ -1,482 +0,0 @@
-import Foundation
-import zlib
-
-enum ZipArchiveExtractor {
-    private static let localFileHeaderSignature: UInt32 = 0x04034B50
-    private static let centralDirectoryHeaderSignature: UInt32 = 0x02014B50
-    private static let endOfCentralDirectorySignature: UInt32 = 0x06054B50
-    private static let storedMethod: UInt16 = 0
-    private static let deflatedMethod: UInt16 = 8
-    private static let encryptedFlag: UInt16 = 1 << 0
-    private static let maxCommentLength = 0xFFFF
-    private static let unixHostIdentifier: UInt8 = 3
-    private static let fileTypeMask: UInt16 = 0o170000
-    private static let symbolicLinkMode: UInt16 = 0o120000
-    private static let directoryMode: UInt16 = 0o040000
-
-    private struct CentralDirectoryEntry {
-        let path: String
-        let compressionMethod: UInt16
-        let flags: UInt16
-        let compressedSize: UInt64
-        let uncompressedSize: UInt64
-        let checksum: UInt32
-        let localHeaderOffset: UInt64
-        let isDirectory: Bool
-        let isSymbolicLink: Bool
-    }
-
-    private struct EndOfCentralDirectoryRecord {
-        let totalEntries: UInt16
-        let centralDirectoryOffset: UInt64
-    }
-
-    static func extract(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        let fileURL = URL(fileURLWithPath: file)
-        let fileSize = try archiveFileSize(at: file)
-        let handle = try FileHandle(forReadingFrom: fileURL)
-
-        defer {
-            try? handle.close()
-        }
-
-        let entries = try readCentralDirectoryEntries(from: handle, fileSize: fileSize)
-
-        let destinationURL = URL(fileURLWithPath: destination)
-        try ArchiveExtractionUtilities.ensureDirectory(at: destinationURL)
-
-        let totalCompressedBytes = entries.reduce(UInt64(0)) { $0 + max($1.compressedSize, 1) }
-        var processedCompressedBytes: UInt64 = 0
-
-        for entry in entries {
-            try extractEntry(entry, from: handle, to: destinationURL.standardizedFileURL.path)
-            processedCompressedBytes += max(entry.compressedSize, 1)
-
-            guard totalCompressedBytes > 0 else {
-                continue
-            }
-
-            let progress = min(Double(processedCompressedBytes) / Double(totalCompressedBytes), 1.0)
-            progressHandler(progress)
-        }
-
-        progressHandler(1.0)
-    }
-
-    private static func readCentralDirectoryEntries(
-        from handle: FileHandle,
-        fileSize: UInt64
-    ) throws -> [CentralDirectoryEntry] {
-        let endRecord = try locateEndOfCentralDirectory(in: handle, fileSize: fileSize)
-
-        try ArchiveExtractionUtilities.seek(handle, to: endRecord.centralDirectoryOffset)
-
-        var entries: [CentralDirectoryEntry] = []
-        entries.reserveCapacity(Int(endRecord.totalEntries))
-
-        for _ in 0..<endRecord.totalEntries {
-            let header = try ArchiveExtractionUtilities.readExactly(from: handle, count: 46)
-
-            guard header.archiveUInt32LE(at: 0) == centralDirectoryHeaderSignature else {
-                throw NSError(
-                    domain: "ZipArchiveExtractor",
-                    code: 1,
-                    userInfo: [NSLocalizedDescriptionKey: "Invalid ZIP central directory header"]
-                )
-            }
-
-            let flags = header.archiveUInt16LE(at: 8)
-            let compressionMethod = header.archiveUInt16LE(at: 10)
-            let compressedSize = header.archiveUInt32LE(at: 20)
-            let uncompressedSize = header.archiveUInt32LE(at: 24)
-            let fileNameLength = Int(header.archiveUInt16LE(at: 28))
-            let extraFieldLength = Int(header.archiveUInt16LE(at: 30))
-            let commentLength = Int(header.archiveUInt16LE(at: 32))
-            let checksum = header.archiveUInt32LE(at: 16)
-            let localHeaderOffset = header.archiveUInt32LE(at: 42)
-            let versionMadeBy = header.archiveUInt16LE(at: 4)
-            let externalAttributes = header.archiveUInt32LE(at: 38)
-
-            guard compressedSize != UInt32.max,
-                  uncompressedSize != UInt32.max,
-                  localHeaderOffset != UInt32.max else {
-                throw NSError(
-                    domain: "ZipArchiveExtractor",
-                    code: 2,
-                    userInfo: [NSLocalizedDescriptionKey: "ZIP64 archives are not supported"]
-                )
-            }
-
-            let fileNameData = try ArchiveExtractionUtilities.readExactly(from: handle, count: fileNameLength)
-            let extraFieldData = try ArchiveExtractionUtilities.readExactly(from: handle, count: extraFieldLength)
-            _ = extraFieldData
-            if commentLength > 0 {
-                try ArchiveExtractionUtilities.skipBytes(UInt64(commentLength), in: handle)
-            }
-
-            let path = decodePath(from: fileNameData)
-            let mode = unixFileMode(versionMadeBy: versionMadeBy, externalAttributes: externalAttributes)
-            let isDirectory = path.hasSuffix("/") || mode == directoryMode
-            let isSymbolicLink = mode == symbolicLinkMode
-
-            entries.append(
-                CentralDirectoryEntry(
-                    path: path,
-                    compressionMethod: compressionMethod,
-                    flags: flags,
-                    compressedSize: UInt64(compressedSize),
-                    uncompressedSize: UInt64(uncompressedSize),
-                    checksum: checksum,
-                    localHeaderOffset: UInt64(localHeaderOffset),
-                    isDirectory: isDirectory,
-                    isSymbolicLink: isSymbolicLink
-                )
-            )
-        }
-
-        return entries
-    }
-
-    private static func locateEndOfCentralDirectory(
-        in handle: FileHandle,
-        fileSize: UInt64
-    ) throws -> EndOfCentralDirectoryRecord {
-        let minimumRecordLength = 22
-        let searchLength = Int(min(fileSize, UInt64(maxCommentLength + minimumRecordLength)))
-        let searchOffset = fileSize - UInt64(searchLength)
-
-        try ArchiveExtractionUtilities.seek(handle, to: searchOffset)
-        let tailData = try ArchiveExtractionUtilities.readExactly(from: handle, count: searchLength)
-
-        let signatureBytes: [UInt8] = [0x50, 0x4B, 0x05, 0x06]
-
-        guard let recordIndex = findLastSignature(signatureBytes, in: tailData) else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 3,
-                userInfo: [NSLocalizedDescriptionKey: "ZIP end of central directory record not found"]
-            )
-        }
-
-        let minimumEndIndex = recordIndex + minimumRecordLength
-        guard minimumEndIndex <= tailData.count else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 4,
-                userInfo: [NSLocalizedDescriptionKey: "ZIP end of central directory record is truncated"]
-            )
-        }
-
-        let commentLength = Int(tailData.archiveUInt16LE(at: recordIndex + 20))
-        guard minimumEndIndex + commentLength == tailData.count else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 5,
-                userInfo: [NSLocalizedDescriptionKey: "ZIP central directory comment is malformed"]
-            )
-        }
-
-        return EndOfCentralDirectoryRecord(
-            totalEntries: tailData.archiveUInt16LE(at: recordIndex + 10),
-            centralDirectoryOffset: UInt64(tailData.archiveUInt32LE(at: recordIndex + 16))
-        )
-    }
-
-    private static func extractEntry(
-        _ entry: CentralDirectoryEntry,
-        from handle: FileHandle,
-        to destinationRoot: String
-    ) throws {
-        guard entry.flags & encryptedFlag == 0 else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 6,
-                userInfo: [NSLocalizedDescriptionKey: "Encrypted ZIP entries are not supported"]
-            )
-        }
-
-        guard let relativePath = ArchiveExtractionUtilities.normalizedRelativePath(from: entry.path) else {
-            return
-        }
-
-        let targetURL = try ArchiveExtractionUtilities.extractionURL(
-            for: relativePath,
-            destinationRoot: destinationRoot
-        )
-
-        if entry.isDirectory {
-            try ArchiveExtractionUtilities.ensureDirectory(at: targetURL)
-            return
-        }
-
-        if entry.isSymbolicLink {
-            NSLog("[ZipArchiveExtractor] Skipping symbolic link entry: \(entry.path)")
-            return
-        }
-
-        try ArchiveExtractionUtilities.seek(handle, to: entry.localHeaderOffset)
-        let localHeader = try ArchiveExtractionUtilities.readExactly(from: handle, count: 30)
-
-        guard localHeader.archiveUInt32LE(at: 0) == localFileHeaderSignature else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 7,
-                userInfo: [NSLocalizedDescriptionKey: "Invalid ZIP local file header for \(entry.path)"]
-            )
-        }
-
-        let fileNameLength = UInt64(localHeader.archiveUInt16LE(at: 26))
-        let extraFieldLength = UInt64(localHeader.archiveUInt16LE(at: 28))
-        let dataOffset = entry.localHeaderOffset + 30 + fileNameLength + extraFieldLength
-
-        try ArchiveExtractionUtilities.seek(handle, to: dataOffset)
-        let outputHandle = try ArchiveExtractionUtilities.createOutputFile(at: targetURL)
-
-        defer {
-            try? outputHandle.close()
-        }
-
-        let extractionResult: (writtenSize: UInt64, checksum: UInt32)
-
-        switch entry.compressionMethod {
-        case storedMethod:
-            extractionResult = try extractStoredEntry(
-                from: handle,
-                compressedSize: entry.compressedSize,
-                to: outputHandle
-            )
-        case deflatedMethod:
-            extractionResult = try extractDeflatedEntry(
-                from: handle,
-                compressedSize: entry.compressedSize,
-                path: entry.path,
-                to: outputHandle
-            )
-        default:
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 8,
-                userInfo: [NSLocalizedDescriptionKey: "Unsupported ZIP compression method \(entry.compressionMethod) for \(entry.path)"]
-            )
-        }
-
-        guard extractionResult.writtenSize == entry.uncompressedSize else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 9,
-                userInfo: [NSLocalizedDescriptionKey: "ZIP entry size mismatch for \(entry.path)"]
-            )
-        }
-
-        guard extractionResult.checksum == entry.checksum else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 10,
-                userInfo: [NSLocalizedDescriptionKey: "ZIP entry checksum mismatch for \(entry.path)"]
-            )
-        }
-    }
-
-    private static func extractStoredEntry(
-        from handle: FileHandle,
-        compressedSize: UInt64,
-        to outputHandle: FileHandle
-    ) throws -> (writtenSize: UInt64, checksum: UInt32) {
-        var remainingBytes = compressedSize
-        var totalWritten: UInt64 = 0
-        var checksum: uLong = crc32(0, nil, 0)
-
-        while remainingBytes > 0 {
-            let chunkSize = Int(min(remainingBytes, UInt64(ArchiveExtractionUtilities.bufferSize)))
-            let chunk = try ArchiveExtractionUtilities.readExactly(from: handle, count: chunkSize)
-            outputHandle.write(chunk)
-            totalWritten += UInt64(chunk.count)
-            checksum = updateCRC32(checksum, with: chunk)
-            remainingBytes -= UInt64(chunk.count)
-        }
-
-        return (totalWritten, UInt32(checksum))
-    }
-
-    private static func extractDeflatedEntry(
-        from handle: FileHandle,
-        compressedSize: UInt64,
-        path: String,
-        to outputHandle: FileHandle
-    ) throws -> (writtenSize: UInt64, checksum: UInt32) {
-        let outputBuffer = UnsafeMutablePointer<UInt8>.allocate(capacity: ArchiveExtractionUtilities.bufferSize)
-
-        defer {
-            outputBuffer.deallocate()
-        }
-
-        var stream = z_stream()
-        let initStatus = inflateInit2_(
-            &stream,
-            -MAX_WBITS,
-            ZLIB_VERSION,
-            Int32(MemoryLayout<z_stream>.size)
-        )
-
-        guard initStatus == Z_OK else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 11,
-                userInfo: [NSLocalizedDescriptionKey: "Failed to initialize ZIP inflater"]
-            )
-        }
-
-        defer {
-            inflateEnd(&stream)
-        }
-
-        var remainingBytes = compressedSize
-        var totalWritten: UInt64 = 0
-        var checksum: uLong = crc32(0, nil, 0)
-        var reachedStreamEnd = false
-
-        while remainingBytes > 0 {
-            let chunkSize = Int(min(remainingBytes, UInt64(ArchiveExtractionUtilities.bufferSize)))
-            let chunk = try ArchiveExtractionUtilities.readExactly(from: handle, count: chunkSize)
-            remainingBytes -= UInt64(chunk.count)
-
-            try chunk.withUnsafeBytes { rawBuffer in
-                guard let baseAddress = rawBuffer.bindMemory(to: UInt8.self).baseAddress else {
-                    return
-                }
-
-                stream.next_in = UnsafeMutablePointer(mutating: baseAddress)
-                stream.avail_in = uInt(chunk.count)
-                var needsMoreInput = false
-
-                repeat {
-                    stream.next_out = outputBuffer
-                    stream.avail_out = uInt(ArchiveExtractionUtilities.bufferSize)
-
-                    let status = inflate(&stream, Z_NO_FLUSH)
-                    let producedBytes = ArchiveExtractionUtilities.bufferSize - Int(stream.avail_out)
-                    if producedBytes > 0 {
-                        let outputData = Data(bytes: outputBuffer, count: producedBytes)
-                        outputHandle.write(outputData)
-                        totalWritten += UInt64(producedBytes)
-                        checksum = updateCRC32(checksum, with: outputData)
-                    }
-
-                    switch status {
-                    case Z_OK, Z_STREAM_END:
-                        if status == Z_STREAM_END {
-                            guard stream.avail_in == 0, remainingBytes == 0 else {
-                                throw NSError(
-                                    domain: "ZipArchiveExtractor",
-                                    code: 12,
-                                    userInfo: [NSLocalizedDescriptionKey: "ZIP deflate stream ended unexpectedly"]
-                                )
-                            }
-
-                            reachedStreamEnd = true
-                        }
-                    case Z_BUF_ERROR:
-                        guard stream.avail_in == 0, remainingBytes > 0 else {
-                            let message = stream.msg.map { String(cString: $0) } ?? "Unknown zlib error"
-                            throw NSError(
-                                domain: "ZipArchiveExtractor",
-                                code: 13,
-                                userInfo: [
-                                    NSLocalizedDescriptionKey:
-                                        "ZIP deflate failed for \(path): status=\(status) totalIn=\(stream.total_in) totalOut=\(stream.total_out) \(message)"
-                                ]
-                            )
-                        }
-
-                        needsMoreInput = true
-
-                    default:
-                        let message = stream.msg.map { String(cString: $0) } ?? "Unknown zlib error"
-                        throw NSError(
-                            domain: "ZipArchiveExtractor",
-                            code: 13,
-                            userInfo: [
-                                NSLocalizedDescriptionKey:
-                                    "ZIP deflate failed for \(path): status=\(status) totalIn=\(stream.total_in) totalOut=\(stream.total_out) \(message)"
-                            ]
-                        )
-                    }
-                } while (stream.avail_in > 0 || stream.avail_out == 0) && !needsMoreInput && !reachedStreamEnd
-            }
-
-            if reachedStreamEnd {
-                break
-            }
-        }
-
-        guard reachedStreamEnd || compressedSize == 0 else {
-            throw NSError(
-                domain: "ZipArchiveExtractor",
-                code: 14,
-                userInfo: [NSLocalizedDescriptionKey: "ZIP deflate stream did not terminate correctly"]
-            )
-        }
-
-        return (totalWritten, UInt32(checksum))
-    }
-
-    private static func findLastSignature(_ signature: [UInt8], in data: Data) -> Int? {
-        guard signature.count <= data.count else {
-            return nil
-        }
-
-        let lastStartIndex = data.count - signature.count
-        for startIndex in stride(from: lastStartIndex, through: 0, by: -1) {
-            if Array(data[startIndex..<(startIndex + signature.count)]) == signature {
-                return startIndex
-            }
-        }
-
-        return nil
-    }
-
-    private static func decodePath(from data: Data) -> String {
-        if let utf8Path = String(data: data, encoding: .utf8) {
-            return utf8Path
-        }
-
-        return String(decoding: data, as: UTF8.self)
-    }
-
-    private static func updateCRC32(_ checksum: uLong, with data: Data) -> uLong {
-        data.withUnsafeBytes { rawBuffer in
-            guard let baseAddress = rawBuffer.bindMemory(to: Bytef.self).baseAddress else {
-                return checksum
-            }
-
-            return crc32(checksum, baseAddress, uInt(data.count))
-        }
-    }
-
-    private static func unixFileMode(versionMadeBy: UInt16, externalAttributes: UInt32) -> UInt16? {
-        let hostIdentifier = UInt8((versionMadeBy >> 8) & 0xFF)
-        guard hostIdentifier == unixHostIdentifier else {
-            return nil
-        }
-
-        let mode = UInt16((externalAttributes >> 16) & 0xFFFF) & fileTypeMask
-        guard mode != 0 else {
-            return nil
-        }
-
-        return mode
-    }
-
-    private static func archiveFileSize(at path: String) throws -> UInt64 {
-        let attributes = try FileManager.default.attributesOfItem(atPath: path)
-        if let number = attributes[.size] as? NSNumber {
-            return number.uint64Value
-        }
-
-        if let value = attributes[.size] as? UInt64 {
-            return value
-        }
-
-        return 0
-    }
-}

package/ios/HotUpdater/Internal/ZipDecompressionStrategy.swift

@@ -1,56 +0,0 @@
-import Foundation
-
-/**
- * Strategy for handling ZIP compressed files
- */
-class ZipDecompressionStrategy: DecompressionStrategy {
-    private static let ZIP_MAGIC_NUMBER: [UInt8] = [0x50, 0x4B, 0x03, 0x04]
-    private static let MIN_ZIP_SIZE: UInt64 = 22
-
-    func isValid(file: String) -> Bool {
-        guard FileManager.default.fileExists(atPath: file) else {
-            NSLog("[ZipStrategy] Invalid ZIP: file doesn't exist")
-            return false
-        }
-
-        do {
-            let attributes = try FileManager.default.attributesOfItem(atPath: file)
-            guard let fileSize = attributes[.size] as? UInt64, fileSize >= Self.MIN_ZIP_SIZE else {
-                NSLog("[ZipStrategy] Invalid ZIP: file too small")
-                return false
-            }
-        } catch {
-            NSLog("[ZipStrategy] Invalid ZIP: cannot read attributes - \(error.localizedDescription)")
-            return false
-        }
-
-        guard let fileHandle = FileHandle(forReadingAtPath: file) else {
-            NSLog("[ZipStrategy] Invalid ZIP: cannot open file")
-            return false
-        }
-
-        defer {
-            fileHandle.closeFile()
-        }
-
-        guard let header = try? ArchiveExtractionUtilities.readUpToCount(from: fileHandle, count: 4),
-              header.count == 4 else {
-            NSLog("[ZipStrategy] Invalid ZIP: cannot read header")
-            return false
-        }
-
-        let magicBytes = [UInt8](header)
-        guard magicBytes == Self.ZIP_MAGIC_NUMBER else {
-            NSLog("[ZipStrategy] Invalid ZIP: wrong magic number")
-            return false
-        }
-
-        return true
-    }
-
-    func decompress(file: String, to destination: String, progressHandler: @escaping (Double) -> Void) throws {
-        NSLog("[ZipStrategy] Starting extraction of \(file) to \(destination)")
-        try ZipArchiveExtractor.extract(file: file, to: destination, progressHandler: progressHandler)
-        NSLog("[ZipStrategy] Successfully extracted all entries")
-    }
-}

package/lib/commonjs/catalogCacheNative.spec.js

@@ -1,31 +0,0 @@
-"use strict";
-
-var _vitest = require("vitest");
-var _catalogCacheNative = require("./catalogCacheNative.js");
-const nativeModule = _vitest.vi.hoisted(() => ({}));
-_vitest.vi.mock("./specs/NativeHotUpdater", () => ({
-  default: nativeModule
-}));
-(0, _vitest.describe)("Release Catalog native cache", () => {
-  (0, _vitest.beforeEach)(() => {
-    for (const key of Object.keys(nativeModule)) delete nativeModule[key];
-  });
-  (0, _vitest.it)("fails fast when the v1 native cache API is missing", async () => {
-    await (0, _vitest.expect)((0, _catalogCacheNative.readNativeReleaseCatalogCache)("partition")).rejects.toThrow("Native module is missing 'getReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.");
-    await (0, _vitest.expect)((0, _catalogCacheNative.writeNativeReleaseCatalogCache)("partition", "payload")).rejects.toThrow("Native module is missing 'setReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.");
-    await (0, _vitest.expect)((0, _catalogCacheNative.removeNativeReleaseCatalogCache)("partition")).rejects.toThrow("Native module is missing 'removeReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.");
-  });
-  (0, _vitest.it)("normalizes an undefined iOS TurboModule cache miss to null", async () => {
-    nativeModule.getReleaseCatalogCache = _vitest.vi.fn().mockResolvedValue(undefined);
-    await (0, _vitest.expect)((0, _catalogCacheNative.readNativeReleaseCatalogCache)("partition")).resolves.toBeNull();
-  });
-  (0, _vitest.it)("treats native cache I/O failures as misses without hiding network work", async () => {
-    nativeModule.getReleaseCatalogCache = _vitest.vi.fn().mockRejectedValue(new Error("read"));
-    nativeModule.setReleaseCatalogCache = _vitest.vi.fn().mockRejectedValue(new Error("write"));
-    nativeModule.removeReleaseCatalogCache = _vitest.vi.fn().mockRejectedValue(new Error("remove"));
-    await (0, _vitest.expect)((0, _catalogCacheNative.readNativeReleaseCatalogCache)("partition")).resolves.toBeNull();
-    await (0, _vitest.expect)((0, _catalogCacheNative.writeNativeReleaseCatalogCache)("partition", "payload")).resolves.toBe(false);
-    await (0, _vitest.expect)((0, _catalogCacheNative.removeNativeReleaseCatalogCache)("partition")).resolves.toBeUndefined();
-  });
-});
-//# sourceMappingURL=catalogCacheNative.spec.js.map

package/lib/commonjs/catalogCacheNative.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["_vitest","require","_catalogCacheNative","nativeModule","vi","hoisted","mock","default","describe","beforeEach","key","Object","keys","it","expect","readNativeReleaseCatalogCache","rejects","toThrow","writeNativeReleaseCatalogCache","removeNativeReleaseCatalogCache","getReleaseCatalogCache","fn","mockResolvedValue","undefined","resolves","toBeNull","mockRejectedValue","Error","setReleaseCatalogCache","removeReleaseCatalogCache","toBe","toBeUndefined"],"sourceRoot":"../../src","sources":["catalogCacheNative.spec.ts"],"mappings":";;AAAA,IAAAA,OAAA,GAAAC,OAAA;AAQA,IAAAC,mBAAA,GAAAD,OAAA;AANA,MAAME,YAAY,GAAGC,UAAE,CAACC,OAAO,CAC7B,OAAO,CAAC,CAAC,CACX,CAAC;AAEDD,UAAE,CAACE,IAAI,CAAC,0BAA0B,EAAE,OAAO;EAAEC,OAAO,EAAEJ;AAAa,CAAC,CAAC,CAAC;AAQtE,IAAAK,gBAAQ,EAAC,8BAA8B,EAAE,MAAM;EAC7C,IAAAC,kBAAU,EAAC,MAAM;IACf,KAAK,MAAMC,GAAG,IAAIC,MAAM,CAACC,IAAI,CAACT,YAAY,CAAC,EAAE,OAAOA,YAAY,CAACO,GAAG,CAAC;EACvE,CAAC,CAAC;EAEF,IAAAG,UAAE,EAAC,oDAAoD,EAAE,YAAY;IACnE,MAAM,IAAAC,cAAM,EAAC,IAAAC,iDAA6B,EAAC,WAAW,CAAC,CAAC,CAACC,OAAO,CAACC,OAAO,CACtE,4GACF,CAAC;IACD,MAAM,IAAAH,cAAM,EACV,IAAAI,kDAA8B,EAAC,WAAW,EAAE,SAAS,CACvD,CAAC,CAACF,OAAO,CAACC,OAAO,CACf,4GACF,CAAC;IACD,MAAM,IAAAH,cAAM,EAAC,IAAAK,mDAA+B,EAAC,WAAW,CAAC,CAAC,CAACH,OAAO,CAACC,OAAO,CACxE,+GACF,CAAC;EACH,CAAC,CAAC;EAEF,IAAAJ,UAAE,EAAC,4DAA4D,EAAE,YAAY;IAC3EV,YAAY,CAACiB,sBAAsB,GAAGhB,UAAE,CAACiB,EAAE,CAAC,CAAC,CAACC,iBAAiB,CAACC,SAAS,CAAC;IAE1E,MAAM,IAAAT,cAAM,EACV,IAAAC,iDAA6B,EAAC,WAAW,CAC3C,CAAC,CAACS,QAAQ,CAACC,QAAQ,CAAC,CAAC;EACvB,CAAC,CAAC;EAEF,IAAAZ,UAAE,EAAC,wEAAwE,EAAE,YAAY;IACvFV,YAAY,CAACiB,sBAAsB,GAAGhB,UAAE,CACrCiB,EAAE,CAAC,CAAC,CACJK,iBAAiB,CAAC,IAAIC,KAAK,CAAC,MAAM,CAAC,CAAC;IACvCxB,YAAY,CAACyB,sBAAsB,GAAGxB,UAAE,CACrCiB,EAAE,CAAC,CAAC,CACJK,iBAAiB,CAAC,IAAIC,KAAK,CAAC,OAAO,CAAC,CAAC;IACxCxB,YAAY,CAAC0B,yBAAyB,GAAGzB,UAAE,CACxCiB,EAAE,CAAC,CAAC,CACJK,iBAAiB,CAAC,IAAIC,KAAK,CAAC,QAAQ,CAAC,CAAC;IAEzC,MAAM,IAAAb,cAAM,EACV,IAAAC,iDAA6B,EAAC,WAAW,CAC3C,CAAC,CAACS,QAAQ,CAACC,QAAQ,CAAC,CAAC;IACrB,MAAM,IAAAX,cAAM,EACV,IAAAI,kDAA8B,EAAC,WAAW,EAAE,SAAS,CACvD,CAAC,CAACM,QAAQ,CAACM,IAAI,CAAC,KAAK,CAAC;IACtB,MAAM,IAAAhB,cAAM,EACV,IAAAK,mDAA+B,EAAC,WAAW,CAC7C,CAAC,CAACK,QAAQ,CAACO,aAAa,CAAC,CAAC;EAC5B,CAAC,CAAC;AACJ,CAAC,CAAC","ignoreList":[]}