@expo/cli 55.0.4 → 55.0.6

package/build/bin/cli

@@ -123,7 +123,7 @@ const args = (0, _arg().default)({
 });
 if (args['--version']) {
     // Version is added in the build script.
-    console.log("55.0.4");
+    console.log("55.0.6");
     process.exit(0);
 }
 if (args['--non-interactive']) {

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

@@ -9,35 +9,24 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    GraphqlError: function() {
-        return _core().CombinedError;
+    UnexpectedServerData: function() {
+        return _client.UnexpectedServerData;
     },
-    graphqlClient: function() {
-        return graphqlClient;
+    UnexpectedServerError: function() {
+        return _client.UnexpectedServerError;
     },
-    withErrorHandlingAsync: function() {
-        return withErrorHandlingAsync;
+    graphql: function() {
+        return graphql;
+    },
+    query: function() {
+        return query;
     }
 });
-function _core() {
-    const data = require("@urql/core");
-    _core = function() {
-        return data;
-    };
-    return data;
-}
-function _exchangeretry() {
-    const data = require("@urql/exchange-retry");
-    _exchangeretry = function() {
-        return data;
-    };
-    return data;
-}
 const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../log"));
 const _fetch = require("../../utils/fetch");
 const _endpoint = require("../endpoint");
+const _client = require("../rest/client");
 const _wrapFetchWithOffline = require("../rest/wrapFetchWithOffline");
-const _wrapFetchWithProxy = require("../rest/wrapFetchWithProxy");
 const _wrapFetchWithUserAgent = require("../rest/wrapFetchWithUserAgent");
 const _UserSettings = require("../user/UserSettings");
 function _getRequireWildcardCache(nodeInterop) {
@@ -81,59 +70,135 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const graphqlClient = (0, _core().createClient)({
-    url: (0, _endpoint.getExpoApiBaseUrl)() + '/graphql',
-    exchanges: [
-        _core().cacheExchange,
-        (0, _exchangeretry().retryExchange)({
-            maxDelayMs: 4000,
-            retryIf: (err)=>!!(err && (err.networkError || err.graphQLErrors.some((e)=>{
-                    var _e_extensions;
-                    return e == null ? void 0 : (_e_extensions = e.extensions) == null ? void 0 : _e_extensions.isTransient;
-                })))
-        }),
-        _core().fetchExchange
-    ],
-    // @ts-ignore Type 'typeof fetch' is not assignable to type '(input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>'.
-    fetch: (0, _wrapFetchWithOffline.wrapFetchWithOffline)((0, _wrapFetchWithProxy.wrapFetchWithProxy)((0, _wrapFetchWithUserAgent.wrapFetchWithUserAgent)(_fetch.fetch))),
-    fetchOptions: ()=>{
+function graphql(query) {
+    return query.trim();
+}
+const query = (()=>{
+    const url = (0, _endpoint.getExpoApiBaseUrl)() + '/graphql';
+    let _fetch1;
+    const wrappedFetch = (...args)=>{
+        if (!_fetch1) {
+            _fetch1 = (0, _wrapFetchWithOffline.wrapFetchWithOffline)((0, _wrapFetchWithUserAgent.wrapFetchWithUserAgent)(_fetch.fetch));
+        }
+        return _fetch1(...args);
+    };
+    const randomDelay = (attemptCount)=>new Promise((resolve)=>{
+            setTimeout(resolve, Math.min(500 + Math.random() * 1000 * attemptCount, 4000));
+        });
+    const getFetchHeaders = ()=>{
         var _getSession;
         const token = (0, _UserSettings.getAccessToken)();
+        const headers = {
+            'content-type': 'application/json',
+            accept: 'application/graphql-response+json, application/graphql+json, application/json'
+        };
+        let sessionSecret;
         if (token) {
-            return {
-                headers: {
-                    authorization: `Bearer ${token}`
-                }
-            };
+            headers.authorization = `Bearer ${token}`;
+        } else if (sessionSecret = (_getSession = (0, _UserSettings.getSession)()) == null ? void 0 : _getSession.sessionSecret) {
+            headers['expo-session'] = sessionSecret;
+        }
+        return headers;
+    };
+    // NOTE(@kitten): This only sorted keys one level deep since this is sufficient for most cases
+    const stringifySorted = (variables)=>JSON.stringify(Object.keys(variables).sort().reduce((acc, key)=>{
+            acc[key] = variables[key];
+            return acc;
+        }, {}));
+    let cache = {};
+    let cacheKey;
+    function resetCache() {
+        cache = {};
+    }
+    return async function query(query, variables, options) {
+        let isTransient = false;
+        let response;
+        let data;
+        let error;
+        // Pre-instantiate headers and reset the cache if they've changed
+        const headers = {
+            ...getFetchHeaders(),
+            ...options == null ? void 0 : options.headers
+        };
+        const headersKey = stringifySorted(headers);
+        if (!cacheKey || cacheKey !== headersKey) {
+            resetCache();
         }
-        const sessionSecret = (_getSession = (0, _UserSettings.getSession)()) == null ? void 0 : _getSession.sessionSecret;
-        if (sessionSecret) {
-            return {
-                headers: {
-                    'expo-session': sessionSecret
+        // Retrieve a cached result, if we have any via a `query => variables => Result` cache key
+        const variablesKey = stringifySorted(variables);
+        const queryCache = cache[query] || (cache[query] = new Map());
+        if (queryCache.has(variablesKey)) {
+            data = queryCache.get(variablesKey);
+        }
+        // Retry the query if it fails due to an unknown or transient error
+        for(let attemptCount = 0; attemptCount < 3 && !data; attemptCount++){
+            // Add a random delay on each subsequent attempt
+            if (attemptCount > 0) {
+                await randomDelay(attemptCount);
+            }
+            try {
+                response = await wrappedFetch(url, {
+                    ...options,
+                    method: 'POST',
+                    body: JSON.stringify({
+                        query,
+                        variables
+                    }),
+                    headers
+                });
+            } catch (networkError) {
+                error = networkError || error;
+                continue;
+            }
+            const json = await response.json();
+            if (typeof json === 'object' && json) {
+                // If we have a transient error, we retry immediately and discard the data
+                // Otherwise, we store the first available error and get the data
+                if ('errors' in json && Array.isArray(json.errors)) {
+                    isTransient = json.errors.some((e)=>{
+                        var _e_extensions;
+                        return e == null ? void 0 : (_e_extensions = e.extensions) == null ? void 0 : _e_extensions.isTransient;
+                    });
+                    if (isTransient) {
+                        data = undefined;
+                        continue;
+                    } else {
+                        error = json.errors[0] || error;
+                    }
+                }
+                try {
+                    data = (0, _client.getResponseDataOrThrow)(json);
+                } catch (dataError) {
+                    // We only use the data error, if we don't have an error already
+                    if (!error) {
+                        error = dataError || error;
+                    }
+                    continue;
                 }
-            };
+            }
         }
-        return {};
-    }
-});
-async function withErrorHandlingAsync(promise) {
-    const { data, error } = await promise;
-    if (error) {
-        if (error.graphQLErrors.some((e)=>{
-            var _e_extensions;
-            return e == null ? void 0 : (_e_extensions = e.extensions) == null ? void 0 : _e_extensions.isTransient;
-        })) {
-            _log.error(`We've encountered a transient error, please try again shortly.`);
+        // Store the data in the cache, and only return a result if we have any values
+        if (data) {
+            queryCache.set(variablesKey, data);
+            const keys = Object.keys(data);
+            if (keys.length > 0 && keys.some((key)=>data[key] != null)) {
+                return data;
+            }
         }
-        throw error;
-    }
-    // Check for a malformed response. This only checks the root query's existence. It doesn't affect
-    // returning responses with an empty result set.
-    if (!data) {
-        throw new Error('Returned query result data is null!');
-    }
-    return data;
-}
+        // If we have an error, rethrow it wrapped in our custom errors
+        if (error) {
+            if (isTransient) {
+                _log.error(`We've encountered a transient error, please try again shortly.`);
+            }
+            const wrappedError = new _client.UnexpectedServerError('' + error.message);
+            wrappedError.cause = error;
+            throw wrappedError;
+        } else if (response && !response.ok) {
+            throw new _client.UnexpectedServerError(`Unexpected server error: ${response.statusText}`);
+        } else {
+            throw new _client.UnexpectedServerData('Unexpected server error: No returned query result');
+        }
+    };
+})();
 
 //# sourceMappingURL=client.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/api/graphql/client.ts"],"sourcesContent":["import {\n  cacheExchange,\n  Client,\n  CombinedError as GraphqlError,\n  AnyVariables,\n  DocumentInput,\n  createClient as createUrqlClient,\n  fetchExchange,\n  OperationContext,\n  OperationResult,\n  OperationResultSource,\n} from '@urql/core';\nimport { retryExchange } from '@urql/exchange-retry';\n\nimport * as Log from '../../log';\nimport { fetch } from '../../utils/fetch';\nimport { getExpoApiBaseUrl } from '../endpoint';\nimport { wrapFetchWithOffline } from '../rest/wrapFetchWithOffline';\nimport { wrapFetchWithProxy } from '../rest/wrapFetchWithProxy';\nimport { wrapFetchWithUserAgent } from '../rest/wrapFetchWithUserAgent';\nimport { getAccessToken, getSession } from '../user/UserSettings';\n\ntype AccessTokenHeaders = {\n  authorization: string;\n};\n\ntype SessionHeaders = {\n  'expo-session': string;\n};\n\nexport const graphqlClient = createUrqlClient({\n  url: getExpoApiBaseUrl() + '/graphql',\n  exchanges: [\n    cacheExchange,\n    retryExchange({\n      maxDelayMs: 4000,\n      retryIf: (err) =>\n        !!(err && (err.networkError || err.graphQLErrors.some((e) => e?.extensions?.isTransient))),\n    }),\n    fetchExchange,\n  ],\n  // @ts-ignore Type 'typeof fetch' is not assignable to type '(input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>'.\n  fetch: wrapFetchWithOffline(wrapFetchWithProxy(wrapFetchWithUserAgent(fetch))),\n  fetchOptions: (): { headers?: AccessTokenHeaders | SessionHeaders } => {\n    const token = getAccessToken();\n    if (token) {\n      return {\n        headers: {\n          authorization: `Bearer ${token}`,\n        },\n      };\n    }\n    const sessionSecret = getSession()?.sessionSecret;\n    if (sessionSecret) {\n      return {\n        headers: {\n          'expo-session': sessionSecret,\n        },\n      };\n    }\n    return {};\n  },\n}) as StricterClient;\n\n/* Please specify additionalTypenames in your Graphql queries */\nexport interface StricterClient extends Client {\n  query<Data = any, Variables extends AnyVariables = AnyVariables>(\n    query: DocumentInput<Data, Variables>,\n    variables: Variables,\n    context: Partial<OperationContext> & { additionalTypenames: string[] }\n  ): OperationResultSource<OperationResult<Data, Variables>>;\n}\n\nexport async function withErrorHandlingAsync<T>(promise: Promise<OperationResult<T>>): Promise<T> {\n  const { data, error } = await promise;\n\n  if (error) {\n    if (error.graphQLErrors.some((e) => e?.extensions?.isTransient)) {\n      Log.error(`We've encountered a transient error, please try again shortly.`);\n    }\n    throw error;\n  }\n\n  // Check for a malformed response. This only checks the root query's existence. It doesn't affect\n  // returning responses with an empty result set.\n  if (!data) {\n    throw new Error('Returned query result data is null!');\n  }\n\n  return data;\n}\n\nexport { GraphqlError };\n"],"names":["GraphqlError","graphqlClient","withErrorHandlingAsync","createUrqlClient","url","getExpoApiBaseUrl","exchanges","cacheExchange","retryExchange","maxDelayMs","retryIf","err","networkError","graphQLErrors","some","e","extensions","isTransient","fetchExchange","fetch","wrapFetchWithOffline","wrapFetchWithProxy","wrapFetchWithUserAgent","fetchOptions","getSession","token","getAccessToken","headers","authorization","sessionSecret","promise","data","error","Log","Error"],"mappings":";;;;;;;;;;;IA4FSA,YAAY;eAAZA,qBAAY;;IA9DRC,aAAa;eAAbA;;IA2CSC,sBAAsB;eAAtBA;;;;yBA9Df;;;;;;;yBACuB;;;;;;6DAET;uBACC;0BACY;sCACG;oCACF;wCACI;8BACI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUpC,MAAMD,gBAAgBE,IAAAA,oBAAgB,EAAC;IAC5CC,KAAKC,IAAAA,2BAAiB,MAAK;IAC3BC,WAAW;QACTC,qBAAa;QACbC,IAAAA,8BAAa,EAAC;YACZC,YAAY;YACZC,SAAS,CAACC,MACR,CAAC,CAAEA,CAAAA,OAAQA,CAAAA,IAAIC,YAAY,IAAID,IAAIE,aAAa,CAACC,IAAI,CAAC,CAACC;wBAAMA;2BAAAA,sBAAAA,gBAAAA,EAAGC,UAAU,qBAAbD,cAAeE,WAAW;kBAAA,CAAC;QAC5F;QACAC,qBAAa;KACd;IACD,wIAAwI;IACxIC,OAAOC,IAAAA,0CAAoB,EAACC,IAAAA,sCAAkB,EAACC,IAAAA,8CAAsB,EAACH,YAAK;IAC3EI,cAAc;YASUC;QARtB,MAAMC,QAAQC,IAAAA,4BAAc;QAC5B,IAAID,OAAO;YACT,OAAO;gBACLE,SAAS;oBACPC,eAAe,CAAC,OAAO,EAAEH,OAAO;gBAClC;YACF;QACF;QACA,MAAMI,iBAAgBL,cAAAA,IAAAA,wBAAU,wBAAVA,YAAcK,aAAa;QACjD,IAAIA,eAAe;YACjB,OAAO;gBACLF,SAAS;oBACP,gBAAgBE;gBAClB;YACF;QACF;QACA,OAAO,CAAC;IACV;AACF;AAWO,eAAe3B,uBAA0B4B,OAAoC;IAClF,MAAM,EAAEC,IAAI,EAAEC,KAAK,EAAE,GAAG,MAAMF;IAE9B,IAAIE,OAAO;QACT,IAAIA,MAAMnB,aAAa,CAACC,IAAI,CAAC,CAACC;gBAAMA;mBAAAA,sBAAAA,gBAAAA,EAAGC,UAAU,qBAAbD,cAAeE,WAAW;YAAG;YAC/DgB,KAAID,KAAK,CAAC,CAAC,8DAA8D,CAAC;QAC5E;QACA,MAAMA;IACR;IAEA,iGAAiG;IACjG,gDAAgD;IAChD,IAAI,CAACD,MAAM;QACT,MAAM,IAAIG,MAAM;IAClB;IAEA,OAAOH;AACT"}
+{"version":3,"sources":["../../../../src/api/graphql/client.ts"],"sourcesContent":["import * as Log from '../../log';\nimport { fetch, type Response } from '../../utils/fetch';\nimport { getExpoApiBaseUrl } from '../endpoint';\nimport {\n  getResponseDataOrThrow,\n  UnexpectedServerData,\n  UnexpectedServerError,\n} from '../rest/client';\nimport { FetchLike } from '../rest/client.types';\nimport { wrapFetchWithOffline } from '../rest/wrapFetchWithOffline';\nimport { wrapFetchWithUserAgent } from '../rest/wrapFetchWithUserAgent';\nimport { getAccessToken, getSession } from '../user/UserSettings';\n\ntype JSONObject = Record<string, unknown>;\ntype EmptyVariables = Record<string, never>;\n\nexport type StaticDocumentNode<Result extends JSONObject, Variables extends JSONObject> = string & {\n  readonly __graphql: (vars: Variables) => Result;\n};\n\nexport function graphql<Result extends JSONObject, Variables extends JSONObject = EmptyVariables>(\n  query: string\n): StaticDocumentNode<Result, Variables> {\n  return query.trim() as StaticDocumentNode<Result, Variables>;\n}\n\nexport { UnexpectedServerError, UnexpectedServerData };\n\nexport interface QueryOptions {\n  headers?: Record<string, string>;\n}\n\nexport const query = (() => {\n  const url = getExpoApiBaseUrl() + '/graphql';\n\n  let _fetch: FetchLike | undefined;\n  const wrappedFetch: FetchLike = (...args) => {\n    if (!_fetch) {\n      _fetch = wrapFetchWithOffline(wrapFetchWithUserAgent(fetch));\n    }\n    return _fetch(...args);\n  };\n\n  const randomDelay = (attemptCount: number) =>\n    new Promise((resolve) => {\n      setTimeout(resolve, Math.min(500 + Math.random() * 1000 * attemptCount, 4_000));\n    });\n\n  const getFetchHeaders = (): Record<string, string> => {\n    const token = getAccessToken();\n    const headers: Record<string, string> = {\n      'content-type': 'application/json',\n      accept: 'application/graphql-response+json, application/graphql+json, application/json',\n    };\n    let sessionSecret: string | undefined;\n    if (token) {\n      headers.authorization = `Bearer ${token}`;\n    } else if ((sessionSecret = getSession()?.sessionSecret)) {\n      headers['expo-session'] = sessionSecret;\n    }\n    return headers;\n  };\n\n  // NOTE(@kitten): This only sorted keys one level deep since this is sufficient for most cases\n  const stringifySorted = (variables: JSONObject): string =>\n    JSON.stringify(\n      Object.keys(variables)\n        .sort()\n        .reduce((acc, key) => {\n          acc[key] = variables[key];\n          return acc;\n        }, {} as JSONObject)\n    );\n\n  let cache: Record<string, Map<string, unknown>> = {};\n  let cacheKey: string | undefined;\n\n  function resetCache() {\n    cache = {};\n  }\n\n  return async function query<Result extends JSONObject, Variables extends JSONObject>(\n    query: StaticDocumentNode<Result, Variables>,\n    variables: Variables,\n    options?: QueryOptions\n  ): Promise<Result> {\n    let isTransient = false;\n    let response: Response | undefined;\n    let data: Result | null | undefined;\n    let error: unknown;\n\n    // Pre-instantiate headers and reset the cache if they've changed\n    const headers = { ...getFetchHeaders(), ...options?.headers };\n    const headersKey = stringifySorted(headers);\n    if (!cacheKey || cacheKey !== headersKey) {\n      resetCache();\n    }\n\n    // Retrieve a cached result, if we have any via a `query => variables => Result` cache key\n    const variablesKey = stringifySorted(variables);\n    const queryCache = cache[query] || (cache[query] = new Map());\n    if (queryCache.has(variablesKey)) {\n      data = queryCache.get(variablesKey) as Result;\n    }\n\n    // Retry the query if it fails due to an unknown or transient error\n    for (let attemptCount = 0; attemptCount < 3 && !data; attemptCount++) {\n      // Add a random delay on each subsequent attempt\n      if (attemptCount > 0) {\n        await randomDelay(attemptCount);\n      }\n\n      try {\n        response = await wrappedFetch(url, {\n          ...options,\n          method: 'POST',\n          body: JSON.stringify({ query, variables }),\n          headers,\n        });\n      } catch (networkError) {\n        error = networkError || error;\n        continue;\n      }\n\n      const json = await response.json();\n      if (typeof json === 'object' && json) {\n        // If we have a transient error, we retry immediately and discard the data\n        // Otherwise, we store the first available error and get the data\n        if ('errors' in json && Array.isArray(json.errors)) {\n          isTransient = json.errors.some((e: any) => e?.extensions?.isTransient);\n          if (isTransient) {\n            data = undefined;\n            continue;\n          } else {\n            error = json.errors[0] || error;\n          }\n        }\n\n        try {\n          data = getResponseDataOrThrow<Result | null>(json);\n        } catch (dataError) {\n          // We only use the data error, if we don't have an error already\n          if (!error) {\n            error = dataError || error;\n          }\n          continue;\n        }\n      }\n    }\n\n    // Store the data in the cache, and only return a result if we have any values\n    if (data) {\n      queryCache.set(variablesKey, data);\n      const keys = Object.keys(data);\n      if (keys.length > 0 && keys.some((key) => data[key as keyof typeof data] != null)) {\n        return data;\n      }\n    }\n\n    // If we have an error, rethrow it wrapped in our custom errors\n    if (error) {\n      if (isTransient) {\n        Log.error(`We've encountered a transient error, please try again shortly.`);\n      }\n      const wrappedError = new UnexpectedServerError('' + (error as any).message);\n      wrappedError.cause = error;\n      throw wrappedError;\n    } else if (response && !response.ok) {\n      throw new UnexpectedServerError(`Unexpected server error: ${response.statusText}`);\n    } else {\n      throw new UnexpectedServerData('Unexpected server error: No returned query result');\n    }\n  };\n})();\n"],"names":["UnexpectedServerData","UnexpectedServerError","graphql","query","trim","url","getExpoApiBaseUrl","_fetch","wrappedFetch","args","wrapFetchWithOffline","wrapFetchWithUserAgent","fetch","randomDelay","attemptCount","Promise","resolve","setTimeout","Math","min","random","getFetchHeaders","getSession","token","getAccessToken","headers","accept","sessionSecret","authorization","stringifySorted","variables","JSON","stringify","Object","keys","sort","reduce","acc","key","cache","cacheKey","resetCache","options","isTransient","response","data","error","headersKey","variablesKey","queryCache","Map","has","get","method","body","networkError","json","Array","isArray","errors","some","e","extensions","undefined","getResponseDataOrThrow","dataError","set","length","Log","wrappedError","message","cause","ok","statusText"],"mappings":"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"}

package/build/src/api/graphql/queries/AppQuery.js

@@ -8,35 +8,31 @@ Object.defineProperty(exports, "AppQuery", {
         return AppQuery;
     }
 });
-function _core() {
-    const data = require("@urql/core");
-    _core = function() {
-        return data;
-    };
-    return data;
-}
 const _client = require("../client");
-const _App = require("../types/App");
+const AppQueryDocument = (0, _client.graphql)(`
+  query AppByIdQuery($appId: String!) {
+    app {
+      byId(appId: $appId) {
+        id
+        ...AppFragment
+      }
+    }
+  }
+
+  fragment AppFragment on App {
+    id
+    scopeKey
+    ownerAccount {
+      id
+      name
+    }
+  }
+`);
 const AppQuery = {
     async byIdAsync (projectId) {
-        const data = await (0, _client.withErrorHandlingAsync)(_client.graphqlClient.query((0, _core().gql)`
-            query AppByIdQuery($appId: String!) {
-              app {
-                byId(appId: $appId) {
-                  id
-                  ...AppFragment
-                }
-              }
-            }
-
-            ${_App.AppFragmentNode}
-          `, {
+        const data = await (0, _client.query)(AppQueryDocument, {
             appId: projectId
-        }, {
-            additionalTypenames: [
-                'App'
-            ]
-        }).toPromise());
+        });
         return data.app.byId;
     }
 };

package/build/src/api/graphql/queries/AppQuery.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/api/graphql/queries/AppQuery.ts"],"sourcesContent":["import { gql } from '@urql/core';\n\nimport { AppByIdQuery } from '../../../graphql/generated';\nimport { graphqlClient, withErrorHandlingAsync } from '../client';\nimport { AppFragmentNode } from '../types/App';\n\nexport const AppQuery = {\n  async byIdAsync(projectId: string): Promise<AppByIdQuery['app']['byId']> {\n    const data = await withErrorHandlingAsync(\n      graphqlClient\n        .query<AppByIdQuery>(\n          gql`\n            query AppByIdQuery($appId: String!) {\n              app {\n                byId(appId: $appId) {\n                  id\n                  ...AppFragment\n                }\n              }\n            }\n\n            ${AppFragmentNode}\n          `,\n          { appId: projectId },\n          {\n            additionalTypenames: ['App'],\n          }\n        )\n        .toPromise()\n    );\n    return data.app.byId;\n  },\n};\n"],"names":["AppQuery","byIdAsync","projectId","data","withErrorHandlingAsync","graphqlClient","query","gql","AppFragmentNode","appId","additionalTypenames","toPromise","app","byId"],"mappings":";;;;+BAMaA;;;eAAAA;;;;yBANO;;;;;;wBAGkC;qBACtB;AAEzB,MAAMA,WAAW;IACtB,MAAMC,WAAUC,SAAiB;QAC/B,MAAMC,OAAO,MAAMC,IAAAA,8BAAsB,EACvCC,qBAAa,CACVC,KAAK,CACJC,IAAAA,WAAG,CAAA,CAAC;;;;;;;;;;YAUF,EAAEC,oBAAe,CAAC;UACpB,CAAC,EACD;YAAEC,OAAOP;QAAU,GACnB;YACEQ,qBAAqB;gBAAC;aAAM;QAC9B,GAEDC,SAAS;QAEd,OAAOR,KAAKS,GAAG,CAACC,IAAI;IACtB;AACF"}
+{"version":3,"sources":["../../../../../src/api/graphql/queries/AppQuery.ts"],"sourcesContent":["import { graphql, query } from '../client';\n\nexport type App = {\n  id: string;\n  scopeKey: string;\n  ownerAccount: {\n    id: string;\n    name: string;\n  };\n};\n\ntype AppQueryData = {\n  app: {\n    byId: App;\n  };\n};\n\ntype AppQueryVariables = {\n  appId: string;\n};\n\nconst AppQueryDocument = graphql<AppQueryData, AppQueryVariables>(`\n  query AppByIdQuery($appId: String!) {\n    app {\n      byId(appId: $appId) {\n        id\n        ...AppFragment\n      }\n    }\n  }\n\n  fragment AppFragment on App {\n    id\n    scopeKey\n    ownerAccount {\n      id\n      name\n    }\n  }\n`);\n\nexport const AppQuery = {\n  async byIdAsync(projectId: string): Promise<AppQueryData['app']['byId']> {\n    const data = await query(AppQueryDocument, { appId: projectId });\n    return data.app.byId;\n  },\n};\n"],"names":["AppQuery","AppQueryDocument","graphql","byIdAsync","projectId","data","query","appId","app","byId"],"mappings":";;;;+BAyCaA;;;eAAAA;;;wBAzCkB;AAqB/B,MAAMC,mBAAmBC,IAAAA,eAAO,EAAkC,CAAC;;;;;;;;;;;;;;;;;;AAkBnE,CAAC;AAEM,MAAMF,WAAW;IACtB,MAAMG,WAAUC,SAAiB;QAC/B,MAAMC,OAAO,MAAMC,IAAAA,aAAK,EAACL,kBAAkB;YAAEM,OAAOH;QAAU;QAC9D,OAAOC,KAAKG,GAAG,CAACC,IAAI;IACtB;AACF"}

package/build/src/api/graphql/queries/UserQuery.js

@@ -8,48 +8,55 @@ Object.defineProperty(exports, "UserQuery", {
         return UserQuery;
     }
 });
-function _core() {
-    const data = require("@urql/core");
-    _core = function() {
-        return data;
-    };
-    return data;
-}
 const _client = require("../client");
+const CurrentUserDocument = (0, _client.graphql)(`
+  query CurrentUser {
+    meActor {
+      __typename
+      id
+      ... on UserActor {
+        primaryAccount {
+          id
+        }
+        username
+      }
+      ... on Robot {
+        firstName
+      }
+      accounts {
+        id
+        users {
+          actor {
+            __typename
+            id
+          }
+          permissions
+        }
+      }
+    }
+  }
+`);
+const UserQueryDocument = (0, _client.graphql)(`
+  query UserQuery {
+    meUserActor {
+      id
+      username
+    }
+  }
+`);
 const UserQuery = {
     async currentUserAsync () {
-        const data = await (0, _client.withErrorHandlingAsync)(_client.graphqlClient.query((0, _core().gql)`
-            query CurrentUser {
-              meActor {
-                __typename
-                id
-                ... on UserActor {
-                  primaryAccount {
-                    id
-                  }
-                  username
-                }
-                ... on Robot {
-                  firstName
-                }
-                accounts {
-                  id
-                  users {
-                    actor {
-                      id
-                    }
-                    permissions
-                  }
-                }
-              }
-            }
-          `, /* variables */ undefined, {
-            additionalTypenames: [
-                'User',
-                'SSOUser'
-            ]
-        }).toPromise());
+        const data = await (0, _client.query)(CurrentUserDocument, {});
         return data.meActor;
+    },
+    async meUserActorAsync (headers) {
+        const data = await (0, _client.query)(UserQueryDocument, {}, {
+            headers
+        });
+        return {
+            id: data.meUserActor.id,
+            username: data.meUserActor.username
+        };
     }
 };
 

package/build/src/api/graphql/queries/UserQuery.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/api/graphql/queries/UserQuery.ts"],"sourcesContent":["import { gql } from '@urql/core';\n\nimport { CurrentUserQuery } from '../../../graphql/generated';\nimport { graphqlClient, withErrorHandlingAsync } from '../client';\n\nexport const UserQuery = {\n  async currentUserAsync(): Promise<CurrentUserQuery['meActor']> {\n    const data = await withErrorHandlingAsync(\n      graphqlClient\n        .query<CurrentUserQuery>(\n          gql`\n            query CurrentUser {\n              meActor {\n                __typename\n                id\n                ... on UserActor {\n                  primaryAccount {\n                    id\n                  }\n                  username\n                }\n                ... on Robot {\n                  firstName\n                }\n                accounts {\n                  id\n                  users {\n                    actor {\n                      id\n                    }\n                    permissions\n                  }\n                }\n              }\n            }\n          `,\n          /* variables */ undefined,\n          {\n            additionalTypenames: ['User', 'SSOUser'],\n          }\n        )\n        .toPromise()\n    );\n\n    return data.meActor;\n  },\n};\n"],"names":["UserQuery","currentUserAsync","data","withErrorHandlingAsync","graphqlClient","query","gql","undefined","additionalTypenames","toPromise","meActor"],"mappings":";;;;+BAKaA;;;eAAAA;;;;yBALO;;;;;;wBAGkC;AAE/C,MAAMA,YAAY;IACvB,MAAMC;QACJ,MAAMC,OAAO,MAAMC,IAAAA,8BAAsB,EACvCC,qBAAa,CACVC,KAAK,CACJC,IAAAA,WAAG,CAAA,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;UAyBJ,CAAC,EACD,aAAa,GAAGC,WAChB;YACEC,qBAAqB;gBAAC;gBAAQ;aAAU;QAC1C,GAEDC,SAAS;QAGd,OAAOP,KAAKQ,OAAO;IACrB;AACF"}
+{"version":3,"sources":["../../../../../src/api/graphql/queries/UserQuery.ts"],"sourcesContent":["import { graphql, query } from '../client';\n\nexport type Permission = 'ADMIN' | 'OWN' | 'PUBLISH' | 'VIEW';\n\ntype CurrentUserDataUser = {\n  permissions: Permission[];\n  actor: {\n    __typename: 'Robot' | 'SSOUser' | 'User';\n    id: string;\n  };\n};\n\ntype CurrentUserDataAccount = {\n  __typename?: 'Account';\n  id: string;\n  users: CurrentUserDataUser[];\n};\n\nexport type Actor =\n  | {\n      __typename: 'Robot';\n      firstName?: string | null;\n      id: string;\n      accounts: CurrentUserDataAccount[];\n    }\n  | {\n      __typename: 'SSOUser' | 'User';\n      id: string;\n      username: string;\n      primaryAccount: {\n        id: string;\n      };\n      accounts: CurrentUserDataAccount[];\n    };\n\ntype CurrentUserData = {\n  meActor: Actor | null;\n};\n\nconst CurrentUserDocument = graphql<CurrentUserData>(`\n  query CurrentUser {\n    meActor {\n      __typename\n      id\n      ... on UserActor {\n        primaryAccount {\n          id\n        }\n        username\n      }\n      ... on Robot {\n        firstName\n      }\n      accounts {\n        id\n        users {\n          actor {\n            __typename\n            id\n          }\n          permissions\n        }\n      }\n    }\n  }\n`);\n\ntype UserQueryData = {\n  meUserActor: {\n    id: string;\n    username: string;\n  };\n};\n\nconst UserQueryDocument = graphql<UserQueryData>(`\n  query UserQuery {\n    meUserActor {\n      id\n      username\n    }\n  }\n`);\n\nexport const UserQuery = {\n  async currentUserAsync() {\n    const data = await query(CurrentUserDocument, {});\n    return data.meActor;\n  },\n  async meUserActorAsync(headers: Record<string, string>) {\n    const data = await query(UserQueryDocument, {}, { headers });\n    return {\n      id: data.meUserActor.id,\n      username: data.meUserActor.username,\n    };\n  },\n};\n"],"names":["UserQuery","CurrentUserDocument","graphql","UserQueryDocument","currentUserAsync","data","query","meActor","meUserActorAsync","headers","id","meUserActor","username"],"mappings":";;;;+BAmFaA;;;eAAAA;;;wBAnFkB;AAuC/B,MAAMC,sBAAsBC,IAAAA,eAAO,EAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BtD,CAAC;AASD,MAAMC,oBAAoBD,IAAAA,eAAO,EAAgB,CAAC;;;;;;;AAOlD,CAAC;AAEM,MAAMF,YAAY;IACvB,MAAMI;QACJ,MAAMC,OAAO,MAAMC,IAAAA,aAAK,EAACL,qBAAqB,CAAC;QAC/C,OAAOI,KAAKE,OAAO;IACrB;IACA,MAAMC,kBAAiBC,OAA+B;QACpD,MAAMJ,OAAO,MAAMC,IAAAA,aAAK,EAACH,mBAAmB,CAAC,GAAG;YAAEM;QAAQ;QAC1D,OAAO;YACLC,IAAIL,KAAKM,WAAW,CAACD,EAAE;YACvBE,UAAUP,KAAKM,WAAW,CAACC,QAAQ;QACrC;IACF;AACF"}

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

@@ -1 +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,\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);\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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"}
+{"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.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/api/rest/cache/ResponseCache.ts"],"sourcesContent":["import crypto from 'crypto';\nimport { ReadStream } from 'fs';\nimport type { Response, RequestInfo, RequestInit } from 'undici';\n\nconst GLOBAL_CACHE_VERSION = 4;\n\nexport type ResponseCacheEntry = {\n  body: import('stream/web').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;;;;;;;yBACQ;;;;;;;;;;;AAG3B,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"}
+{"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

@@ -8,28 +8,28 @@ Object.defineProperty(exports, "wrapFetchWithCache", {
         return wrapFetchWithCache;
     }
 });
-function _undici() {
-    const data = require("undici");
-    _undici = function() {
+function _fetchnodeshim() {
+    const data = require("fetch-nodeshim");
+    _fetchnodeshim = function() {
         return data;
     };
     return data;
 }
 const _ResponseCache = require("./ResponseCache");
-const debug = require('debug')('expo:undici-cache');
+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 (_undici()).Response(cachedResponse.body, cachedResponse.info);
+            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 (_undici()).Response(cachedResponse.body, cachedResponse.info);
+                return new (_fetchnodeshim()).Response(cachedResponse.body, cachedResponse.info);
             }
             // Execute the fetch request
             const response = await fetch(url, init);
@@ -48,7 +48,7 @@ function wrapFetchWithCache(fetch, cache) {
                 return response;
             }
             // Return the cached response
-            return new (_undici()).Response(cachedResponse.body, cachedResponse.info);
+            return new (_fetchnodeshim()).Response(cachedResponse.body, cachedResponse.info);
         } finally{
             unlock(cacheKey);
         }

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../../src/api/rest/cache/wrapFetchWithCache.ts"],"sourcesContent":["import { Response, type RequestInfo, type RequestInit } from 'undici';\n\nimport { getRequestCacheKey, getResponseInfo, type ResponseCache } from './ResponseCache';\nimport type { FetchLike } from '../client.types';\n\nconst debug = require('debug')('expo:undici-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,SAAO,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,SAAO,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,SAAO,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"}
+{"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"}