@data-client/rest 0.1.0

package/legacy/RestEndpoint.js

@@ -0,0 +1,225 @@
+import _objectDestructuringEmpty from "@babel/runtime/helpers/objectDestructuringEmpty";
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+import { Endpoint } from '@data-client/endpoint';
+import { pathToRegexp } from 'path-to-regexp';
+import extractCollection from './extractCollection.js';
+import mapCollection from './mapCollection.js';
+import NetworkError from './NetworkError.js';
+import { paginatedMerge, paginatedFilter } from './paginatedCollections.js';
+import paginationUpdate from './paginationUpdate.js';
+import paramsToString from './paramsToString.js';
+import { getUrlBase, getUrlTokens, isPojo } from './RestHelpers.js';
+
+/** Simplifies endpoint definitions that follow REST patterns
+ *
+ * @see https://resthooks.io/rest/api/RestEndpoint
+ */
+var _hasBody = /*#__PURE__*/_classPrivateFieldLooseKey("hasBody");
+export default class RestEndpoint extends Endpoint {
+  constructor(options) {
+    var _options$fetch;
+    super((_options$fetch = options.fetch) != null ? _options$fetch : function (...args) {
+      const urlParams = _classPrivateFieldLooseBase(this, _hasBody)[_hasBody] && args.length < 2 ? {} : args[0] || {};
+      const body = _classPrivateFieldLooseBase(this, _hasBody)[_hasBody] ? args[args.length - 1] : undefined;
+      return this.fetchResponse(this.url(urlParams), this.getRequestInit(body)).then(response => this.parseResponse(response)).then(res => this.process(res, ...args));
+    }, options);
+    // we want to use the prototype chain here
+    Object.defineProperty(this, _hasBody, {
+      writable: true,
+      value: void 0
+    });
+    if (!('sideEffect' in this) || 'method' in options && !('sideEffect' in options)) {
+      this.sideEffect = options.method === 'GET' || options.method === undefined ? undefined : true;
+    }
+    if (this.method === undefined) {
+      this.method = this.sideEffect ? 'POST' : 'GET';
+    }
+    if (this.urlPrefix === undefined) {
+      this.urlPrefix = '';
+    }
+    _classPrivateFieldLooseBase(this, _hasBody)[_hasBody] = (!('body' in this) || this.body !== undefined) && !['GET', 'DELETE'].includes(this.method);
+    Object.defineProperty(this, 'name', {
+      get() {
+        // using 'in' to ensure inheritance lookup
+        if ('__name' in this) return this.__name;
+        return this.urlPrefix + this.path;
+      }
+    });
+  }
+  key(...args) {
+    return `${this.method} ${this.url(_classPrivateFieldLooseBase(this, _hasBody)[_hasBody] && args.length < 2 ? {} : args[0] || {})}`;
+  }
+
+  /** Get the url */
+  url(urlParams = {}) {
+    const urlBase = getUrlBase(this.path)(urlParams);
+    const tokens = getUrlTokens(this.path);
+    const searchParams = {};
+    Object.keys(urlParams).forEach(k => {
+      if (!tokens.has(k)) {
+        searchParams[k] = urlParams[k];
+      }
+    });
+    if (Object.keys(searchParams).length) {
+      return `${this.urlPrefix}${urlBase}?${paramsToString(searchParams)}`;
+    }
+    return `${this.urlPrefix}${urlBase}`;
+  }
+  getHeaders(headers) {
+    return headers;
+  }
+
+  /** Init options for fetch - run at fetch */
+  getRequestInit(body) {
+    const bodyIsPojo = isPojo(body);
+    if (bodyIsPojo) {
+      body = JSON.stringify(body);
+    }
+    const init = Object.assign({}, this.requestInit, {
+      method: this.method,
+      signal: this.signal,
+      body
+    });
+    if (!body || bodyIsPojo) {
+      init.headers = Object.assign({
+        // default to application/json but allow user explicit overrides
+        'Content-Type': 'application/json'
+      }, init.headers);
+    }
+    init.headers = this.getHeaders(init.headers);
+    return init;
+  }
+
+  /** Perform network request and resolve with HTTP Response */
+  fetchResponse(input, init) {
+    return fetch(input, init).then(response => {
+      if (!response.ok) {
+        throw new NetworkError(response);
+      }
+      return response;
+    }).catch(error => {
+      // ensure CORS, network down, and parse errors are still caught by NetworkErrorBoundary
+      if (error instanceof TypeError) {
+        error.status = 500;
+      }
+      throw error;
+    });
+  }
+  parseResponse(response) {
+    var _response$headers$get;
+    // this should not have any content to read
+    if (response.status === 204) return Promise.resolve(null);
+    if (!((_response$headers$get = response.headers.get('content-type')) != null && _response$headers$get.includes('json'))) {
+      return response.text().then(text => {
+        // string or 'not set' schema, are valid
+        // when overriding process they might handle other cases, so we don't want to block on our logic
+        if (['string', 'undefined'].includes(typeof this.schema) || this.schema === null || this.process !== RestEndpoint.prototype.process) return text;
+        const error = new NetworkError(response);
+        error.status = 404;
+        error.message = `Unexpected text response for schema ${this.schema}`;
+        // custom dev-only messages for more detailed cause
+        /* istanbul ignore else */
+        if (process.env.NODE_ENV !== 'production') {
+          var _response$headers$get2;
+          if (!((_response$headers$get2 = response.headers.get('content-type')) != null && _response$headers$get2.includes('html') || text.startsWith('<!doctype html>'))) {
+            if (tryParse(text) !== undefined) {
+              error.message = `"content-type" header does not include "json", but JSON response found.
+See https://www.rfc-editor.org/rfc/rfc4627 for information on JSON responses
+
+Using parsed JSON.
+If text content was expected see https://resthooks.io/rest/api/RestEndpoint#parseResponse`;
+            }
+          } else {
+            error.message = `Unexpected html response for schema ${this.schema}
+This likely means no API endpoint was configured for this request, resulting in an HTML fallback.
+
+Response (first 300 characters): ${text.substring(0, 300)}`;
+          }
+        }
+        throw error;
+      });
+    }
+    return response.json().catch(error => {
+      error.status = 400;
+      throw error;
+    });
+  }
+  process(value) {
+    return value;
+  }
+  errorPolicy(error) {
+    return error.status >= 500 ? 'soft' : undefined;
+  }
+  get pathRegex() {
+    return pathToRegexp(this.path);
+  }
+  testKey(key) {
+    const prefix = this.method + ' ' + this.urlPrefix;
+    if (!key.startsWith(prefix)) return false;
+    let lastQuestion = key.lastIndexOf('?');
+    if (lastQuestion === -1) lastQuestion = undefined;
+    return this.pathRegex.test(key.substring(prefix.length, lastQuestion));
+  }
+  extend(options) {
+    // make a constructor/prototype based off this
+    // extend from it and init with options sent
+    class E extends this.constructor {}
+    Object.assign(E.prototype, this);
+    const instance = new E( //  fetch get overridden by function prototype, so we must set it explicitly every time
+    Object.assign({
+      fetch: this.fetch
+    }, options));
+    return instance;
+  }
+  paginated(removeCursor) {
+    if (typeof removeCursor === 'string') {
+      const fieldName = removeCursor;
+      removeCursor = _ref => {
+        let params = Object.assign({}, (_objectDestructuringEmpty(_ref), _ref));
+        delete params[fieldName];
+        return [params];
+      };
+    }
+    let found = false;
+    const createPaginatedSchema = collection => {
+      found = true;
+      return collection.addWith(paginatedMerge, paginatedFilter(removeCursor));
+    };
+    const newSchema = mapCollection(this.schema, createPaginatedSchema);
+    if (found) {
+      return this.extend({
+        schema: newSchema
+      });
+    }
+    return this.extend({
+      update: paginationUpdate(this, removeCursor)
+    });
+  }
+  get push() {
+    return this.extend({
+      method: 'POST',
+      schema: extractCollection(this.schema, s => s.push)
+    });
+  }
+  get unshift() {
+    return this.extend({
+      method: 'POST',
+      schema: extractCollection(this.schema, s => s.unshift)
+    });
+  }
+  get assign() {
+    return this.extend({
+      method: 'POST',
+      schema: extractCollection(this.schema, s => s.assign)
+    });
+  }
+}
+const tryParse = input => {
+  try {
+    return JSON.parse(input);
+  } catch (e) {
+    return undefined;
+  }
+};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Endpoint","pathToRegexp","extractCollection","mapCollection","NetworkError","paginatedMerge","paginatedFilter","paginationUpdate","paramsToString","getUrlBase","getUrlTokens","isPojo","_hasBody","_classPrivateFieldLooseKey","RestEndpoint","constructor","options","_options$fetch","fetch","args","urlParams","_classPrivateFieldLooseBase","length","body","undefined","fetchResponse","url","getRequestInit","then","response","parseResponse","res","process","Object","defineProperty","writable","value","sideEffect","method","urlPrefix","includes","get","__name","path","key","urlBase","tokens","searchParams","keys","forEach","k","has","getHeaders","headers","bodyIsPojo","JSON","stringify","init","assign","requestInit","signal","input","ok","catch","error","TypeError","status","_response$headers$get","Promise","resolve","text","schema","prototype","message","env","NODE_ENV","_response$headers$get2","startsWith","tryParse","substring","json","errorPolicy","pathRegex","testKey","prefix","lastQuestion","lastIndexOf","test","extend","E","instance","paginated","removeCursor","fieldName","_ref","params","_objectDestructuringEmpty","found","createPaginatedSchema","collection","addWith","newSchema","update","push","s","unshift","parse","e"],"sources":["../src/RestEndpoint.js"],"sourcesContent":["import { Endpoint } from '@data-client/endpoint';\nimport { pathToRegexp } from 'path-to-regexp';\n\nimport extractCollection from './extractCollection.js';\nimport mapCollection from './mapCollection.js';\nimport NetworkError from './NetworkError.js';\nimport { paginatedMerge, paginatedFilter } from './paginatedCollections.js';\nimport paginationUpdate from './paginationUpdate.js';\nimport paramsToString from './paramsToString.js';\nimport { getUrlBase, getUrlTokens, isPojo } from './RestHelpers.js';\n\n/** Simplifies endpoint definitions that follow REST patterns\n *\n * @see https://resthooks.io/rest/api/RestEndpoint\n */\nexport default class RestEndpoint extends Endpoint {\n  #hasBody;\n  constructor(options) {\n    super(\n      options.fetch ??\n        function (...args) {\n          const urlParams =\n            this.#hasBody && args.length < 2 ? {} : args[0] || {};\n          const body = this.#hasBody ? args[args.length - 1] : undefined;\n          return this.fetchResponse(\n            this.url(urlParams),\n            this.getRequestInit(body),\n          )\n            .then(response => this.parseResponse(response))\n            .then(res => this.process(res, ...args));\n        },\n      options,\n    );\n    // we want to use the prototype chain here\n    if (\n      !('sideEffect' in this) ||\n      ('method' in options && !('sideEffect' in options))\n    ) {\n      this.sideEffect =\n        options.method === 'GET' || options.method === undefined\n          ? undefined\n          : true;\n    }\n    if (this.method === undefined) {\n      this.method = this.sideEffect ? 'POST' : 'GET';\n    }\n    if (this.urlPrefix === undefined) {\n      this.urlPrefix = '';\n    }\n    this.#hasBody =\n      (!('body' in this) || this.body !== undefined) &&\n      !['GET', 'DELETE'].includes(this.method);\n\n    Object.defineProperty(this, 'name', {\n      get() {\n        // using 'in' to ensure inheritance lookup\n        if ('__name' in this) return this.__name;\n        return this.urlPrefix + this.path;\n      },\n    });\n  }\n\n  key(...args) {\n    return `${this.method} ${this.url(\n      this.#hasBody && args.length < 2 ? {} : args[0] || {},\n    )}`;\n  }\n\n  /** Get the url */\n  url(urlParams = {}) {\n    const urlBase = getUrlBase(this.path)(urlParams);\n    const tokens = getUrlTokens(this.path);\n    const searchParams = {};\n    Object.keys(urlParams).forEach(k => {\n      if (!tokens.has(k)) {\n        searchParams[k] = urlParams[k];\n      }\n    });\n    if (Object.keys(searchParams).length) {\n      return `${this.urlPrefix}${urlBase}?${paramsToString(searchParams)}`;\n    }\n    return `${this.urlPrefix}${urlBase}`;\n  }\n\n  getHeaders(headers) {\n    return headers;\n  }\n\n  /** Init options for fetch - run at fetch */\n  getRequestInit(body) {\n    const bodyIsPojo = isPojo(body);\n    if (bodyIsPojo) {\n      body = JSON.stringify(body);\n    }\n    const init = {\n      ...this.requestInit,\n      method: this.method,\n      signal: this.signal,\n      body,\n    };\n    if (!body || bodyIsPojo) {\n      init.headers = {\n        // default to application/json but allow user explicit overrides\n        'Content-Type': 'application/json',\n        ...init.headers,\n      };\n    }\n    init.headers = this.getHeaders(init.headers);\n    return init;\n  }\n\n  /** Perform network request and resolve with HTTP Response */\n  fetchResponse(input, init) {\n    return fetch(input, init)\n      .then(response => {\n        if (!response.ok) {\n          throw new NetworkError(response);\n        }\n        return response;\n      })\n      .catch(error => {\n        // ensure CORS, network down, and parse errors are still caught by NetworkErrorBoundary\n        if (error instanceof TypeError) {\n          error.status = 500;\n        }\n        throw error;\n      });\n  }\n\n  parseResponse(response) {\n    // this should not have any content to read\n    if (response.status === 204) return Promise.resolve(null);\n    if (!response.headers.get('content-type')?.includes('json')) {\n      return response.text().then(text => {\n        // string or 'not set' schema, are valid\n        // when overriding process they might handle other cases, so we don't want to block on our logic\n        if (\n          ['string', 'undefined'].includes(typeof this.schema) ||\n          this.schema === null ||\n          this.process !== RestEndpoint.prototype.process\n        )\n          return text;\n\n        const error = new NetworkError(response);\n        error.status = 404;\n        error.message = `Unexpected text response for schema ${this.schema}`;\n        // custom dev-only messages for more detailed cause\n        /* istanbul ignore else */\n        if (process.env.NODE_ENV !== 'production') {\n          if (\n            !(\n              response.headers.get('content-type')?.includes('html') ||\n              text.startsWith('<!doctype html>')\n            )\n          ) {\n            if (tryParse(text) !== undefined) {\n              error.message = `\"content-type\" header does not include \"json\", but JSON response found.\nSee https://www.rfc-editor.org/rfc/rfc4627 for information on JSON responses\n\nUsing parsed JSON.\nIf text content was expected see https://resthooks.io/rest/api/RestEndpoint#parseResponse`;\n            }\n          } else {\n            error.message = `Unexpected html response for schema ${this.schema}\nThis likely means no API endpoint was configured for this request, resulting in an HTML fallback.\n\nResponse (first 300 characters): ${text.substring(0, 300)}`;\n          }\n        }\n        throw error;\n      });\n    }\n    return response.json().catch(error => {\n      error.status = 400;\n      throw error;\n    });\n  }\n\n  process(value) {\n    return value;\n  }\n\n  errorPolicy(error) {\n    return error.status >= 500 ? 'soft' : undefined;\n  }\n\n  get pathRegex() {\n    return pathToRegexp(this.path);\n  }\n\n  testKey(key) {\n    const prefix = this.method + ' ' + this.urlPrefix;\n    if (!key.startsWith(prefix)) return false;\n    let lastQuestion = key.lastIndexOf('?');\n    if (lastQuestion === -1) lastQuestion = undefined;\n    return this.pathRegex.test(key.substring(prefix.length, lastQuestion));\n  }\n\n  extend(options) {\n    // make a constructor/prototype based off this\n    // extend from it and init with options sent\n    class E extends this.constructor {}\n\n    Object.assign(E.prototype, this);\n    const instance = new E(\n      //  fetch get overridden by function prototype, so we must set it explicitly every time\n      { fetch: this.fetch, ...options },\n    );\n\n    return instance;\n  }\n\n  paginated(removeCursor) {\n    if (typeof removeCursor === 'string') {\n      const fieldName = removeCursor;\n      removeCursor = ({ ...params }) => {\n        delete params[fieldName];\n        return [params];\n      };\n    }\n    let found = false;\n    const createPaginatedSchema = collection => {\n      found = true;\n      return collection.addWith(paginatedMerge, paginatedFilter(removeCursor));\n    };\n    const newSchema = mapCollection(this.schema, createPaginatedSchema);\n    if (found) {\n      return this.extend({ schema: newSchema });\n    }\n\n    return this.extend({ update: paginationUpdate(this, removeCursor) });\n  }\n\n  get push() {\n    return this.extend({\n      method: 'POST',\n      schema: extractCollection(this.schema, s => s.push),\n    });\n  }\n\n  get unshift() {\n    return this.extend({\n      method: 'POST',\n      schema: extractCollection(this.schema, s => s.unshift),\n    });\n  }\n\n  get assign() {\n    return this.extend({\n      method: 'POST',\n      schema: extractCollection(this.schema, s => s.assign),\n    });\n  }\n}\n\nconst tryParse = input => {\n  try {\n    return JSON.parse(input);\n  } catch (e) {\n    return undefined;\n  }\n};\n"],"mappings":";;;AAAA,SAASA,QAAQ,QAAQ,uBAAuB;AAChD,SAASC,YAAY,QAAQ,gBAAgB;AAE7C,OAAOC,iBAAiB,MAAM,wBAAwB;AACtD,OAAOC,aAAa,MAAM,oBAAoB;AAC9C,OAAOC,YAAY,MAAM,mBAAmB;AAC5C,SAASC,cAAc,EAAEC,eAAe,QAAQ,2BAA2B;AAC3E,OAAOC,gBAAgB,MAAM,uBAAuB;AACpD,OAAOC,cAAc,MAAM,qBAAqB;AAChD,SAASC,UAAU,EAAEC,YAAY,EAAEC,MAAM,QAAQ,kBAAkB;;AAEnE;AACA;AACA;AACA;AAHA,IAAAC,QAAA,gBAAAC,0BAAA;AAIA,eAAe,MAAMC,YAAY,SAASd,QAAQ,CAAC;EAEjDe,WAAWA,CAACC,OAAO,EAAE;IAAA,IAAAC,cAAA;IACnB,KAAK,EAAAA,cAAA,GACHD,OAAO,CAACE,KAAK,YAAAD,cAAA,GACX,UAAU,GAAGE,IAAI,EAAE;MACjB,MAAMC,SAAS,GACbC,2BAAA,KAAI,EAAAT,QAAA,EAAAA,QAAA,KAAaO,IAAI,CAACG,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;MACvD,MAAMI,IAAI,GAAGF,2BAAA,KAAI,EAAAT,QAAA,EAAAA,QAAA,IAAYO,IAAI,CAACA,IAAI,CAACG,MAAM,GAAG,CAAC,CAAC,GAAGE,SAAS;MAC9D,OAAO,IAAI,CAACC,aAAa,CACvB,IAAI,CAACC,GAAG,CAACN,SAAS,CAAC,EACnB,IAAI,CAACO,cAAc,CAACJ,IAAI,CAC1B,CAAC,CACEK,IAAI,CAACC,QAAQ,IAAI,IAAI,CAACC,aAAa,CAACD,QAAQ,CAAC,CAAC,CAC9CD,IAAI,CAACG,GAAG,IAAI,IAAI,CAACC,OAAO,CAACD,GAAG,EAAE,GAAGZ,IAAI,CAAC,CAAC;IAC5C,CAAC,EACHH,OACF,CAAC;IACD;IAAAiB,MAAA,CAAAC,cAAA,OAAAtB,QAAA;MAAAuB,QAAA;MAAAC,KAAA;IAAA;IACA,IACE,EAAE,YAAY,IAAI,IAAI,CAAC,IACtB,QAAQ,IAAIpB,OAAO,IAAI,EAAE,YAAY,IAAIA,OAAO,CAAE,EACnD;MACA,IAAI,CAACqB,UAAU,GACbrB,OAAO,CAACsB,MAAM,KAAK,KAAK,IAAItB,OAAO,CAACsB,MAAM,KAAKd,SAAS,GACpDA,SAAS,GACT,IAAI;IACZ;IACA,IAAI,IAAI,CAACc,MAAM,KAAKd,SAAS,EAAE;MAC7B,IAAI,CAACc,MAAM,GAAG,IAAI,CAACD,UAAU,GAAG,MAAM,GAAG,KAAK;IAChD;IACA,IAAI,IAAI,CAACE,SAAS,KAAKf,SAAS,EAAE;MAChC,IAAI,CAACe,SAAS,GAAG,EAAE;IACrB;IACAlB,2BAAA,KAAI,EAAAT,QAAA,EAAAA,QAAA,IACF,CAAC,EAAE,MAAM,IAAI,IAAI,CAAC,IAAI,IAAI,CAACW,IAAI,KAAKC,SAAS,KAC7C,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,CAACgB,QAAQ,CAAC,IAAI,CAACF,MAAM,CAAC;IAE1CL,MAAM,CAACC,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE;MAClCO,GAAGA,CAAA,EAAG;QACJ;QACA,IAAI,QAAQ,IAAI,IAAI,EAAE,OAAO,IAAI,CAACC,MAAM;QACxC,OAAO,IAAI,CAACH,SAAS,GAAG,IAAI,CAACI,IAAI;MACnC;IACF,CAAC,CAAC;EACJ;EAEAC,GAAGA,CAAC,GAAGzB,IAAI,EAAE;IACX,OAAQ,GAAE,IAAI,CAACmB,MAAO,IAAG,IAAI,CAACZ,GAAG,CAC/BL,2BAAA,KAAI,EAAAT,QAAA,EAAAA,QAAA,KAAaO,IAAI,CAACG,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,GAAGH,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CACtD,CAAE,EAAC;EACL;;EAEA;EACAO,GAAGA,CAACN,SAAS,GAAG,CAAC,CAAC,EAAE;IAClB,MAAMyB,OAAO,GAAGpC,UAAU,CAAC,IAAI,CAACkC,IAAI,CAAC,CAACvB,SAAS,CAAC;IAChD,MAAM0B,MAAM,GAAGpC,YAAY,CAAC,IAAI,CAACiC,IAAI,CAAC;IACtC,MAAMI,YAAY,GAAG,CAAC,CAAC;IACvBd,MAAM,CAACe,IAAI,CAAC5B,SAAS,CAAC,CAAC6B,OAAO,CAACC,CAAC,IAAI;MAClC,IAAI,CAACJ,MAAM,CAACK,GAAG,CAACD,CAAC,CAAC,EAAE;QAClBH,YAAY,CAACG,CAAC,CAAC,GAAG9B,SAAS,CAAC8B,CAAC,CAAC;MAChC;IACF,CAAC,CAAC;IACF,IAAIjB,MAAM,CAACe,IAAI,CAACD,YAAY,CAAC,CAACzB,MAAM,EAAE;MACpC,OAAQ,GAAE,IAAI,CAACiB,SAAU,GAAEM,OAAQ,IAAGrC,cAAc,CAACuC,YAAY,CAAE,EAAC;IACtE;IACA,OAAQ,GAAE,IAAI,CAACR,SAAU,GAAEM,OAAQ,EAAC;EACtC;EAEAO,UAAUA,CAACC,OAAO,EAAE;IAClB,OAAOA,OAAO;EAChB;;EAEA;EACA1B,cAAcA,CAACJ,IAAI,EAAE;IACnB,MAAM+B,UAAU,GAAG3C,MAAM,CAACY,IAAI,CAAC;IAC/B,IAAI+B,UAAU,EAAE;MACd/B,IAAI,GAAGgC,IAAI,CAACC,SAAS,CAACjC,IAAI,CAAC;IAC7B;IACA,MAAMkC,IAAI,GAAAxB,MAAA,CAAAyB,MAAA,KACL,IAAI,CAACC,WAAW;MACnBrB,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBsB,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBrC;IAAI,EACL;IACD,IAAI,CAACA,IAAI,IAAI+B,UAAU,EAAE;MACvBG,IAAI,CAACJ,OAAO,GAAApB,MAAA,CAAAyB,MAAA;QACV;QACA,cAAc,EAAE;MAAkB,GAC/BD,IAAI,CAACJ,OAAO,CAChB;IACH;IACAI,IAAI,CAACJ,OAAO,GAAG,IAAI,CAACD,UAAU,CAACK,IAAI,CAACJ,OAAO,CAAC;IAC5C,OAAOI,IAAI;EACb;;EAEA;EACAhC,aAAaA,CAACoC,KAAK,EAAEJ,IAAI,EAAE;IACzB,OAAOvC,KAAK,CAAC2C,KAAK,EAAEJ,IAAI,CAAC,CACtB7B,IAAI,CAACC,QAAQ,IAAI;MAChB,IAAI,CAACA,QAAQ,CAACiC,EAAE,EAAE;QAChB,MAAM,IAAI1D,YAAY,CAACyB,QAAQ,CAAC;MAClC;MACA,OAAOA,QAAQ;IACjB,CAAC,CAAC,CACDkC,KAAK,CAACC,KAAK,IAAI;MACd;MACA,IAAIA,KAAK,YAAYC,SAAS,EAAE;QAC9BD,KAAK,CAACE,MAAM,GAAG,GAAG;MACpB;MACA,MAAMF,KAAK;IACb,CAAC,CAAC;EACN;EAEAlC,aAAaA,CAACD,QAAQ,EAAE;IAAA,IAAAsC,qBAAA;IACtB;IACA,IAAItC,QAAQ,CAACqC,MAAM,KAAK,GAAG,EAAE,OAAOE,OAAO,CAACC,OAAO,CAAC,IAAI,CAAC;IACzD,IAAI,GAAAF,qBAAA,GAACtC,QAAQ,CAACwB,OAAO,CAACZ,GAAG,CAAC,cAAc,CAAC,aAApC0B,qBAAA,CAAsC3B,QAAQ,CAAC,MAAM,CAAC,GAAE;MAC3D,OAAOX,QAAQ,CAACyC,IAAI,CAAC,CAAC,CAAC1C,IAAI,CAAC0C,IAAI,IAAI;QAClC;QACA;QACA,IACE,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC9B,QAAQ,CAAC,OAAO,IAAI,CAAC+B,MAAM,CAAC,IACpD,IAAI,CAACA,MAAM,KAAK,IAAI,IACpB,IAAI,CAACvC,OAAO,KAAKlB,YAAY,CAAC0D,SAAS,CAACxC,OAAO,EAE/C,OAAOsC,IAAI;QAEb,MAAMN,KAAK,GAAG,IAAI5D,YAAY,CAACyB,QAAQ,CAAC;QACxCmC,KAAK,CAACE,MAAM,GAAG,GAAG;QAClBF,KAAK,CAACS,OAAO,GAAI,uCAAsC,IAAI,CAACF,MAAO,EAAC;QACpE;QACA;QACA,IAAIvC,OAAO,CAAC0C,GAAG,CAACC,QAAQ,KAAK,YAAY,EAAE;UAAA,IAAAC,sBAAA;UACzC,IACE,EACE,CAAAA,sBAAA,GAAA/C,QAAQ,CAACwB,OAAO,CAACZ,GAAG,CAAC,cAAc,CAAC,aAApCmC,sBAAA,CAAsCpC,QAAQ,CAAC,MAAM,CAAC,IACtD8B,IAAI,CAACO,UAAU,CAAC,iBAAiB,CAAC,CACnC,EACD;YACA,IAAIC,QAAQ,CAACR,IAAI,CAAC,KAAK9C,SAAS,EAAE;cAChCwC,KAAK,CAACS,OAAO,GAAI;AAC/B;AACA;AACA;AACA,0FAA0F;YAC9E;UACF,CAAC,MAAM;YACLT,KAAK,CAACS,OAAO,GAAI,uCAAsC,IAAI,CAACF,MAAO;AAC/E;AACA;AACA,mCAAmCD,IAAI,CAACS,SAAS,CAAC,CAAC,EAAE,GAAG,CAAE,EAAC;UACjD;QACF;QACA,MAAMf,KAAK;MACb,CAAC,CAAC;IACJ;IACA,OAAOnC,QAAQ,CAACmD,IAAI,CAAC,CAAC,CAACjB,KAAK,CAACC,KAAK,IAAI;MACpCA,KAAK,CAACE,MAAM,GAAG,GAAG;MAClB,MAAMF,KAAK;IACb,CAAC,CAAC;EACJ;EAEAhC,OAAOA,CAACI,KAAK,EAAE;IACb,OAAOA,KAAK;EACd;EAEA6C,WAAWA,CAACjB,KAAK,EAAE;IACjB,OAAOA,KAAK,CAACE,MAAM,IAAI,GAAG,GAAG,MAAM,GAAG1C,SAAS;EACjD;EAEA,IAAI0D,SAASA,CAAA,EAAG;IACd,OAAOjF,YAAY,CAAC,IAAI,CAAC0C,IAAI,CAAC;EAChC;EAEAwC,OAAOA,CAACvC,GAAG,EAAE;IACX,MAAMwC,MAAM,GAAG,IAAI,CAAC9C,MAAM,GAAG,GAAG,GAAG,IAAI,CAACC,SAAS;IACjD,IAAI,CAACK,GAAG,CAACiC,UAAU,CAACO,MAAM,CAAC,EAAE,OAAO,KAAK;IACzC,IAAIC,YAAY,GAAGzC,GAAG,CAAC0C,WAAW,CAAC,GAAG,CAAC;IACvC,IAAID,YAAY,KAAK,CAAC,CAAC,EAAEA,YAAY,GAAG7D,SAAS;IACjD,OAAO,IAAI,CAAC0D,SAAS,CAACK,IAAI,CAAC3C,GAAG,CAACmC,SAAS,CAACK,MAAM,CAAC9D,MAAM,EAAE+D,YAAY,CAAC,CAAC;EACxE;EAEAG,MAAMA,CAACxE,OAAO,EAAE;IACd;IACA;IACA,MAAMyE,CAAC,SAAS,IAAI,CAAC1E,WAAW,CAAC;IAEjCkB,MAAM,CAACyB,MAAM,CAAC+B,CAAC,CAACjB,SAAS,EAAE,IAAI,CAAC;IAChC,MAAMkB,QAAQ,GAAG,IAAID,CAAC,EACpB;IAAAxD,MAAA,CAAAyB,MAAA;MACExC,KAAK,EAAE,IAAI,CAACA;IAAK,GAAKF,OAAO,CACjC,CAAC;IAED,OAAO0E,QAAQ;EACjB;EAEAC,SAASA,CAACC,YAAY,EAAE;IACtB,IAAI,OAAOA,YAAY,KAAK,QAAQ,EAAE;MACpC,MAAMC,SAAS,GAAGD,YAAY;MAC9BA,YAAY,GAAGE,IAAA,IAAmB;QAAA,IAAbC,MAAM,GAAA9D,MAAA,CAAAyB,MAAA,MAAAsC,yBAAA,CAAAF,IAAA,GAAAA,IAAA;QACzB,OAAOC,MAAM,CAACF,SAAS,CAAC;QACxB,OAAO,CAACE,MAAM,CAAC;MACjB,CAAC;IACH;IACA,IAAIE,KAAK,GAAG,KAAK;IACjB,MAAMC,qBAAqB,GAAGC,UAAU,IAAI;MAC1CF,KAAK,GAAG,IAAI;MACZ,OAAOE,UAAU,CAACC,OAAO,CAAC/F,cAAc,EAAEC,eAAe,CAACsF,YAAY,CAAC,CAAC;IAC1E,CAAC;IACD,MAAMS,SAAS,GAAGlG,aAAa,CAAC,IAAI,CAACoE,MAAM,EAAE2B,qBAAqB,CAAC;IACnE,IAAID,KAAK,EAAE;MACT,OAAO,IAAI,CAACT,MAAM,CAAC;QAAEjB,MAAM,EAAE8B;MAAU,CAAC,CAAC;IAC3C;IAEA,OAAO,IAAI,CAACb,MAAM,CAAC;MAAEc,MAAM,EAAE/F,gBAAgB,CAAC,IAAI,EAAEqF,YAAY;IAAE,CAAC,CAAC;EACtE;EAEA,IAAIW,IAAIA,CAAA,EAAG;IACT,OAAO,IAAI,CAACf,MAAM,CAAC;MACjBlD,MAAM,EAAE,MAAM;MACdiC,MAAM,EAAErE,iBAAiB,CAAC,IAAI,CAACqE,MAAM,EAAEiC,CAAC,IAAIA,CAAC,CAACD,IAAI;IACpD,CAAC,CAAC;EACJ;EAEA,IAAIE,OAAOA,CAAA,EAAG;IACZ,OAAO,IAAI,CAACjB,MAAM,CAAC;MACjBlD,MAAM,EAAE,MAAM;MACdiC,MAAM,EAAErE,iBAAiB,CAAC,IAAI,CAACqE,MAAM,EAAEiC,CAAC,IAAIA,CAAC,CAACC,OAAO;IACvD,CAAC,CAAC;EACJ;EAEA,IAAI/C,MAAMA,CAAA,EAAG;IACX,OAAO,IAAI,CAAC8B,MAAM,CAAC;MACjBlD,MAAM,EAAE,MAAM;MACdiC,MAAM,EAAErE,iBAAiB,CAAC,IAAI,CAACqE,MAAM,EAAEiC,CAAC,IAAIA,CAAC,CAAC9C,MAAM;IACtD,CAAC,CAAC;EACJ;AACF;AAEA,MAAMoB,QAAQ,GAAGjB,KAAK,IAAI;EACxB,IAAI;IACF,OAAON,IAAI,CAACmD,KAAK,CAAC7C,KAAK,CAAC;EAC1B,CAAC,CAAC,OAAO8C,CAAC,EAAE;IACV,OAAOnF,SAAS;EAClB;AACF,CAAC"}

package/legacy/RestEndpointTypeHelp.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vc3JjL1Jlc3RFbmRwb2ludFR5cGVIZWxwLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHtcbiAgRmV0Y2hGdW5jdGlvbixcbiAgUmVzb2x2ZVR5cGUsXG4gIE5vcm1hbGl6ZSxcbn0gZnJvbSAnQGRhdGEtY2xpZW50L2VuZHBvaW50JztcblxuZXhwb3J0IHR5cGUgRW5kcG9pbnRVcGRhdGVGdW5jdGlvbjxcbiAgU291cmNlIGV4dGVuZHMgRmV0Y2hGdW5jdGlvbixcbiAgU2NoZW1hLFxuICBVcGRhdGVycyBleHRlbmRzIFJlY29yZDxzdHJpbmcsIGFueT4gPSBSZWNvcmQ8c3RyaW5nLCBhbnk+LFxuPiA9IChcbiAgc291cmNlOiBSZXN1bHRFbnRyeTxTb3VyY2UgJiB7IHNjaGVtYTogU2NoZW1hIH0+LFxuICAuLi5hcmdzOiBQYXJhbWV0ZXJzPFNvdXJjZT5cbikgPT4ge1xuICBbSyBpbiBrZXlvZiBVcGRhdGVyc106IChyZXN1bHQ6IFVwZGF0ZXJzW0tdKSA9PiBVcGRhdGVyc1tLXTtcbn07XG5leHBvcnQgdHlwZSBSZXN1bHRFbnRyeTxFIGV4dGVuZHMgRmV0Y2hGdW5jdGlvbiAmIHsgc2NoZW1hOiBhbnkgfT4gPVxuICBFWydzY2hlbWEnXSBleHRlbmRzIHVuZGVmaW5lZCB8IG51bGxcbiAgICA/IFJlc29sdmVUeXBlPEU+XG4gICAgOiBOb3JtYWxpemU8RVsnc2NoZW1hJ10+O1xuIl0sIm1hcHBpbmdzIjoiIn0=

package/legacy/RestHelpers.js

@@ -0,0 +1,33 @@
+import { compile, parse } from 'path-to-regexp';
+const urlBaseCache = Object.create(null);
+export function getUrlBase(path) {
+  if (!(path in urlBaseCache)) {
+    urlBaseCache[path] = compile(path, {
+      encode: encodeURIComponent,
+      validate: false
+    });
+  }
+  return urlBaseCache[path];
+}
+const urlTokensCache = Object.create(null);
+export function getUrlTokens(path) {
+  if (!(path in urlTokensCache)) {
+    urlTokensCache[path] = new Set(parse(path).map(t => typeof t === 'string' ? t : `${t['name']}`));
+  }
+  return urlTokensCache[path];
+}
+const proto = Object.prototype;
+const gpo = Object.getPrototypeOf;
+export function isPojo(obj) {
+  if (obj === null || typeof obj !== 'object') {
+    return false;
+  }
+  return gpo(obj) === proto;
+}
+export function shortenPath(path) {
+  // this is for when not specifying a specific item like create/list
+  let shortUrlRoot = path.substring(0, path.lastIndexOf(':'));
+  if (shortUrlRoot[shortUrlRoot.length - 1] === '/') shortUrlRoot = shortUrlRoot.substring(0, shortUrlRoot.length - 1);
+  return shortUrlRoot;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/createResource.js

@@ -0,0 +1,88 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+const _excluded = ["path", "schema", "Endpoint", "optimistic"];
+import { AbortOptimistic, schema } from '@data-client/endpoint';
+import RestEndpoint from './RestEndpoint.js';
+import { shortenPath } from './RestHelpers.js';
+const {
+  Delete
+} = schema;
+
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+export default function createResource(_ref) {
+  let {
+      path,
+      schema,
+      Endpoint = RestEndpoint,
+      optimistic
+    } = _ref,
+    extraOptions = _objectWithoutPropertiesLoose(_ref, _excluded);
+  const shortenedPath = shortenPath(path);
+  const getName = name => `${schema == null ? void 0 : schema.name}.${name}`;
+  const extraMutateOptions = Object.assign({}, extraOptions);
+  const extraPartialOptions = Object.assign({}, extraOptions);
+  const get = new Endpoint(Object.assign({}, extraOptions, {
+    path,
+    schema,
+    name: getName('get')
+  }));
+  if (optimistic) {
+    extraMutateOptions.getOptimisticResponse = optimisticUpdate;
+    extraPartialOptions.getOptimisticResponse = optimisticPartial(get);
+  }
+  const getList = new Endpoint(Object.assign({}, extraOptions, {
+    path: shortenedPath,
+    schema: [schema],
+    name: getName('getList')
+  }));
+  return {
+    get,
+    getList,
+    create: new Endpoint(Object.assign({}, extraMutateOptions, {
+      path: shortenedPath,
+      schema,
+      method: 'POST',
+      name: getName('create')
+    })),
+    update: new Endpoint(Object.assign({}, extraMutateOptions, {
+      path,
+      schema,
+      method: 'PUT',
+      name: getName('update')
+    })),
+    partialUpdate: new Endpoint(Object.assign({}, extraPartialOptions, {
+      path,
+      schema,
+      method: 'PATCH',
+      name: getName('partialUpdate')
+    })),
+    delete: new Endpoint(Object.assign({}, extraMutateOptions, {
+      path,
+      schema: schema.process ? new Delete(schema) : schema,
+      method: 'DELETE',
+      name: getName('delete'),
+      process(res, params) {
+        return res && Object.keys(res).length ? res : params;
+      },
+      getOptimisticResponse: optimistic ? optimisticDelete : undefined
+    }))
+  };
+}
+function optimisticUpdate(snap, params, body) {
+  return Object.assign({}, params, body);
+}
+function optimisticPartial(getEndpoint) {
+  return function (snap, params, body) {
+    const {
+      data
+    } = snap.getResponse(getEndpoint, params);
+    if (!data) throw new AbortOptimistic();
+    return Object.assign({}, params, data, body);
+  };
+}
+function optimisticDelete(snap, params) {
+  return params;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["AbortOptimistic","schema","RestEndpoint","shortenPath","Delete","createResource","_ref","path","Endpoint","optimistic","extraOptions","_objectWithoutPropertiesLoose","_excluded","shortenedPath","getName","name","extraMutateOptions","Object","assign","extraPartialOptions","get","getOptimisticResponse","optimisticUpdate","optimisticPartial","getList","create","method","update","partialUpdate","delete","process","res","params","keys","length","optimisticDelete","undefined","snap","body","getEndpoint","data","getResponse"],"sources":["../src/createResource.ts"],"sourcesContent":["import {\n  AbortOptimistic,\n  schema,\n  SnapshotInterface,\n} from '@data-client/endpoint';\nimport type {\n  Schema,\n  Denormalize,\n  EndpointExtraOptions,\n} from '@data-client/endpoint';\n\nimport { PathArgs, ShortenPath } from './pathTypes.js';\nimport RestEndpoint, {\n  NewGetEndpoint,\n  NewMutateEndpoint,\n  RestInstance,\n  RestTypeNoBody,\n} from './RestEndpoint.js';\nimport { shortenPath } from './RestHelpers.js';\n\nconst { Delete } = schema;\n\n/** Creates collection of Endpoints for common operations on a given data/schema.\n *\n * @see https://resthooks.io/rest/api/createResource\n */\nexport default function createResource<U extends string, S extends Schema>({\n  path,\n  schema,\n  Endpoint = RestEndpoint,\n  optimistic,\n  ...extraOptions\n}: {\n  readonly path: U;\n  readonly schema: S;\n  readonly Endpoint?: typeof RestEndpoint;\n  urlPrefix?: string;\n  optimistic?: boolean;\n} & EndpointExtraOptions): Resource<U, S> {\n  const shortenedPath = shortenPath(path);\n  const getName = (name: string) => `${(schema as any)?.name}.${name}`;\n  const extraMutateOptions = { ...extraOptions };\n  const extraPartialOptions = { ...extraOptions };\n  const get: NewGetEndpoint<{ path: U }, S> = new Endpoint({\n    ...extraOptions,\n    path,\n    schema,\n    name: getName('get'),\n  });\n  if (optimistic) {\n    (extraMutateOptions as any).getOptimisticResponse = optimisticUpdate;\n    (extraPartialOptions as any).getOptimisticResponse = optimisticPartial(get);\n  }\n  const getList = new Endpoint({\n    ...extraOptions,\n    path: shortenedPath,\n    schema: [schema],\n    name: getName('getList'),\n  });\n  return {\n    get,\n    getList,\n    create: new Endpoint({\n      ...extraMutateOptions,\n      path: shortenedPath,\n      schema,\n      method: 'POST',\n      name: getName('create'),\n    }),\n    update: new Endpoint({\n      ...extraMutateOptions,\n      path,\n      schema,\n      method: 'PUT',\n      name: getName('update'),\n    }),\n    partialUpdate: new Endpoint({\n      ...extraPartialOptions,\n      path,\n      schema,\n      method: 'PATCH',\n      name: getName('partialUpdate'),\n    }),\n    delete: new Endpoint({\n      ...extraMutateOptions,\n      path,\n      schema: (schema as any).process ? new Delete(schema as any) : schema,\n      method: 'DELETE',\n      name: getName('delete'),\n      process(res, params) {\n        return res && Object.keys(res).length ? res : params;\n      },\n      getOptimisticResponse: optimistic ? (optimisticDelete as any) : undefined,\n    }),\n  } as any;\n}\n\nfunction optimisticUpdate(snap: SnapshotInterface, params: any, body: any) {\n  return {\n    ...params,\n    // even tho we don't always have two arguments, the extra one will simply be undefined which spreads fine\n    ...body,\n  };\n}\nfunction optimisticPartial(getEndpoint: NewGetEndpoint<any, any>) {\n  return function (snap: SnapshotInterface, params: any, body: any) {\n    const { data } = snap.getResponse(getEndpoint, params);\n    if (!data) throw new AbortOptimistic();\n    return {\n      ...params,\n      ...data,\n      // even tho we don't always have two arguments, the extra one will simply be undefined which spreads fine\n      ...body,\n    };\n  };\n}\nfunction optimisticDelete(snap: SnapshotInterface, params: any) {\n  return params;\n}\n\nexport interface Resource<U extends string, S extends Schema> {\n  /** Get a singular item\n   *\n   * @see https://resthooks.io/rest/api/createResource#get\n   */\n  get: NewGetEndpoint<{ path: U }, S>;\n  /** Get a list of item\n   *\n   * @see https://resthooks.io/rest/api/createResource#getlist\n   */\n  getList: NewGetEndpoint<\n    {\n      path: ShortenPath<U>;\n      searchParams: Record<string, number | string | boolean> | undefined;\n    },\n    S[]\n  >;\n  /** Create a new item (POST)\n   *\n   * @see https://resthooks.io/rest/api/createResource#create\n   */\n  create: NewMutateEndpoint<\n    { path: ShortenPath<U>; body: Partial<Denormalize<S>> },\n    S\n  >;\n  /** Update an item (PUT)\n   *\n   * @see https://resthooks.io/rest/api/createResource#update\n   */\n  update: NewMutateEndpoint<{ path: U; body: Partial<Denormalize<S>> }, S>;\n  /** Update an item (PATCH)\n   *\n   * @see https://resthooks.io/rest/api/createResource#partialupdate\n   */\n  partialUpdate: NewMutateEndpoint<\n    { path: U; body: Partial<Denormalize<S>> },\n    S\n  >;\n  /** Delete an item (DELETE)\n   *\n   * @see https://resthooks.io/rest/api/createResource#delete\n   */\n  delete: RestTypeNoBody<\n    PathArgs<U>,\n    S extends schema.EntityInterface & { process: any } ? schema.Delete<S> : S,\n    undefined,\n    Partial<PathArgs<U>>,\n    {\n      path: U;\n    }\n  >;\n}\n"],"mappings":"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"}

package/legacy/extractCollection.js

@@ -0,0 +1,14 @@
+import { schema } from '@data-client/endpoint';
+export default function extractCollection(s, mapper) {
+  if (typeof s !== 'object' || s === undefined || Array.isArray(s)) return;
+  if (s instanceof schema.Collection) {
+    return mapper(s);
+  }
+  const objCopy = Object.assign({}, s instanceof schema.Object ? s.schema : s);
+  for (const k in objCopy) {
+    if (!objCopy[k]) continue;
+    const collection = extractCollection(objCopy[k], mapper);
+    if (collection) return collection;
+  }
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/getArrayPath.js

@@ -0,0 +1,19 @@
+import { schema } from '@data-client/endpoint';
+export default function getArrayPath(s) {
+  if (typeof s !== 'object') return false;
+  if (s === undefined || s instanceof schema.Array || Array.isArray(s)) {
+    return [];
+  }
+  const o = s instanceof schema.Object ? s.schema : s;
+  for (const k in o) {
+    if (!o[k]) continue;
+    const path = getArrayPath(o[k]);
+    if (path !== false) {
+      // mutation is ok because there is only one path
+      path.unshift(k);
+      return path;
+    }
+  }
+  return false;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJzY2hlbWEiLCJnZXRBcnJheVBhdGgiLCJzIiwidW5kZWZpbmVkIiwiQXJyYXkiLCJpc0FycmF5IiwibyIsIk9iamVjdCIsImsiLCJwYXRoIiwidW5zaGlmdCJdLCJzb3VyY2VzIjpbIi4uL3NyYy9nZXRBcnJheVBhdGgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2NoZW1hLCBzY2hlbWEgfSBmcm9tICdAZGF0YS1jbGllbnQvZW5kcG9pbnQnO1xuXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBnZXRBcnJheVBhdGgoczogU2NoZW1hIHwgdW5kZWZpbmVkKTogc3RyaW5nW10gfCBmYWxzZSB7XG4gIGlmICh0eXBlb2YgcyAhPT0gJ29iamVjdCcpIHJldHVybiBmYWxzZTtcbiAgaWYgKHMgPT09IHVuZGVmaW5lZCB8fCBzIGluc3RhbmNlb2Ygc2NoZW1hLkFycmF5IHx8IEFycmF5LmlzQXJyYXkocykpIHtcbiAgICByZXR1cm4gW107XG4gIH1cbiAgY29uc3QgbzogUmVjb3JkPHN0cmluZywgU2NoZW1hPiA9XG4gICAgcyBpbnN0YW5jZW9mIHNjaGVtYS5PYmplY3QgPyAocyBhcyBhbnkpLnNjaGVtYSA6IHM7XG4gIGZvciAoY29uc3QgayBpbiBvKSB7XG4gICAgaWYgKCFvW2tdKSBjb250aW51ZTtcbiAgICBjb25zdCBwYXRoID0gZ2V0QXJyYXlQYXRoKG9ba10pO1xuICAgIGlmIChwYXRoICE9PSBmYWxzZSkge1xuICAgICAgLy8gbXV0YXRpb24gaXMgb2sgYmVjYXVzZSB0aGVyZSBpcyBvbmx5IG9uZSBwYXRoXG4gICAgICBwYXRoLnVuc2hpZnQoayk7XG4gICAgICByZXR1cm4gcGF0aDtcbiAgICB9XG4gIH1cbiAgcmV0dXJuIGZhbHNlO1xufVxuIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFpQkEsTUFBTSxRQUFRLHVCQUF1QjtBQUV0RCxlQUFlLFNBQVNDLFlBQVlBLENBQUNDLENBQXFCLEVBQW9CO0VBQzVFLElBQUksT0FBT0EsQ0FBQyxLQUFLLFFBQVEsRUFBRSxPQUFPLEtBQUs7RUFDdkMsSUFBSUEsQ0FBQyxLQUFLQyxTQUFTLElBQUlELENBQUMsWUFBWUYsTUFBTSxDQUFDSSxLQUFLLElBQUlBLEtBQUssQ0FBQ0MsT0FBTyxDQUFDSCxDQUFDLENBQUMsRUFBRTtJQUNwRSxPQUFPLEVBQUU7RUFDWDtFQUNBLE1BQU1JLENBQXlCLEdBQzdCSixDQUFDLFlBQVlGLE1BQU0sQ0FBQ08sTUFBTSxHQUFJTCxDQUFDLENBQVNGLE1BQU0sR0FBR0UsQ0FBQztFQUNwRCxLQUFLLE1BQU1NLENBQUMsSUFBSUYsQ0FBQyxFQUFFO0lBQ2pCLElBQUksQ0FBQ0EsQ0FBQyxDQUFDRSxDQUFDLENBQUMsRUFBRTtJQUNYLE1BQU1DLElBQUksR0FBR1IsWUFBWSxDQUFDSyxDQUFDLENBQUNFLENBQUMsQ0FBQyxDQUFDO0lBQy9CLElBQUlDLElBQUksS0FBSyxLQUFLLEVBQUU7TUFDbEI7TUFDQUEsSUFBSSxDQUFDQyxPQUFPLENBQUNGLENBQUMsQ0FBQztNQUNmLE9BQU9DLElBQUk7SUFDYjtFQUNGO0VBQ0EsT0FBTyxLQUFLO0FBQ2QifQ==

package/legacy/hookifyResource.js

@@ -0,0 +1,24 @@
+/** Turns a collection of Endpoints (Resource) into a collection of hooks.
+ * This is useful for Endpoints that need hooks to prepare their fetch requests.
+ *
+ * @see https://resthooks.io/rest/api/hookifyResource
+ */
+export default function hookifyResource(resource, useRequestInit) {
+  const usingResource = {};
+  Object.keys(resource).forEach(key => {
+    const endpoint = resource[key];
+    if (endpoint.extend !== undefined) usingResource[`use${capitalizeFirstLetter(key)}`] = () => {
+      // this is false positive due to the dynamic nature of assignment
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      const requestInit = useRequestInit();
+      return endpoint.extend({
+        requestInit
+      });
+    };
+  });
+  return usingResource;
+}
+function capitalizeFirstLetter(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/index.js

@@ -0,0 +1,10 @@
+Object.hasOwn = Object.hasOwn || /* istanbul ignore next */function hasOwn(it, key) {
+  return Object.prototype.hasOwnProperty.call(it, key);
+};
+export { default as RestEndpoint } from './RestEndpoint.js';
+export { default as createResource } from './createResource.js';
+export { default as hookifyResource } from './hookifyResource.js';
+export { default as NetworkError } from './NetworkError.js';
+export { default as paginationUpdate } from './paginationUpdate.js';
+export * from '@data-client/endpoint';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/mapCollection.js

@@ -0,0 +1,14 @@
+import { schema } from '@data-client/endpoint';
+export default function mapCollection(s, mapper) {
+  if (typeof s !== 'object' || s === undefined) return s;
+  if (s instanceof schema.Collection) {
+    return mapper(s);
+  }
+  const objCopy = Object.assign({}, s instanceof schema.Object ? s.schema : s);
+  for (const k in objCopy) {
+    if (!objCopy[k]) continue;
+    objCopy[k] = mapCollection(objCopy[k], mapper);
+  }
+  return objCopy;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/legacy/next/OptionsToFunction.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL25leHQvT3B0aW9uc1RvRnVuY3Rpb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBGZXRjaEZ1bmN0aW9uLCBSZXNvbHZlVHlwZSB9IGZyb20gJ0BkYXRhLWNsaWVudC9lbmRwb2ludCc7XG5cbmltcG9ydCB7XG4gIFBhcnRpYWxSZXN0R2VuZXJpY3MsXG4gIFJlc3RJbnN0YW5jZUJhc2UsXG4gIFJlc3RGZXRjaCxcbn0gZnJvbSAnLi9SZXN0RW5kcG9pbnQuanMnO1xuaW1wb3J0IHsgUGF0aEFyZ3MgfSBmcm9tICcuLi9wYXRoVHlwZXMuanMnO1xuXG5leHBvcnQgdHlwZSBPcHRpb25zVG9GdW5jdGlvbjxcbiAgTyBleHRlbmRzIFBhcnRpYWxSZXN0R2VuZXJpY3MsXG4gIEUgZXh0ZW5kcyBSZXN0SW5zdGFuY2VCYXNlICYgeyBib2R5PzogYW55IH0sXG4gIEYgZXh0ZW5kcyBGZXRjaEZ1bmN0aW9uLFxuPiA9ICdwYXRoJyBleHRlbmRzIGtleW9mIE9cbiAgPyBSZXN0RmV0Y2g8XG4gICAgICAnc2VhcmNoUGFyYW1zJyBleHRlbmRzIGtleW9mIE9cbiAgICAgICAgPyBPWydzZWFyY2hQYXJhbXMnXSAmIFBhdGhBcmdzPEV4Y2x1ZGU8T1sncGF0aCddLCB1bmRlZmluZWQ+PlxuICAgICAgICA6IFBhdGhBcmdzPEV4Y2x1ZGU8T1sncGF0aCddLCB1bmRlZmluZWQ+PixcbiAgICAgICdib2R5JyBleHRlbmRzIGtleW9mIE8gPyBPWydib2R5J10gOiBFWydib2R5J10sXG4gICAgICBPWydwcm9jZXNzJ10gZXh0ZW5kcyB7fSA/IFJldHVyblR5cGU8T1sncHJvY2VzcyddPiA6IFJlc29sdmVUeXBlPEY+XG4gICAgPlxuICA6ICdib2R5JyBleHRlbmRzIGtleW9mIE9cbiAgPyBSZXN0RmV0Y2g8XG4gICAgICAnc2VhcmNoUGFyYW1zJyBleHRlbmRzIGtleW9mIE9cbiAgICAgICAgPyBPWydzZWFyY2hQYXJhbXMnXSAmIFBhdGhBcmdzPEV4Y2x1ZGU8RVsncGF0aCddLCB1bmRlZmluZWQ+PlxuICAgICAgICA6IFBhdGhBcmdzPEV4Y2x1ZGU8RVsncGF0aCddLCB1bmRlZmluZWQ+PixcbiAgICAgIE9bJ2JvZHknXSxcbiAgICAgIE9bJ3Byb2Nlc3MnXSBleHRlbmRzIHt9ID8gUmV0dXJuVHlwZTxPWydwcm9jZXNzJ10+IDogUmVzb2x2ZVR5cGU8Rj5cbiAgICA+XG4gIDogJ3NlYXJjaFBhcmFtcycgZXh0ZW5kcyBrZXlvZiBPXG4gID8gUmVzdEZldGNoPFxuICAgICAgT1snc2VhcmNoUGFyYW1zJ10gJiBQYXRoQXJnczxFeGNsdWRlPEVbJ3BhdGgnXSwgdW5kZWZpbmVkPj4sXG4gICAgICBFWydib2R5J10sXG4gICAgICBPWydwcm9jZXNzJ10gZXh0ZW5kcyB7fSA/IFJldHVyblR5cGU8T1sncHJvY2VzcyddPiA6IFJlc29sdmVUeXBlPEY+XG4gICAgPlxuICA6IChcbiAgICAgIHRoaXM6IFRoaXNQYXJhbWV0ZXJUeXBlPEY+LFxuICAgICAgLi4uYXJnczogUGFyYW1ldGVyczxGPlxuICAgICkgPT4gUHJvbWlzZTxcbiAgICAgIE9bJ3Byb2Nlc3MnXSBleHRlbmRzIHt9ID8gUmV0dXJuVHlwZTxPWydwcm9jZXNzJ10+IDogUmVzb2x2ZVR5cGU8Rj5cbiAgICA+O1xuIl0sIm1hcHBpbmdzIjoiIn0=