@data-client/core
Version:
Async State Management without the Management. REST, GraphQL, SSE, Websockets, Fetch
267 lines (255 loc) • 31.6 kB
JavaScript
import { SET_RESPONSE, FETCH, RESET } from '../actionTypes.js';
import { createSetResponse } from '../controller/actions/index.js';
import Controller from '../controller/Controller.js';
export class ResetError extends Error {
constructor() {
super('Aborted due to RESET');
this.name = 'ResetError';
}
}
/** Handles all async network dispatches
*
* Dedupes concurrent requests by keeping track of all fetches in flight
* and returning existing promises for requests already in flight.
*
* Interfaces with store via a redux-compatible middleware.
*
* @see https://dataclient.io/docs/api/NetworkManager
*/
export default class NetworkManager {
constructor({
dataExpiryLength = 60000,
errorExpiryLength = 1000
} = {}) {
this.fetching = new Map();
this.controller = new Controller();
this.middleware = controller => {
this.controller = controller;
return next => action => {
switch (action.type) {
case FETCH:
this.handleFetch(action);
// This is the only case that causes any state change
// It's important to intercept other fetches as we don't want to trigger reducers during
// render - so we need to stop 'readonly' fetches which can be triggered in render
if (action.endpoint.getOptimisticResponse !== undefined && action.endpoint.sideEffect) {
return next(action);
}
return Promise.resolve();
case SET_RESPONSE:
// only set after new state is computed
return next(action).then(() => {
if (this.fetching.has(action.key)) {
var _controller$getState$;
// Note: meta *must* be set by reducer so this should be safe
const error = (_controller$getState$ = controller.getState().meta[action.key]) == null ? void 0 : _controller$getState$.error;
// processing errors result in state meta having error, so we should reject the promise
if (error) {
this.handleSet(createSetResponse(action.endpoint, {
args: action.args,
response: error,
fetchedAt: action.meta.fetchedAt,
error: true
}));
} else {
this.handleSet(action);
}
}
});
case RESET:
{
// take snapshot of rejectors at this point in time
// we must use Array.from since iteration does not freeze state at this point in time
const fetches = Array.from(this.fetching.values());
this.clearAll();
return next(action).then(() => {
// there could be external listeners to the promise
// this must happen after commit so our own rejector knows not to dispatch an error based on this
for (const {
reject
} of fetches) {
reject(new ResetError());
}
});
}
default:
return next(action);
}
};
};
this.dataExpiryLength = dataExpiryLength;
this.errorExpiryLength = errorExpiryLength;
}
/** On mount */
init() {
delete this.cleanupDate;
}
/** Ensures all promises are completed by rejecting remaining. */
cleanup() {
// ensure no dispatches after unmount
// this must be reversible (done in init) so useEffect() remains symmetric
this.cleanupDate = Date.now();
}
/** Used by DevtoolsManager to determine whether to log an action */
skipLogging(action) {
/* istanbul ignore next */
return action.type === FETCH && this.fetching.has(action.key);
}
allSettled() {
if (this.fetching.size) return Promise.allSettled(this.fetching.values().map(({
promise
}) => promise));
}
/** Clear all promise state */
clearAll() {
for (const k of this.fetching.keys()) {
this.clear(k);
}
}
/** Clear promise state for a given key */
clear(key) {
if (this.fetching.has(key)) {
this.fetching.get(key).promise.catch(() => {});
this.fetching.delete(key);
}
}
getLastReset() {
if (this.cleanupDate) return this.cleanupDate;
return this.controller.getState().lastReset;
}
/** Called when middleware intercepts 'rdc/fetch' action.
*
* Will then start a promise for a key and potentially start the network
* fetch.
*
* Uses throttle endpoints without sideEffects. This is valuable
* for ensures mutation requests always go through.
*/
handleFetch(action) {
const {
resolve,
reject,
fetchedAt
} = action.meta;
const throttle = !action.endpoint.sideEffect;
const deferedFetch = () => {
let promise = action.endpoint(...action.args);
const resolvePromise = promise => promise.then(data => {
resolve(data);
return data;
}).catch(error => {
reject(error);
throw error;
});
// schedule non-throttled resolutions in a microtask before set
// this enables users awaiting their fetch to trigger any react updates needed to deal
// with upcoming changes because of the fetch (for instance avoiding suspense if something is deleted)
if (!throttle) {
promise = resolvePromise(promise);
}
promise = promise.then(response => {
let lastReset = this.getLastReset();
/* istanbul ignore else */
if (process.env.NODE_ENV !== 'production' && isNaN(lastReset)) {
console.error('state.lastReset is NaN. Only positive timestamps are valid.');
lastReset = 0;
}
// don't update state with promises started before last clear
if (fetchedAt >= lastReset) {
this.controller.resolve(action.endpoint, {
args: action.args,
response,
fetchedAt
});
}
return response;
}).catch(error => {
const lastReset = this.getLastReset();
// don't update state with promises started before last clear
if (fetchedAt >= lastReset) {
this.controller.resolve(action.endpoint, {
args: action.args,
response: error,
fetchedAt,
error: true
});
}
throw error;
});
return promise;
};
if (throttle) {
return this.throttle(action.key, deferedFetch, fetchedAt).then(data => resolve(data)).catch(error => reject(error));
} else {
return deferedFetch().catch(() => {});
}
}
/** Called when middleware intercepts a set action.
*
* Will resolve the promise associated with set key.
*/
handleSet(action) {
// this can still turn out to be untrue since this is async
if (this.fetching.has(action.key)) {
const {
reject,
resolve
} = this.fetching.get(action.key);
if (action.error) {
reject(action.response);
} else {
resolve(action.response);
}
// since we're resolved we no longer need to keep track of this promise
this.clear(action.key);
}
}
/** Ensures only one request for a given key is in flight at any time
*
* Uses key to either retrieve in-flight promise, or if not
* create a new promise and call fetch.
*
* Note: The new promise is not actually tied to fetch at all,
* but is resolved when the expected 'receive' action is processed.
* This ensures promises are resolved only once their data is processed
* by the reducer.
*/
throttle(key, fetch, fetchedAt) {
const lastReset = this.getLastReset();
let fetchMeta = this.fetching.get(key);
// we're already fetching so reuse the promise
// fetches after reset do not count
if (fetchMeta && fetchMeta.fetchedAt > lastReset) {
return fetchMeta.promise;
}
fetchMeta = newFetchMeta(fetchedAt);
this.fetching.set(key, fetchMeta);
this.idleCallback(() => {
// since our real promise is resolved via the wrapReducer(),
// we should just stop all errors here.
// TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)
fetch().catch(() => null);
}, {
timeout: 500
});
return fetchMeta.promise;
}
/** Calls the callback when client is not 'busy' with high priority interaction tasks
*
* Override for platform-specific implementations
*/
idleCallback(callback, options) {
callback();
}
}
function newFetchMeta(fetchedAt) {
const fetchMeta = {
fetchedAt
};
fetchMeta.promise = new Promise((resolve, reject) => {
fetchMeta.resolve = resolve;
fetchMeta.reject = reject;
});
return fetchMeta;
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SET_RESPONSE","FETCH","RESET","createSetResponse","Controller","ResetError","Error","constructor","name","NetworkManager","dataExpiryLength","errorExpiryLength","fetching","Map","controller","middleware","next","action","type","handleFetch","endpoint","getOptimisticResponse","undefined","sideEffect","Promise","resolve","then","has","key","_controller$getState$","error","getState","meta","handleSet","args","response","fetchedAt","fetches","Array","from","values","clearAll","reject","init","cleanupDate","cleanup","Date","now","skipLogging","allSettled","size","map","promise","k","keys","clear","get","catch","delete","getLastReset","lastReset","throttle","deferedFetch","resolvePromise","data","process","env","NODE_ENV","isNaN","console","fetch","fetchMeta","newFetchMeta","set","idleCallback","timeout","callback","options"],"sources":["../../src/manager/NetworkManager.ts"],"sourcesContent":["import { SET_RESPONSE, FETCH, RESET } from '../actionTypes.js';\nimport { createSetResponse } from '../controller/actions/index.js';\nimport Controller from '../controller/Controller.js';\nimport type {\n  FetchAction,\n  Manager,\n  ActionTypes,\n  Middleware,\n  SetResponseAction,\n} from '../types.js';\n\nexport class ResetError extends Error {\n  name = 'ResetError';\n\n  constructor() {\n    super('Aborted due to RESET');\n  }\n}\n\nexport interface FetchingMeta {\n  promise: Promise<any>;\n  resolve: (value?: any) => void;\n  reject: (value?: any) => void;\n  fetchedAt: number;\n}\n\n/** Handles all async network dispatches\n *\n * Dedupes concurrent requests by keeping track of all fetches in flight\n * and returning existing promises for requests already in flight.\n *\n * Interfaces with store via a redux-compatible middleware.\n *\n * @see https://dataclient.io/docs/api/NetworkManager\n */\nexport default class NetworkManager implements Manager {\n  protected fetching: Map<string, FetchingMeta> = new Map();\n  declare readonly dataExpiryLength: number;\n  declare readonly errorExpiryLength: number;\n  protected controller: Controller = new Controller();\n  declare cleanupDate?: number;\n\n  constructor({ dataExpiryLength = 60000, errorExpiryLength = 1000 } = {}) {\n    this.dataExpiryLength = dataExpiryLength;\n    this.errorExpiryLength = errorExpiryLength;\n  }\n\n  middleware: Middleware = controller => {\n    this.controller = controller;\n    return next => action => {\n      switch (action.type) {\n        case FETCH:\n          this.handleFetch(action);\n          // This is the only case that causes any state change\n          // It's important to intercept other fetches as we don't want to trigger reducers during\n          // render - so we need to stop 'readonly' fetches which can be triggered in render\n          if (\n            action.endpoint.getOptimisticResponse !== undefined &&\n            action.endpoint.sideEffect\n          ) {\n            return next(action);\n          }\n          return Promise.resolve();\n        case SET_RESPONSE:\n          // only set after new state is computed\n          return next(action).then(() => {\n            if (this.fetching.has(action.key)) {\n              // Note: meta *must* be set by reducer so this should be safe\n              const error = controller.getState().meta[action.key]?.error;\n              // processing errors result in state meta having error, so we should reject the promise\n              if (error) {\n                this.handleSet(\n                  createSetResponse(action.endpoint, {\n                    args: action.args,\n                    response: error,\n                    fetchedAt: action.meta.fetchedAt,\n                    error: true,\n                  }),\n                );\n              } else {\n                this.handleSet(action);\n              }\n            }\n          });\n        case RESET: {\n          // take snapshot of rejectors at this point in time\n          // we must use Array.from since iteration does not freeze state at this point in time\n          const fetches = Array.from(this.fetching.values());\n\n          this.clearAll();\n          return next(action).then(() => {\n            // there could be external listeners to the promise\n            // this must happen after commit so our own rejector knows not to dispatch an error based on this\n            for (const { reject } of fetches) {\n              reject(new ResetError());\n            }\n          });\n        }\n        default:\n          return next(action);\n      }\n    };\n  };\n\n  /** On mount */\n  init() {\n    delete this.cleanupDate;\n  }\n\n  /** Ensures all promises are completed by rejecting remaining. */\n  cleanup() {\n    // ensure no dispatches after unmount\n    // this must be reversible (done in init) so useEffect() remains symmetric\n    this.cleanupDate = Date.now();\n  }\n\n  /** Used by DevtoolsManager to determine whether to log an action */\n  skipLogging(action: ActionTypes) {\n    /* istanbul ignore next */\n    return action.type === FETCH && this.fetching.has(action.key);\n  }\n\n  allSettled() {\n    if (this.fetching.size)\n      return Promise.allSettled(\n        this.fetching.values().map(({ promise }) => promise),\n      );\n  }\n\n  /** Clear all promise state */\n  protected clearAll() {\n    for (const k of this.fetching.keys()) {\n      this.clear(k);\n    }\n  }\n\n  /** Clear promise state for a given key */\n  protected clear(key: string) {\n    if (this.fetching.has(key)) {\n      (this.fetching.get(key) as FetchingMeta).promise.catch(() => {});\n      this.fetching.delete(key);\n    }\n  }\n\n  protected getLastReset() {\n    if (this.cleanupDate) return this.cleanupDate;\n    return this.controller.getState().lastReset;\n  }\n\n  /** Called when middleware intercepts 'rdc/fetch' action.\n   *\n   * Will then start a promise for a key and potentially start the network\n   * fetch.\n   *\n   * Uses throttle endpoints without sideEffects. This is valuable\n   * for ensures mutation requests always go through.\n   */\n  protected handleFetch(action: FetchAction) {\n    const { resolve, reject, fetchedAt } = action.meta;\n    const throttle = !action.endpoint.sideEffect;\n\n    const deferedFetch = () => {\n      let promise = action.endpoint(...action.args);\n      const resolvePromise = (\n        promise: Promise<string | number | object | null>,\n      ) =>\n        promise\n          .then(data => {\n            resolve(data);\n            return data;\n          })\n          .catch(error => {\n            reject(error);\n            throw error;\n          });\n      // schedule non-throttled resolutions in a microtask before set\n      // this enables users awaiting their fetch to trigger any react updates needed to deal\n      // with upcoming changes because of the fetch (for instance avoiding suspense if something is deleted)\n      if (!throttle) {\n        promise = resolvePromise(promise);\n      }\n      promise = promise\n        .then(response => {\n          let lastReset = this.getLastReset();\n\n          /* istanbul ignore else */\n          if (process.env.NODE_ENV !== 'production' && isNaN(lastReset)) {\n            console.error(\n              'state.lastReset is NaN. Only positive timestamps are valid.',\n            );\n            lastReset = 0;\n          }\n\n          // don't update state with promises started before last clear\n          if (fetchedAt >= lastReset) {\n            this.controller.resolve(action.endpoint, {\n              args: action.args,\n              response,\n              fetchedAt,\n            });\n          }\n          return response;\n        })\n        .catch(error => {\n          const lastReset = this.getLastReset();\n          // don't update state with promises started before last clear\n          if (fetchedAt >= lastReset) {\n            this.controller.resolve(action.endpoint, {\n              args: action.args,\n              response: error,\n              fetchedAt,\n              error: true,\n            });\n          }\n          throw error;\n        });\n      return promise;\n    };\n\n    if (throttle) {\n      return this.throttle(action.key, deferedFetch, fetchedAt)\n        .then(data => resolve(data))\n        .catch(error => reject(error));\n    } else {\n      return deferedFetch().catch(() => {});\n    }\n  }\n\n  /** Called when middleware intercepts a set action.\n   *\n   * Will resolve the promise associated with set key.\n   */\n  protected handleSet(action: SetResponseAction) {\n    // this can still turn out to be untrue since this is async\n    if (this.fetching.has(action.key)) {\n      const { reject, resolve } = this.fetching.get(action.key) as FetchingMeta;\n      if (action.error) {\n        reject(action.response);\n      } else {\n        resolve(action.response);\n      }\n\n      // since we're resolved we no longer need to keep track of this promise\n      this.clear(action.key);\n    }\n  }\n\n  /** Ensures only one request for a given key is in flight at any time\n   *\n   * Uses key to either retrieve in-flight promise, or if not\n   * create a new promise and call fetch.\n   *\n   * Note: The new promise is not actually tied to fetch at all,\n   * but is resolved when the expected 'receive' action is processed.\n   * This ensures promises are resolved only once their data is processed\n   * by the reducer.\n   */\n  protected throttle(\n    key: string,\n    fetch: () => Promise<any>,\n    fetchedAt: number,\n  ): Promise<any> {\n    const lastReset = this.getLastReset();\n    let fetchMeta = this.fetching.get(key);\n\n    // we're already fetching so reuse the promise\n    // fetches after reset do not count\n    if (fetchMeta && fetchMeta.fetchedAt > lastReset) {\n      return fetchMeta.promise;\n    }\n\n    fetchMeta = newFetchMeta(fetchedAt);\n    this.fetching.set(key, fetchMeta);\n\n    this.idleCallback(\n      () => {\n        // since our real promise is resolved via the wrapReducer(),\n        // we should just stop all errors here.\n        // TODO: decouple this from useFetcher() (that's what's dispatching the error the resolves in here)\n        fetch().catch(() => null);\n      },\n      { timeout: 500 },\n    );\n\n    return fetchMeta.promise;\n  }\n\n  /** Calls the callback when client is not 'busy' with high priority interaction tasks\n   *\n   * Override for platform-specific implementations\n   */\n  protected idleCallback(\n    callback: (...args: any[]) => void,\n    options?: IdleRequestOptions,\n  ) {\n    callback();\n  }\n}\n\nfunction newFetchMeta(fetchedAt: number): FetchingMeta {\n  const fetchMeta = { fetchedAt } as FetchingMeta;\n  fetchMeta.promise = new Promise((resolve, reject) => {\n    fetchMeta.resolve = resolve;\n    fetchMeta.reject = reject;\n  });\n  return fetchMeta;\n}\n"],"mappings":"AAAA,SAASA,YAAY,EAAEC,KAAK,EAAEC,KAAK,QAAQ,mBAAmB;AAC9D,SAASC,iBAAiB,QAAQ,gCAAgC;AAClE,OAAOC,UAAU,MAAM,6BAA6B;AASpD,OAAO,MAAMC,UAAU,SAASC,KAAK,CAAC;EAGpCC,WAAWA,CAAA,EAAG;IACZ,KAAK,CAAC,sBAAsB,CAAC;IAAC,KAHhCC,IAAI,GAAG,YAAY;EAInB;AACF;AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,MAAMC,cAAc,CAAoB;EAOrDF,WAAWA,CAAC;IAAEG,gBAAgB,GAAG,KAAK;IAAEC,iBAAiB,GAAG;EAAK,CAAC,GAAG,CAAC,CAAC,EAAE;IAAA,KAN/DC,QAAQ,GAA8B,IAAIC,GAAG,CAAC,CAAC;IAAA,KAG/CC,UAAU,GAAe,IAAIV,UAAU,CAAC,CAAC;IAAA,KAQnDW,UAAU,GAAeD,UAAU,IAAI;MACrC,IAAI,CAACA,UAAU,GAAGA,UAAU;MAC5B,OAAOE,IAAI,IAAIC,MAAM,IAAI;QACvB,QAAQA,MAAM,CAACC,IAAI;UACjB,KAAKjB,KAAK;YACR,IAAI,CAACkB,WAAW,CAACF,MAAM,CAAC;YACxB;YACA;YACA;YACA,IACEA,MAAM,CAACG,QAAQ,CAACC,qBAAqB,KAAKC,SAAS,IACnDL,MAAM,CAACG,QAAQ,CAACG,UAAU,EAC1B;cACA,OAAOP,IAAI,CAACC,MAAM,CAAC;YACrB;YACA,OAAOO,OAAO,CAACC,OAAO,CAAC,CAAC;UAC1B,KAAKzB,YAAY;YACf;YACA,OAAOgB,IAAI,CAACC,MAAM,CAAC,CAACS,IAAI,CAAC,MAAM;cAC7B,IAAI,IAAI,CAACd,QAAQ,CAACe,GAAG,CAACV,MAAM,CAACW,GAAG,CAAC,EAAE;gBAAA,IAAAC,qBAAA;gBACjC;gBACA,MAAMC,KAAK,IAAAD,qBAAA,GAAGf,UAAU,CAACiB,QAAQ,CAAC,CAAC,CAACC,IAAI,CAACf,MAAM,CAACW,GAAG,CAAC,qBAAtCC,qBAAA,CAAwCC,KAAK;gBAC3D;gBACA,IAAIA,KAAK,EAAE;kBACT,IAAI,CAACG,SAAS,CACZ9B,iBAAiB,CAACc,MAAM,CAACG,QAAQ,EAAE;oBACjCc,IAAI,EAAEjB,MAAM,CAACiB,IAAI;oBACjBC,QAAQ,EAAEL,KAAK;oBACfM,SAAS,EAAEnB,MAAM,CAACe,IAAI,CAACI,SAAS;oBAChCN,KAAK,EAAE;kBACT,CAAC,CACH,CAAC;gBACH,CAAC,MAAM;kBACL,IAAI,CAACG,SAAS,CAAChB,MAAM,CAAC;gBACxB;cACF;YACF,CAAC,CAAC;UACJ,KAAKf,KAAK;YAAE;cACV;cACA;cACA,MAAMmC,OAAO,GAAGC,KAAK,CAACC,IAAI,CAAC,IAAI,CAAC3B,QAAQ,CAAC4B,MAAM,CAAC,CAAC,CAAC;cAElD,IAAI,CAACC,QAAQ,CAAC,CAAC;cACf,OAAOzB,IAAI,CAACC,MAAM,CAAC,CAACS,IAAI,CAAC,MAAM;gBAC7B;gBACA;gBACA,KAAK,MAAM;kBAAEgB;gBAAO,CAAC,IAAIL,OAAO,EAAE;kBAChCK,MAAM,CAAC,IAAIrC,UAAU,CAAC,CAAC,CAAC;gBAC1B;cACF,CAAC,CAAC;YACJ;UACA;YACE,OAAOW,IAAI,CAACC,MAAM,CAAC;QACvB;MACF,CAAC;IACH,CAAC;IA3DC,IAAI,CAACP,gBAAgB,GAAGA,gBAAgB;IACxC,IAAI,CAACC,iBAAiB,GAAGA,iBAAiB;EAC5C;EA2DA;EACAgC,IAAIA,CAAA,EAAG;IACL,OAAO,IAAI,CAACC,WAAW;EACzB;;EAEA;EACAC,OAAOA,CAAA,EAAG;IACR;IACA;IACA,IAAI,CAACD,WAAW,GAAGE,IAAI,CAACC,GAAG,CAAC,CAAC;EAC/B;;EAEA;EACAC,WAAWA,CAAC/B,MAAmB,EAAE;IAC/B;IACA,OAAOA,MAAM,CAACC,IAAI,KAAKjB,KAAK,IAAI,IAAI,CAACW,QAAQ,CAACe,GAAG,CAACV,MAAM,CAACW,GAAG,CAAC;EAC/D;EAEAqB,UAAUA,CAAA,EAAG;IACX,IAAI,IAAI,CAACrC,QAAQ,CAACsC,IAAI,EACpB,OAAO1B,OAAO,CAACyB,UAAU,CACvB,IAAI,CAACrC,QAAQ,CAAC4B,MAAM,CAAC,CAAC,CAACW,GAAG,CAAC,CAAC;MAAEC;IAAQ,CAAC,KAAKA,OAAO,CACrD,CAAC;EACL;;EAEA;EACUX,QAAQA,CAAA,EAAG;IACnB,KAAK,MAAMY,CAAC,IAAI,IAAI,CAACzC,QAAQ,CAAC0C,IAAI,CAAC,CAAC,EAAE;MACpC,IAAI,CAACC,KAAK,CAACF,CAAC,CAAC;IACf;EACF;;EAEA;EACUE,KAAKA,CAAC3B,GAAW,EAAE;IAC3B,IAAI,IAAI,CAAChB,QAAQ,CAACe,GAAG,CAACC,GAAG,CAAC,EAAE;MACzB,IAAI,CAAChB,QAAQ,CAAC4C,GAAG,CAAC5B,GAAG,CAAC,CAAkBwB,OAAO,CAACK,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;MAChE,IAAI,CAAC7C,QAAQ,CAAC8C,MAAM,CAAC9B,GAAG,CAAC;IAC3B;EACF;EAEU+B,YAAYA,CAAA,EAAG;IACvB,IAAI,IAAI,CAACf,WAAW,EAAE,OAAO,IAAI,CAACA,WAAW;IAC7C,OAAO,IAAI,CAAC9B,UAAU,CAACiB,QAAQ,CAAC,CAAC,CAAC6B,SAAS;EAC7C;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;EACYzC,WAAWA,CAACF,MAAmB,EAAE;IACzC,MAAM;MAAEQ,OAAO;MAAEiB,MAAM;MAAEN;IAAU,CAAC,GAAGnB,MAAM,CAACe,IAAI;IAClD,MAAM6B,QAAQ,GAAG,CAAC5C,MAAM,CAACG,QAAQ,CAACG,UAAU;IAE5C,MAAMuC,YAAY,GAAGA,CAAA,KAAM;MACzB,IAAIV,OAAO,GAAGnC,MAAM,CAACG,QAAQ,CAAC,GAAGH,MAAM,CAACiB,IAAI,CAAC;MAC7C,MAAM6B,cAAc,GAClBX,OAAiD,IAEjDA,OAAO,CACJ1B,IAAI,CAACsC,IAAI,IAAI;QACZvC,OAAO,CAACuC,IAAI,CAAC;QACb,OAAOA,IAAI;MACb,CAAC,CAAC,CACDP,KAAK,CAAC3B,KAAK,IAAI;QACdY,MAAM,CAACZ,KAAK,CAAC;QACb,MAAMA,KAAK;MACb,CAAC,CAAC;MACN;MACA;MACA;MACA,IAAI,CAAC+B,QAAQ,EAAE;QACbT,OAAO,GAAGW,cAAc,CAACX,OAAO,CAAC;MACnC;MACAA,OAAO,GAAGA,OAAO,CACd1B,IAAI,CAACS,QAAQ,IAAI;QAChB,IAAIyB,SAAS,GAAG,IAAI,CAACD,YAAY,CAAC,CAAC;;QAEnC;QACA,IAAIM,OAAO,CAACC,GAAG,CAACC,QAAQ,KAAK,YAAY,IAAIC,KAAK,CAACR,SAAS,CAAC,EAAE;UAC7DS,OAAO,CAACvC,KAAK,CACX,6DACF,CAAC;UACD8B,SAAS,GAAG,CAAC;QACf;;QAEA;QACA,IAAIxB,SAAS,IAAIwB,SAAS,EAAE;UAC1B,IAAI,CAAC9C,UAAU,CAACW,OAAO,CAACR,MAAM,CAACG,QAAQ,EAAE;YACvCc,IAAI,EAAEjB,MAAM,CAACiB,IAAI;YACjBC,QAAQ;YACRC;UACF,CAAC,CAAC;QACJ;QACA,OAAOD,QAAQ;MACjB,CAAC,CAAC,CACDsB,KAAK,CAAC3B,KAAK,IAAI;QACd,MAAM8B,SAAS,GAAG,IAAI,CAACD,YAAY,CAAC,CAAC;QACrC;QACA,IAAIvB,SAAS,IAAIwB,SAAS,EAAE;UAC1B,IAAI,CAAC9C,UAAU,CAACW,OAAO,CAACR,MAAM,CAACG,QAAQ,EAAE;YACvCc,IAAI,EAAEjB,MAAM,CAACiB,IAAI;YACjBC,QAAQ,EAAEL,KAAK;YACfM,SAAS;YACTN,KAAK,EAAE;UACT,CAAC,CAAC;QACJ;QACA,MAAMA,KAAK;MACb,CAAC,CAAC;MACJ,OAAOsB,OAAO;IAChB,CAAC;IAED,IAAIS,QAAQ,EAAE;MACZ,OAAO,IAAI,CAACA,QAAQ,CAAC5C,MAAM,CAACW,GAAG,EAAEkC,YAAY,EAAE1B,SAAS,CAAC,CACtDV,IAAI,CAACsC,IAAI,IAAIvC,OAAO,CAACuC,IAAI,CAAC,CAAC,CAC3BP,KAAK,CAAC3B,KAAK,IAAIY,MAAM,CAACZ,KAAK,CAAC,CAAC;IAClC,CAAC,MAAM;MACL,OAAOgC,YAAY,CAAC,CAAC,CAACL,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACvC;EACF;;EAEA;AACF;AACA;AACA;EACYxB,SAASA,CAAChB,MAAyB,EAAE;IAC7C;IACA,IAAI,IAAI,CAACL,QAAQ,CAACe,GAAG,CAACV,MAAM,CAACW,GAAG,CAAC,EAAE;MACjC,MAAM;QAAEc,MAAM;QAAEjB;MAAQ,CAAC,GAAG,IAAI,CAACb,QAAQ,CAAC4C,GAAG,CAACvC,MAAM,CAACW,GAAG,CAAiB;MACzE,IAAIX,MAAM,CAACa,KAAK,EAAE;QAChBY,MAAM,CAACzB,MAAM,CAACkB,QAAQ,CAAC;MACzB,CAAC,MAAM;QACLV,OAAO,CAACR,MAAM,CAACkB,QAAQ,CAAC;MAC1B;;MAEA;MACA,IAAI,CAACoB,KAAK,CAACtC,MAAM,CAACW,GAAG,CAAC;IACxB;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACYiC,QAAQA,CAChBjC,GAAW,EACX0C,KAAyB,EACzBlC,SAAiB,EACH;IACd,MAAMwB,SAAS,GAAG,IAAI,CAACD,YAAY,CAAC,CAAC;IACrC,IAAIY,SAAS,GAAG,IAAI,CAAC3D,QAAQ,CAAC4C,GAAG,CAAC5B,GAAG,CAAC;;IAEtC;IACA;IACA,IAAI2C,SAAS,IAAIA,SAAS,CAACnC,SAAS,GAAGwB,SAAS,EAAE;MAChD,OAAOW,SAAS,CAACnB,OAAO;IAC1B;IAEAmB,SAAS,GAAGC,YAAY,CAACpC,SAAS,CAAC;IACnC,IAAI,CAACxB,QAAQ,CAAC6D,GAAG,CAAC7C,GAAG,EAAE2C,SAAS,CAAC;IAEjC,IAAI,CAACG,YAAY,CACf,MAAM;MACJ;MACA;MACA;MACAJ,KAAK,CAAC,CAAC,CAACb,KAAK,CAAC,MAAM,IAAI,CAAC;IAC3B,CAAC,EACD;MAAEkB,OAAO,EAAE;IAAI,CACjB,CAAC;IAED,OAAOJ,SAAS,CAACnB,OAAO;EAC1B;;EAEA;AACF;AACA;AACA;EACYsB,YAAYA,CACpBE,QAAkC,EAClCC,OAA4B,EAC5B;IACAD,QAAQ,CAAC,CAAC;EACZ;AACF;AAEA,SAASJ,YAAYA,CAACpC,SAAiB,EAAgB;EACrD,MAAMmC,SAAS,GAAG;IAAEnC;EAAU,CAAiB;EAC/CmC,SAAS,CAACnB,OAAO,GAAG,IAAI5B,OAAO,CAAC,CAACC,OAAO,EAAEiB,MAAM,KAAK;IACnD6B,SAAS,CAAC9C,OAAO,GAAGA,OAAO;IAC3B8C,SAAS,CAAC7B,MAAM,GAAGA,MAAM;EAC3B,CAAC,CAAC;EACF,OAAO6B,SAAS;AAClB","ignoreList":[]}