@depup/expo__cli 55.0.16-depup.0

package/build/src/api/rest/cache/FileSystemResponseCache.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FileSystemResponseCache", {
+    enumerable: true,
+    get: function() {
+        return FileSystemResponseCache;
+    }
+});
+function _nodecrypto() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:crypto"));
+    _nodecrypto = function() {
+        return data;
+    };
+    return data;
+}
+function _nodefs() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+    _nodefs = function() {
+        return data;
+    };
+    return data;
+}
+function _nodepath() {
+    const data = /*#__PURE__*/ _interop_require_default(require("node:path"));
+    _nodepath = function() {
+        return data;
+    };
+    return data;
+}
+function _nodestream() {
+    const data = /*#__PURE__*/ _interop_require_wildcard(require("node:stream"));
+    _nodestream = function() {
+        return data;
+    };
+    return data;
+}
+const _dir = require("../../../utils/dir");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class FileSystemResponseCache {
+    constructor(options){
+        this.cacheDirectory = options.cacheDirectory;
+        this.timeToLive = options.ttl;
+    }
+    getFilePaths(cacheKey) {
+        // Create a hash of the cache key to use as filename
+        const hash = _nodecrypto().default.createHash('sha256').update(cacheKey).digest('hex');
+        return {
+            info: _nodepath().default.join(this.cacheDirectory, `${hash}-info.json`),
+            body: _nodepath().default.join(this.cacheDirectory, `${hash}-body.bin`)
+        };
+    }
+    /** Retrieve the cache response, if any */ async get(cacheKey) {
+        const paths = this.getFilePaths(cacheKey);
+        if (!await (0, _dir.fileExistsAsync)(paths.info)) {
+            return undefined;
+        }
+        // Read and parse the info file
+        const infoBuffer = await _nodefs().default.promises.readFile(paths.info);
+        try {
+            const responseInfo = JSON.parse(infoBuffer.toString());
+            // Check if the response has expired
+            if (responseInfo.expiration && responseInfo.expiration < Date.now()) {
+                await this.remove(cacheKey);
+                return undefined;
+            }
+            // Remove cache-specific data from the response info
+            const { empty, expiration, bodyPath, ...cleanInfo } = responseInfo;
+            // Create response body stream
+            let responseBody;
+            if (empty) {
+                responseBody = _nodestream().Readable.toWeb(_nodestream().Readable.from(Buffer.alloc(0)));
+            } else {
+                const bodyBuffer = await _nodefs().default.promises.readFile(paths.body);
+                responseBody = _nodestream().Readable.toWeb(_nodestream().Readable.from(bodyBuffer));
+            }
+            return {
+                body: responseBody,
+                info: cleanInfo
+            };
+        } catch  {
+            // If file doesn't exist or other errors, return undefined
+            return undefined;
+        }
+    }
+    /** Store the response for caching */ async set(cacheKey, response) {
+        await _nodefs().default.promises.mkdir(this.cacheDirectory, {
+            recursive: true
+        });
+        const paths = this.getFilePaths(cacheKey);
+        // Create a copy of the response info, to add cache-specific data
+        const responseInfo = {
+            ...response.info
+        };
+        // Add expiration time if the "time to live" is set
+        if (typeof this.timeToLive === 'number') {
+            responseInfo.expiration = Date.now() + this.timeToLive;
+        }
+        try {
+            // Clone the response body stream since we need to read it twice
+            const [forSize, forWrite] = response.body.tee();
+            // Check if the body is empty by reading the first stream
+            const reader = forSize.getReader();
+            const { value } = await reader.read();
+            reader.releaseLock();
+            if (!value || value.length === 0) {
+                responseInfo.empty = true;
+            } else {
+                // Create write stream and pipe response body to file
+                const writeStream = _nodefs().default.createWriteStream(paths.body);
+                const nodeStream = _nodestream().Readable.fromWeb(forWrite);
+                nodeStream.pipe(writeStream);
+                // Wait for the stream to finish
+                await _nodestream().default.promises.finished(writeStream);
+                responseInfo.bodyPath = paths.body;
+            }
+            // Write info to file
+            await _nodefs().default.promises.writeFile(paths.info, JSON.stringify(responseInfo));
+            return await this.get(cacheKey);
+        } catch (error) {
+            // Clean up any partially written files
+            await this.remove(cacheKey);
+            throw error;
+        }
+    }
+    /** Remove the response from caching */ async remove(cacheKey) {
+        const paths = this.getFilePaths(cacheKey);
+        await removeAllAsync(paths.info, paths.body);
+    }
+}
+function removeAllAsync(...paths) {
+    return Promise.all(paths.map((path)=>_nodefs().default.promises.rm(path, {
+            recursive: true,
+            force: true
+        }).catch(()=>{})));
+}
+
+//# sourceMappingURL=FileSystemResponseCache.js.map

package/build/src/api/rest/cache/FileSystemResponseCache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/api/rest/cache/FileSystemResponseCache.ts"],"sourcesContent":["import crypto from 'node:crypto';\nimport fs from 'node:fs';\nimport path from 'node:path';\nimport stream, { Readable } from 'node:stream';\nimport { ReadableStream } from 'node:stream/web';\n\nimport type { ResponseCache, ResponseCacheEntry } from './ResponseCache';\nimport { fileExistsAsync } from '../../../utils/dir';\n\ntype FileSystemResponseCacheInfo = ResponseCacheEntry['info'] & {\n  /** The path to the cached body file */\n  bodyPath?: string;\n  /** If there is no response body */\n  empty?: boolean;\n  /** The expiration time, in milliseconds, when the response should be invalidated */\n  expiration?: number;\n};\n\nexport class FileSystemResponseCache implements ResponseCache {\n  /** The absolute path to the directory used to store responses */\n  private cacheDirectory: string;\n  /** Optional auto-expiration for all stored responses */\n  private timeToLive?: number;\n\n  constructor(options: { cacheDirectory: string; ttl?: number }) {\n    this.cacheDirectory = options.cacheDirectory;\n    this.timeToLive = options.ttl;\n  }\n\n  private getFilePaths(cacheKey: string) {\n    // Create a hash of the cache key to use as filename\n    const hash = crypto.createHash('sha256').update(cacheKey).digest('hex');\n    return {\n      info: path.join(this.cacheDirectory, `${hash}-info.json`),\n      body: path.join(this.cacheDirectory, `${hash}-body.bin`),\n    };\n  }\n\n  /** Retrieve the cache response, if any */\n  async get(cacheKey: string): Promise<ResponseCacheEntry | undefined> {\n    const paths = this.getFilePaths(cacheKey);\n\n    if (!(await fileExistsAsync(paths.info))) {\n      return undefined;\n    }\n\n    // Read and parse the info file\n    const infoBuffer = await fs.promises.readFile(paths.info);\n\n    try {\n      const responseInfo: FileSystemResponseCacheInfo = JSON.parse(infoBuffer.toString());\n\n      // Check if the response has expired\n      if (responseInfo.expiration && responseInfo.expiration < Date.now()) {\n        await this.remove(cacheKey);\n        return undefined;\n      }\n\n      // Remove cache-specific data from the response info\n      const { empty, expiration, bodyPath, ...cleanInfo } = responseInfo;\n\n      // Create response body stream\n      let responseBody: ReadableStream;\n      if (empty) {\n        responseBody = Readable.toWeb(Readable.from(Buffer.alloc(0)));\n      } else {\n        const bodyBuffer = await fs.promises.readFile(paths.body);\n        responseBody = Readable.toWeb(Readable.from(bodyBuffer));\n      }\n\n      return {\n        body: responseBody as globalThis.ReadableStream,\n        info: cleanInfo,\n      };\n    } catch {\n      // If file doesn't exist or other errors, return undefined\n      return undefined;\n    }\n  }\n\n  /** Store the response for caching */\n  async set(\n    cacheKey: string,\n    response: ResponseCacheEntry\n  ): Promise<ResponseCacheEntry | undefined> {\n    await fs.promises.mkdir(this.cacheDirectory, { recursive: true });\n    const paths = this.getFilePaths(cacheKey);\n\n    // Create a copy of the response info, to add cache-specific data\n    const responseInfo: FileSystemResponseCacheInfo = { ...response.info };\n\n    // Add expiration time if the \"time to live\" is set\n    if (typeof this.timeToLive === 'number') {\n      responseInfo.expiration = Date.now() + this.timeToLive;\n    }\n\n    try {\n      // Clone the response body stream since we need to read it twice\n      const [forSize, forWrite] = response.body.tee();\n\n      // Check if the body is empty by reading the first stream\n      const reader = forSize.getReader();\n      const { value } = await reader.read();\n      reader.releaseLock();\n\n      if (!value || value.length === 0) {\n        responseInfo.empty = true;\n      } else {\n        // Create write stream and pipe response body to file\n        const writeStream = fs.createWriteStream(paths.body);\n        const nodeStream = Readable.fromWeb(forWrite as ReadableStream);\n        nodeStream.pipe(writeStream);\n\n        // Wait for the stream to finish\n        await stream.promises.finished(writeStream);\n\n        responseInfo.bodyPath = paths.body;\n      }\n\n      // Write info to file\n      await fs.promises.writeFile(paths.info, JSON.stringify(responseInfo));\n\n      return await this.get(cacheKey);\n    } catch (error) {\n      // Clean up any partially written files\n      await this.remove(cacheKey);\n      throw error;\n    }\n  }\n\n  /** Remove the response from caching */\n  async remove(cacheKey: string): Promise<void> {\n    const paths = this.getFilePaths(cacheKey);\n    await removeAllAsync(paths.info, paths.body);\n  }\n}\n\nfunction removeAllAsync(...paths: string[]) {\n  return Promise.all(\n    paths.map((path) => fs.promises.rm(path, { recursive: true, force: true }).catch(() => {}))\n  );\n}\n"],"names":["FileSystemResponseCache","constructor","options","cacheDirectory","timeToLive","ttl","getFilePaths","cacheKey","hash","crypto","createHash","update","digest","info","path","join","body","get","paths","fileExistsAsync","undefined","infoBuffer","fs","promises","readFile","responseInfo","JSON","parse","toString","expiration","Date","now","remove","empty","bodyPath","cleanInfo","responseBody","Readable","toWeb","from","Buffer","alloc","bodyBuffer","set","response","mkdir","recursive","forSize","forWrite","tee","reader","getReader","value","read","releaseLock","length","writeStream","createWriteStream","nodeStream","fromWeb","pipe","stream","finished","writeFile","stringify","error","removeAllAsync","Promise","all","map","rm","force","catch"],"mappings":"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"}

package/build/src/api/rest/cache/ResponseCache.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getRequestBodyCacheData: function() {
+        return getRequestBodyCacheData;
+    },
+    getRequestCacheKey: function() {
+        return getRequestCacheKey;
+    },
+    getRequestInfoCacheData: function() {
+        return getRequestInfoCacheData;
+    },
+    getResponseInfo: function() {
+        return getResponseInfo;
+    }
+});
+function _crypto() {
+    const data = /*#__PURE__*/ _interop_require_default(require("crypto"));
+    _crypto = function() {
+        return data;
+    };
+    return data;
+}
+function _fs() {
+    const data = require("fs");
+    _fs = function() {
+        return data;
+    };
+    return data;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const GLOBAL_CACHE_VERSION = 4;
+function getResponseInfo(response) {
+    const headers = Object.fromEntries(response.headers.entries());
+    delete headers['set-cookie'];
+    return {
+        url: response.url,
+        status: response.status,
+        statusText: response.statusText,
+        headers
+    };
+}
+function getRequestCacheKey(info, init) {
+    const infoKeyData = getRequestInfoCacheData(info);
+    const initKeyData = {
+        body: (init == null ? void 0 : init.body) ? getRequestBodyCacheData(init.body) : undefined
+    };
+    return _crypto().default.createHash('md5').update(JSON.stringify([
+        infoKeyData,
+        initKeyData,
+        GLOBAL_CACHE_VERSION
+    ])).digest('hex');
+}
+function getRequestInfoCacheData(info) {
+    if (typeof info === 'string') {
+        return {
+            url: info
+        };
+    }
+    if (info instanceof URL) {
+        return {
+            url: info.toString()
+        };
+    }
+    if (info instanceof Request) {
+        return {
+            // cache: req.cache,
+            credentials: info.credentials.toString(),
+            destination: info.destination.toString(),
+            headers: Object.fromEntries(info.headers.entries()),
+            integrity: info.integrity,
+            method: info.method,
+            redirect: info.redirect,
+            referrer: info.referrer,
+            referrerPolicy: info.referrerPolicy,
+            url: info.url.toString()
+        };
+    }
+    throw new Error('Unsupported request info type for caching: ' + typeof info);
+}
+function getRequestBodyCacheData(body) {
+    if (!body) {
+        return body;
+    }
+    if (typeof body === 'string') {
+        return body;
+    }
+    if (body instanceof URLSearchParams) {
+        return body.toString();
+    }
+    // Supported for legacy purposes because node-fetch uses fs.readStream
+    if (body instanceof _fs().ReadStream) {
+        return body.path;
+    }
+    if (body.toString && body.toString() === '[object FormData]') {
+        return new URLSearchParams(body).toString();
+    }
+    if (body instanceof Buffer) {
+        return body.toString();
+    }
+    throw new Error(`Unsupported request body type for caching: ${typeof body}`);
+}
+
+//# sourceMappingURL=ResponseCache.js.map

package/build/src/api/rest/cache/ResponseCache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/api/rest/cache/ResponseCache.ts"],"sourcesContent":["import crypto from 'crypto';\nimport type { Response, RequestInfo, RequestInit } from 'fetch-nodeshim';\nimport { ReadStream } from 'fs';\n\nconst GLOBAL_CACHE_VERSION = 4;\n\nexport type ResponseCacheEntry = {\n  body: ReadableStream;\n  info: ReturnType<typeof getResponseInfo>;\n};\n\nexport interface ResponseCache {\n  /** Load the response info from cache, if any */\n  get(cacheKey: string): Promise<ResponseCacheEntry | undefined>;\n  /** Store the response info to cache, and return the cached info */\n  set(cacheKey: string, response: ResponseCacheEntry): Promise<ResponseCacheEntry | undefined>;\n  /** Remove a response entry from the cache */\n  remove(cacheKey: string): Promise<void>;\n}\n\nexport function getResponseInfo(response: Response) {\n  const headers = Object.fromEntries(response.headers.entries());\n  delete headers['set-cookie'];\n  return {\n    url: response.url,\n    status: response.status,\n    statusText: response.statusText,\n    headers,\n  };\n}\n\nexport function getRequestCacheKey(info: RequestInfo, init?: RequestInit) {\n  const infoKeyData = getRequestInfoCacheData(info);\n  const initKeyData = { body: init?.body ? getRequestBodyCacheData(init.body) : undefined };\n\n  return crypto\n    .createHash('md5')\n    .update(JSON.stringify([infoKeyData, initKeyData, GLOBAL_CACHE_VERSION]))\n    .digest('hex');\n}\n\n/** @internal Exposed for testing */\nexport function getRequestInfoCacheData(info: RequestInfo) {\n  if (typeof info === 'string') {\n    return { url: info };\n  }\n\n  if (info instanceof URL) {\n    return { url: info.toString() };\n  }\n\n  if (info instanceof Request) {\n    return {\n      // cache: req.cache,\n      credentials: info.credentials.toString(),\n      destination: info.destination.toString(),\n      headers: Object.fromEntries(info.headers.entries()),\n      integrity: info.integrity,\n      method: info.method,\n      redirect: info.redirect,\n      referrer: info.referrer,\n      referrerPolicy: info.referrerPolicy,\n      url: info.url.toString(),\n      // body: // TODO\n    };\n  }\n\n  throw new Error('Unsupported request info type for caching: ' + typeof info);\n}\n\n/** @internal Exposed for testing */\nexport function getRequestBodyCacheData(body: RequestInit['body']) {\n  if (!body) {\n    return body;\n  }\n\n  if (typeof body === 'string') {\n    return body;\n  }\n\n  if (body instanceof URLSearchParams) {\n    return body.toString();\n  }\n\n  // Supported for legacy purposes because node-fetch uses fs.readStream\n  if (body instanceof ReadStream) {\n    return body.path;\n  }\n\n  if (body.toString && body.toString() === '[object FormData]') {\n    return new URLSearchParams(body as any).toString();\n  }\n\n  if (body instanceof Buffer) {\n    return body.toString();\n  }\n\n  throw new Error(`Unsupported request body type for caching: ${typeof body}`);\n}\n"],"names":["getRequestBodyCacheData","getRequestCacheKey","getRequestInfoCacheData","getResponseInfo","GLOBAL_CACHE_VERSION","response","headers","Object","fromEntries","entries","url","status","statusText","info","init","infoKeyData","initKeyData","body","undefined","crypto","createHash","update","JSON","stringify","digest","URL","toString","Request","credentials","destination","integrity","method","redirect","referrer","referrerPolicy","Error","URLSearchParams","ReadStream","path","Buffer"],"mappings":";;;;;;;;;;;IAuEgBA,uBAAuB;eAAvBA;;IAxCAC,kBAAkB;eAAlBA;;IAWAC,uBAAuB;eAAvBA;;IAtBAC,eAAe;eAAfA;;;;gEApBG;;;;;;;yBAEQ;;;;;;;;;;;AAE3B,MAAMC,uBAAuB;AAgBtB,SAASD,gBAAgBE,QAAkB;IAChD,MAAMC,UAAUC,OAAOC,WAAW,CAACH,SAASC,OAAO,CAACG,OAAO;IAC3D,OAAOH,OAAO,CAAC,aAAa;IAC5B,OAAO;QACLI,KAAKL,SAASK,GAAG;QACjBC,QAAQN,SAASM,MAAM;QACvBC,YAAYP,SAASO,UAAU;QAC/BN;IACF;AACF;AAEO,SAASL,mBAAmBY,IAAiB,EAAEC,IAAkB;IACtE,MAAMC,cAAcb,wBAAwBW;IAC5C,MAAMG,cAAc;QAAEC,MAAMH,CAAAA,wBAAAA,KAAMG,IAAI,IAAGjB,wBAAwBc,KAAKG,IAAI,IAAIC;IAAU;IAExF,OAAOC,iBAAM,CACVC,UAAU,CAAC,OACXC,MAAM,CAACC,KAAKC,SAAS,CAAC;QAACR;QAAaC;QAAaZ;KAAqB,GACtEoB,MAAM,CAAC;AACZ;AAGO,SAAStB,wBAAwBW,IAAiB;IACvD,IAAI,OAAOA,SAAS,UAAU;QAC5B,OAAO;YAAEH,KAAKG;QAAK;IACrB;IAEA,IAAIA,gBAAgBY,KAAK;QACvB,OAAO;YAAEf,KAAKG,KAAKa,QAAQ;QAAG;IAChC;IAEA,IAAIb,gBAAgBc,SAAS;QAC3B,OAAO;YACL,oBAAoB;YACpBC,aAAaf,KAAKe,WAAW,CAACF,QAAQ;YACtCG,aAAahB,KAAKgB,WAAW,CAACH,QAAQ;YACtCpB,SAASC,OAAOC,WAAW,CAACK,KAAKP,OAAO,CAACG,OAAO;YAChDqB,WAAWjB,KAAKiB,SAAS;YACzBC,QAAQlB,KAAKkB,MAAM;YACnBC,UAAUnB,KAAKmB,QAAQ;YACvBC,UAAUpB,KAAKoB,QAAQ;YACvBC,gBAAgBrB,KAAKqB,cAAc;YACnCxB,KAAKG,KAAKH,GAAG,CAACgB,QAAQ;QAExB;IACF;IAEA,MAAM,IAAIS,MAAM,gDAAgD,OAAOtB;AACzE;AAGO,SAASb,wBAAwBiB,IAAyB;IAC/D,IAAI,CAACA,MAAM;QACT,OAAOA;IACT;IAEA,IAAI,OAAOA,SAAS,UAAU;QAC5B,OAAOA;IACT;IAEA,IAAIA,gBAAgBmB,iBAAiB;QACnC,OAAOnB,KAAKS,QAAQ;IACtB;IAEA,sEAAsE;IACtE,IAAIT,gBAAgBoB,gBAAU,EAAE;QAC9B,OAAOpB,KAAKqB,IAAI;IAClB;IAEA,IAAIrB,KAAKS,QAAQ,IAAIT,KAAKS,QAAQ,OAAO,qBAAqB;QAC5D,OAAO,IAAIU,gBAAgBnB,MAAaS,QAAQ;IAClD;IAEA,IAAIT,gBAAgBsB,QAAQ;QAC1B,OAAOtB,KAAKS,QAAQ;IACtB;IAEA,MAAM,IAAIS,MAAM,CAAC,2CAA2C,EAAE,OAAOlB,MAAM;AAC7E"}

package/build/src/api/rest/cache/wrapFetchWithCache.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "wrapFetchWithCache", {
+    enumerable: true,
+    get: function() {
+        return wrapFetchWithCache;
+    }
+});
+function _fetchnodeshim() {
+    const data = require("fetch-nodeshim");
+    _fetchnodeshim = function() {
+        return data;
+    };
+    return data;
+}
+const _ResponseCache = require("./ResponseCache");
+const debug = require('debug')('expo:fetch-cache');
+function wrapFetchWithCache(fetch, cache) {
+    return async function cachedFetch(url, init) {
+        const cacheKey = (0, _ResponseCache.getRequestCacheKey)(url, init);
+        const cachedResponse = await cache.get(cacheKey);
+        if (cachedResponse) {
+            return new (_fetchnodeshim()).Response(cachedResponse.body, cachedResponse.info);
+        }
+        await lock(cacheKey);
+        try {
+            // Retry loading from cache, in case it was stored during the lock
+            let cachedResponse = await cache.get(cacheKey);
+            if (cachedResponse) {
+                return new (_fetchnodeshim()).Response(cachedResponse.body, cachedResponse.info);
+            }
+            // Execute the fetch request
+            const response = await fetch(url, init);
+            if (!response.ok || !response.body) {
+                return response;
+            }
+            // Cache the response
+            cachedResponse = await cache.set(cacheKey, {
+                body: response.body,
+                info: (0, _ResponseCache.getResponseInfo)(response)
+            });
+            // Warn through debug logs that caching failed
+            if (!cachedResponse) {
+                debug(`Failed to cache response for: ${url}`);
+                await cache.remove(cacheKey);
+                return response;
+            }
+            // Return the cached response
+            return new (_fetchnodeshim()).Response(cachedResponse.body, cachedResponse.info);
+        } finally{
+            unlock(cacheKey);
+        }
+    };
+}
+const lockPromiseForKey = {};
+const unlockFunctionForKey = {};
+async function lock(key) {
+    if (!lockPromiseForKey[key]) {
+        lockPromiseForKey[key] = Promise.resolve();
+    }
+    const takeLockPromise = lockPromiseForKey[key];
+    lockPromiseForKey[key] = takeLockPromise.then(()=>new Promise((fulfill)=>{
+            unlockFunctionForKey[key] = fulfill;
+        }));
+    return takeLockPromise;
+}
+function unlock(key) {
+    if (unlockFunctionForKey[key]) {
+        unlockFunctionForKey[key]();
+        delete unlockFunctionForKey[key];
+    }
+}
+
+//# sourceMappingURL=wrapFetchWithCache.js.map

package/build/src/api/rest/cache/wrapFetchWithCache.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/api/rest/cache/wrapFetchWithCache.ts"],"sourcesContent":["import { Response, type RequestInfo, type RequestInit } from 'fetch-nodeshim';\n\nimport { getRequestCacheKey, getResponseInfo, type ResponseCache } from './ResponseCache';\nimport type { FetchLike } from '../client.types';\n\nconst debug = require('debug')('expo:fetch-cache');\n\nexport function wrapFetchWithCache(fetch: FetchLike, cache: ResponseCache): FetchLike {\n  return async function cachedFetch(url: RequestInfo, init?: RequestInit) {\n    const cacheKey = getRequestCacheKey(url, init);\n    const cachedResponse = await cache.get(cacheKey);\n    if (cachedResponse) {\n      return new Response(cachedResponse.body, cachedResponse.info);\n    }\n\n    await lock(cacheKey);\n\n    try {\n      // Retry loading from cache, in case it was stored during the lock\n      let cachedResponse = await cache.get(cacheKey);\n      if (cachedResponse) {\n        return new Response(cachedResponse.body, cachedResponse.info);\n      }\n\n      // Execute the fetch request\n      const response = await fetch(url, init);\n      if (!response.ok || !response.body) {\n        return response;\n      }\n\n      // Cache the response\n      cachedResponse = await cache.set(cacheKey, {\n        body: response.body,\n        info: getResponseInfo(response),\n      });\n\n      // Warn through debug logs that caching failed\n      if (!cachedResponse) {\n        debug(`Failed to cache response for: ${url}`);\n        await cache.remove(cacheKey);\n        return response;\n      }\n\n      // Return the cached response\n      return new Response(cachedResponse.body, cachedResponse.info);\n    } finally {\n      unlock(cacheKey);\n    }\n  };\n}\n\nconst lockPromiseForKey: Record<string, Promise<any>> = {};\nconst unlockFunctionForKey: Record<string, any> = {};\n\nasync function lock(key: string) {\n  if (!lockPromiseForKey[key]) {\n    lockPromiseForKey[key] = Promise.resolve();\n  }\n\n  const takeLockPromise = lockPromiseForKey[key];\n  lockPromiseForKey[key] = takeLockPromise.then(\n    () =>\n      new Promise((fulfill) => {\n        unlockFunctionForKey[key] = fulfill;\n      })\n  );\n\n  return takeLockPromise;\n}\n\nfunction unlock(key: string) {\n  if (unlockFunctionForKey[key]) {\n    unlockFunctionForKey[key]();\n    delete unlockFunctionForKey[key];\n  }\n}\n"],"names":["wrapFetchWithCache","debug","require","fetch","cache","cachedFetch","url","init","cacheKey","getRequestCacheKey","cachedResponse","get","Response","body","info","lock","response","ok","set","getResponseInfo","remove","unlock","lockPromiseForKey","unlockFunctionForKey","key","Promise","resolve","takeLockPromise","then","fulfill"],"mappings":";;;;+BAOgBA;;;eAAAA;;;;yBAP6C;;;;;;+BAEW;AAGxE,MAAMC,QAAQC,QAAQ,SAAS;AAExB,SAASF,mBAAmBG,KAAgB,EAAEC,KAAoB;IACvE,OAAO,eAAeC,YAAYC,GAAgB,EAAEC,IAAkB;QACpE,MAAMC,WAAWC,IAAAA,iCAAkB,EAACH,KAAKC;QACzC,MAAMG,iBAAiB,MAAMN,MAAMO,GAAG,CAACH;QACvC,IAAIE,gBAAgB;YAClB,OAAO,IAAIE,CAAAA,gBAAO,UAAC,CAACF,eAAeG,IAAI,EAAEH,eAAeI,IAAI;QAC9D;QAEA,MAAMC,KAAKP;QAEX,IAAI;YACF,kEAAkE;YAClE,IAAIE,iBAAiB,MAAMN,MAAMO,GAAG,CAACH;YACrC,IAAIE,gBAAgB;gBAClB,OAAO,IAAIE,CAAAA,gBAAO,UAAC,CAACF,eAAeG,IAAI,EAAEH,eAAeI,IAAI;YAC9D;YAEA,4BAA4B;YAC5B,MAAME,WAAW,MAAMb,MAAMG,KAAKC;YAClC,IAAI,CAACS,SAASC,EAAE,IAAI,CAACD,SAASH,IAAI,EAAE;gBAClC,OAAOG;YACT;YAEA,qBAAqB;YACrBN,iBAAiB,MAAMN,MAAMc,GAAG,CAACV,UAAU;gBACzCK,MAAMG,SAASH,IAAI;gBACnBC,MAAMK,IAAAA,8BAAe,EAACH;YACxB;YAEA,8CAA8C;YAC9C,IAAI,CAACN,gBAAgB;gBACnBT,MAAM,CAAC,8BAA8B,EAAEK,KAAK;gBAC5C,MAAMF,MAAMgB,MAAM,CAACZ;gBACnB,OAAOQ;YACT;YAEA,6BAA6B;YAC7B,OAAO,IAAIJ,CAAAA,gBAAO,UAAC,CAACF,eAAeG,IAAI,EAAEH,eAAeI,IAAI;QAC9D,SAAU;YACRO,OAAOb;QACT;IACF;AACF;AAEA,MAAMc,oBAAkD,CAAC;AACzD,MAAMC,uBAA4C,CAAC;AAEnD,eAAeR,KAAKS,GAAW;IAC7B,IAAI,CAACF,iBAAiB,CAACE,IAAI,EAAE;QAC3BF,iBAAiB,CAACE,IAAI,GAAGC,QAAQC,OAAO;IAC1C;IAEA,MAAMC,kBAAkBL,iBAAiB,CAACE,IAAI;IAC9CF,iBAAiB,CAACE,IAAI,GAAGG,gBAAgBC,IAAI,CAC3C,IACE,IAAIH,QAAQ,CAACI;YACXN,oBAAoB,CAACC,IAAI,GAAGK;QAC9B;IAGJ,OAAOF;AACT;AAEA,SAASN,OAAOG,GAAW;IACzB,IAAID,oBAAoB,CAACC,IAAI,EAAE;QAC7BD,oBAAoB,CAACC,IAAI;QACzB,OAAOD,oBAAoB,CAACC,IAAI;IAClC;AACF"}

package/build/src/api/rest/client.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ApiV2Error: function() {
+        return ApiV2Error;
+    },
+    UnexpectedServerData: function() {
+        return UnexpectedServerData;
+    },
+    UnexpectedServerError: function() {
+        return UnexpectedServerError;
+    },
+    createCachedFetch: function() {
+        return createCachedFetch;
+    },
+    fetchAsync: function() {
+        return fetchAsync;
+    },
+    getResponseDataOrThrow: function() {
+        return getResponseDataOrThrow;
+    },
+    wrapFetchWithCredentials: function() {
+        return wrapFetchWithCredentials;
+    }
+});
+function _path() {
+    const data = /*#__PURE__*/ _interop_require_default(require("path"));
+    _path = function() {
+        return data;
+    };
+    return data;
+}
+const _wrapFetchWithCache = require("./cache/wrapFetchWithCache");
+const _wrapFetchWithBaseUrl = require("./wrapFetchWithBaseUrl");
+const _wrapFetchWithOffline = require("./wrapFetchWithOffline");
+const _wrapFetchWithProgress = require("./wrapFetchWithProgress");
+const _wrapFetchWithUserAgent = require("./wrapFetchWithUserAgent");
+const _env = require("../../utils/env");
+const _errors = require("../../utils/errors");
+const _fetch = require("../../utils/fetch");
+const _endpoint = require("../endpoint");
+const _settings = require("../settings");
+const _UserSettings = require("../user/UserSettings");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class ApiV2Error extends Error {
+    constructor(response){
+        super(response.message), this.name = 'ApiV2Error';
+        this.code = response.code;
+        this.expoApiV2ErrorCode = response.code;
+        this.expoApiV2ErrorDetails = response.details;
+        this.expoApiV2ErrorServerStack = response.stack;
+        this.expoApiV2ErrorMetadata = response.metadata;
+        this.expoApiV2RequestId = response.requestId;
+    }
+    toString() {
+        return `${super.toString()}${_env.env.EXPO_DEBUG && this.expoApiV2RequestId ? ` (Request Id: ${this.expoApiV2RequestId})` : ''}`;
+    }
+}
+class UnexpectedServerError extends Error {
+    constructor(...args){
+        super(...args), this.name = 'UnexpectedServerError';
+    }
+}
+class UnexpectedServerData extends Error {
+    constructor(...args){
+        super(...args), this.name = 'UnexpectedServerData';
+    }
+}
+function getResponseDataOrThrow(json) {
+    if (!!json && typeof json === 'object' && 'data' in json) {
+        return json.data;
+    }
+    throw new UnexpectedServerData(!!json && typeof json === 'object' ? JSON.stringify(json) : 'Unknown data received from server.');
+}
+function wrapFetchWithCredentials(fetchFunction) {
+    return async function fetchWithCredentials(url, options = {}) {
+        if (Array.isArray(options.headers)) {
+            throw new Error('request headers must be in object form');
+        }
+        const resolvedHeaders = options.headers ?? {};
+        const token = (0, _UserSettings.getAccessToken)();
+        if (token) {
+            resolvedHeaders.authorization = `Bearer ${token}`;
+        } else {
+            var _getSession;
+            const sessionSecret = (_getSession = (0, _UserSettings.getSession)()) == null ? void 0 : _getSession.sessionSecret;
+            if (sessionSecret) {
+                resolvedHeaders['expo-session'] = sessionSecret;
+            }
+        }
+        try {
+            const response = await fetchFunction(url, {
+                ...options,
+                headers: resolvedHeaders
+            });
+            // Handle expected API errors (4xx)
+            if (response.status >= 400 && response.status < 500) {
+                const body = await response.text();
+                try {
+                    var _data_errors;
+                    const data = JSON.parse(body);
+                    if (data == null ? void 0 : (_data_errors = data.errors) == null ? void 0 : _data_errors.length) {
+                        throw new ApiV2Error(data.errors[0]);
+                    }
+                } catch (error) {
+                    // Server returned non-json response.
+                    if (error.message.includes('in JSON at position')) {
+                        throw new UnexpectedServerError(body);
+                    }
+                    throw error;
+                }
+            }
+            return response;
+        } catch (error) {
+            // When running `expo start`, but wifi or internet has issues
+            if (isNetworkError(error) || 'cause' in error && isNetworkError(error.cause)) {
+                (0, _settings.disableNetwork)();
+                throw new _errors.CommandError('OFFLINE', 'Network connection is unreliable. Try again with the environment variable `EXPO_OFFLINE=1` to skip network requests.');
+            }
+            throw error;
+        }
+    };
+}
+/**
+ * Determine if the provided error is related to a network issue.
+ * When this returns true, offline mode should be enabled.
+ *   - `ENOTFOUND` is thrown when the DNS lookup failed
+ *   - `EAI_AGAIN` is thrown when DNS lookup failed due to a server-side error
+ *   - `UND_ERR_CONNECT_TIMEOUT` is thrown after DNS is resolved, but server can't be reached
+ *
+ * @see https://nodejs.org/api/errors.html
+ * @see https://github.com/nodejs/undici#network-address-family-autoselection
+ */ function isNetworkError(error) {
+    return 'code' in error && error.code && [
+        'ENOTFOUND',
+        'EAI_AGAIN',
+        'UND_ERR_CONNECT_TIMEOUT'
+    ].includes(error.code);
+}
+const fetchWithOffline = (0, _wrapFetchWithOffline.wrapFetchWithOffline)((0, _wrapFetchWithUserAgent.wrapFetchWithUserAgent)(_fetch.fetch));
+const fetchWithBaseUrl = (0, _wrapFetchWithBaseUrl.wrapFetchWithBaseUrl)(fetchWithOffline, (0, _endpoint.getExpoApiBaseUrl)() + '/v2/');
+const fetchWithCredentials = (0, _wrapFetchWithProgress.wrapFetchWithProgress)(wrapFetchWithCredentials(fetchWithBaseUrl));
+function createCachedFetch({ fetch = fetchWithCredentials, cacheDirectory, ttl, skipCache }) {
+    // Disable all caching in EXPO_BETA.
+    if (skipCache || _env.env.EXPO_BETA || _env.env.EXPO_NO_CACHE) {
+        return fetch;
+    }
+    const { FileSystemResponseCache } = require('./cache/FileSystemResponseCache');
+    return (0, _wrapFetchWithCache.wrapFetchWithCache)(fetch, new FileSystemResponseCache({
+        cacheDirectory: _path().default.join((0, _UserSettings.getExpoHomeDirectory)(), cacheDirectory),
+        ttl
+    }));
+}
+const fetchAsync = (0, _wrapFetchWithProgress.wrapFetchWithProgress)(wrapFetchWithCredentials(fetchWithBaseUrl));
+
+//# sourceMappingURL=client.js.map

package/build/src/api/rest/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/api/rest/client.ts"],"sourcesContent":["import type { JSONValue } from '@expo/json-file';\nimport path from 'path';\n\nimport { wrapFetchWithCache } from './cache/wrapFetchWithCache';\nimport type { FetchLike } from './client.types';\nimport { wrapFetchWithBaseUrl } from './wrapFetchWithBaseUrl';\nimport { wrapFetchWithOffline } from './wrapFetchWithOffline';\nimport { wrapFetchWithProgress } from './wrapFetchWithProgress';\nimport { wrapFetchWithUserAgent } from './wrapFetchWithUserAgent';\nimport { env } from '../../utils/env';\nimport { CommandError } from '../../utils/errors';\nimport { fetch } from '../../utils/fetch';\nimport { getExpoApiBaseUrl } from '../endpoint';\nimport { disableNetwork } from '../settings';\nimport { getAccessToken, getExpoHomeDirectory, getSession } from '../user/UserSettings';\n\nexport class ApiV2Error extends Error {\n  readonly name = 'ApiV2Error';\n  readonly code: string;\n  readonly expoApiV2ErrorCode: string;\n  readonly expoApiV2ErrorDetails?: JSONValue;\n  readonly expoApiV2ErrorServerStack?: string;\n  readonly expoApiV2ErrorMetadata?: object;\n  readonly expoApiV2RequestId?: string;\n\n  constructor(response: {\n    message: string;\n    code: string;\n    stack?: string;\n    details?: JSONValue;\n    metadata?: object;\n    requestId: string;\n  }) {\n    super(response.message);\n    this.code = response.code;\n    this.expoApiV2ErrorCode = response.code;\n    this.expoApiV2ErrorDetails = response.details;\n    this.expoApiV2ErrorServerStack = response.stack;\n    this.expoApiV2ErrorMetadata = response.metadata;\n    this.expoApiV2RequestId = response.requestId;\n  }\n\n  toString() {\n    return `${super.toString()}${env.EXPO_DEBUG && this.expoApiV2RequestId ? ` (Request Id: ${this.expoApiV2RequestId})` : ''}`;\n  }\n}\n\n/**\n * An Expo server error that didn't return the expected error JSON information.\n * The only 'expected' place for this is in testing, all other cases are bugs with the server.\n */\nexport class UnexpectedServerError extends Error {\n  readonly name = 'UnexpectedServerError';\n}\n\n/**\n * An error defining that the server didn't return the expected error JSON information.\n * The only 'expected' place for this is in testing, all other cases are bugs with the client.\n */\nexport class UnexpectedServerData extends Error {\n  readonly name = 'UnexpectedServerData';\n}\n\n/** Validate the response json contains `.data` property, or throw an unexpected server data error */\nexport function getResponseDataOrThrow<T = any>(json: unknown): T {\n  if (!!json && typeof json === 'object' && 'data' in json) {\n    return json.data as T;\n  }\n\n  throw new UnexpectedServerData(\n    !!json && typeof json === 'object' ? JSON.stringify(json) : 'Unknown data received from server.'\n  );\n}\n\n/**\n * @returns a `fetch` function that will inject user authentication information and handle errors from the Expo API.\n */\nexport function wrapFetchWithCredentials(fetchFunction: FetchLike): FetchLike {\n  return async function fetchWithCredentials(url, options = {}) {\n    if (Array.isArray(options.headers)) {\n      throw new Error('request headers must be in object form');\n    }\n\n    const resolvedHeaders = options.headers ?? ({} as any);\n\n    const token = getAccessToken();\n    if (token) {\n      resolvedHeaders.authorization = `Bearer ${token}`;\n    } else {\n      const sessionSecret = getSession()?.sessionSecret;\n      if (sessionSecret) {\n        resolvedHeaders['expo-session'] = sessionSecret;\n      }\n    }\n\n    try {\n      const response = await fetchFunction(url, {\n        ...options,\n        headers: resolvedHeaders,\n      });\n\n      // Handle expected API errors (4xx)\n      if (response.status >= 400 && response.status < 500) {\n        const body = await response.text();\n        try {\n          const data = JSON.parse(body);\n          if (data?.errors?.length) {\n            throw new ApiV2Error(data.errors[0]);\n          }\n        } catch (error: any) {\n          // Server returned non-json response.\n          if (error.message.includes('in JSON at position')) {\n            throw new UnexpectedServerError(body);\n          }\n          throw error;\n        }\n      }\n\n      return response;\n    } catch (error: any) {\n      // When running `expo start`, but wifi or internet has issues\n      if (isNetworkError(error) || ('cause' in error && isNetworkError(error.cause))) {\n        disableNetwork();\n\n        throw new CommandError(\n          'OFFLINE',\n          'Network connection is unreliable. Try again with the environment variable `EXPO_OFFLINE=1` to skip network requests.'\n        );\n      }\n\n      throw error;\n    }\n  };\n}\n\n/**\n * Determine if the provided error is related to a network issue.\n * When this returns true, offline mode should be enabled.\n *   - `ENOTFOUND` is thrown when the DNS lookup failed\n *   - `EAI_AGAIN` is thrown when DNS lookup failed due to a server-side error\n *   - `UND_ERR_CONNECT_TIMEOUT` is thrown after DNS is resolved, but server can't be reached\n *\n * @see https://nodejs.org/api/errors.html\n * @see https://github.com/nodejs/undici#network-address-family-autoselection\n */\nfunction isNetworkError(error: Error & { code?: string }) {\n  return (\n    'code' in error &&\n    error.code &&\n    ['ENOTFOUND', 'EAI_AGAIN', 'UND_ERR_CONNECT_TIMEOUT'].includes(error.code)\n  );\n}\n\nconst fetchWithOffline = wrapFetchWithOffline(wrapFetchWithUserAgent(fetch));\n\nconst fetchWithBaseUrl = wrapFetchWithBaseUrl(fetchWithOffline, getExpoApiBaseUrl() + '/v2/');\n\nconst fetchWithCredentials = wrapFetchWithProgress(wrapFetchWithCredentials(fetchWithBaseUrl));\n\n/**\n * Create an instance of the fully qualified fetch command (auto authentication and api) but with caching in the '~/.expo' directory.\n * Caching is disabled automatically if the EXPO_NO_CACHE or EXPO_BETA environment variables are enabled.\n */\nexport function createCachedFetch({\n  fetch = fetchWithCredentials,\n  cacheDirectory,\n  ttl,\n  skipCache,\n}: {\n  fetch?: FetchLike;\n  cacheDirectory: string;\n  ttl?: number;\n  skipCache?: boolean;\n}): FetchLike {\n  // Disable all caching in EXPO_BETA.\n  if (skipCache || env.EXPO_BETA || env.EXPO_NO_CACHE) {\n    return fetch;\n  }\n\n  const { FileSystemResponseCache } =\n    require('./cache/FileSystemResponseCache') as typeof import('./cache/FileSystemResponseCache');\n\n  return wrapFetchWithCache(\n    fetch,\n    new FileSystemResponseCache({\n      cacheDirectory: path.join(getExpoHomeDirectory(), cacheDirectory),\n      ttl,\n    })\n  );\n}\n\n/** Instance of fetch with automatic base URL pointing to the Expo API, user credential injection, and API error handling. Caching not included.  */\nexport const fetchAsync = wrapFetchWithProgress(wrapFetchWithCredentials(fetchWithBaseUrl));\n"],"names":["ApiV2Error","UnexpectedServerData","UnexpectedServerError","createCachedFetch","fetchAsync","getResponseDataOrThrow","wrapFetchWithCredentials","Error","constructor","response","message","name","code","expoApiV2ErrorCode","expoApiV2ErrorDetails","details","expoApiV2ErrorServerStack","stack","expoApiV2ErrorMetadata","metadata","expoApiV2RequestId","requestId","toString","env","EXPO_DEBUG","json","data","JSON","stringify","fetchFunction","fetchWithCredentials","url","options","Array","isArray","headers","resolvedHeaders","token","getAccessToken","authorization","getSession","sessionSecret","status","body","text","parse","errors","length","error","includes","isNetworkError","cause","disableNetwork","CommandError","fetchWithOffline","wrapFetchWithOffline","wrapFetchWithUserAgent","fetch","fetchWithBaseUrl","wrapFetchWithBaseUrl","getExpoApiBaseUrl","wrapFetchWithProgress","cacheDirectory","ttl","skipCache","EXPO_BETA","EXPO_NO_CACHE","FileSystemResponseCache","require","wrapFetchWithCache","path","join","getExpoHomeDirectory"],"mappings":"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"}

package/build/src/api/rest/client.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=client.types.js.map

package/build/src/api/rest/client.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

package/build/src/api/rest/wrapFetchWithBaseUrl.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "wrapFetchWithBaseUrl", {
+    enumerable: true,
+    get: function() {
+        return wrapFetchWithBaseUrl;
+    }
+});
+function _url() {
+    const data = require("url");
+    _url = function() {
+        return data;
+    };
+    return data;
+}
+function wrapFetchWithBaseUrl(fetch, baseUrl) {
+    // NOTE(EvanBacon): DO NOT RETURN AN ASYNC WRAPPER. THIS BREAKS LOADING INDICATORS.
+    return (url, init)=>{
+        if (typeof url !== 'string') {
+            throw new TypeError('Custom fetch function only accepts a string URL as the first parameter');
+        }
+        const parsed = new (_url()).URL(url, baseUrl);
+        if (init == null ? void 0 : init.searchParams) {
+            parsed.search = init.searchParams.toString();
+        }
+        return fetch(parsed.toString(), init);
+    };
+}
+
+//# sourceMappingURL=wrapFetchWithBaseUrl.js.map