decap-cms-lib-util 2.16.0-beta.0

package/dist/esm/API.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PreviewState = void 0;
+exports.getPreviewStatus = getPreviewStatus;
+exports.isPreviewContext = isPreviewContext;
+exports.readFile = readFile;
+exports.readFileMetadata = readFileMetadata;
+exports.requestWithBackoff = requestWithBackoff;
+exports.throwOnConflictingBranches = throwOnConflictingBranches;
+var _asyncLock = require("./asyncLock");
+var _unsentRequest = _interopRequireDefault(require("./unsentRequest"));
+var _APIError = _interopRequireDefault(require("./APIError"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+class RateLimitError extends _extendableBuiltin(Error) {
+  constructor(message, resetSeconds) {
+    super(message);
+    _defineProperty(this, "resetSeconds", void 0);
+    if (resetSeconds < 0) {
+      this.resetSeconds = 1;
+    } else if (resetSeconds > 60 * 60) {
+      this.resetSeconds = 60 * 60;
+    } else {
+      this.resetSeconds = resetSeconds;
+    }
+  }
+}
+async function requestWithBackoff(api, req, attempt = 1) {
+  if (api.rateLimiter) {
+    await api.rateLimiter.acquire();
+  }
+  try {
+    const builtRequest = await api.buildRequest(req);
+    const requestFunction = api.requestFunction || _unsentRequest.default.performRequest;
+    const response = await requestFunction(builtRequest);
+    if (response.status === 429) {
+      // GitLab/Bitbucket too many requests
+      const text = await response.text().catch(() => 'Too many requests');
+      throw new Error(text);
+    } else if (response.status === 403) {
+      // GitHub too many requests
+      const json = await response.json().catch(() => ({
+        message: ''
+      }));
+      if (json.message.match('API rate limit exceeded')) {
+        const now = new Date();
+        const nextWindowInSeconds = response.headers.has('X-RateLimit-Reset') ? parseInt(response.headers.get('X-RateLimit-Reset')) : now.getTime() / 1000 + 60;
+        throw new RateLimitError(json.message, nextWindowInSeconds);
+      }
+      response.json = () => Promise.resolve(json);
+    }
+    return response;
+  } catch (err) {
+    if (attempt > 5 || err.message === "Can't refresh access token when using implicit auth") {
+      throw err;
+    } else {
+      if (!api.rateLimiter) {
+        const timeout = err.resetSeconds || attempt * attempt;
+        console.log(`Pausing requests for ${timeout} ${attempt === 1 ? 'second' : 'seconds'} due to fetch failures:`, err.message);
+        api.rateLimiter = (0, _asyncLock.asyncLock)();
+        api.rateLimiter.acquire();
+        setTimeout(() => {
+          var _api$rateLimiter;
+          (_api$rateLimiter = api.rateLimiter) === null || _api$rateLimiter === void 0 ? void 0 : _api$rateLimiter.release();
+          api.rateLimiter = undefined;
+          console.log(`Done pausing requests`);
+        }, 1000 * timeout);
+      }
+      return requestWithBackoff(api, req, attempt + 1);
+    }
+  }
+}
+async function readFile(id, fetchContent, localForage, isText) {
+  const key = id ? isText ? `gh.${id}` : `gh.${id}.blob` : null;
+  const cached = key ? await localForage.getItem(key) : null;
+  if (cached) {
+    return cached;
+  }
+  const content = await fetchContent();
+  if (key) {
+    await localForage.setItem(key, content);
+  }
+  return content;
+}
+function getFileMetadataKey(id) {
+  return `gh.${id}.meta`;
+}
+async function readFileMetadata(id, fetchMetadata, localForage) {
+  const key = id ? getFileMetadataKey(id) : null;
+  const cached = key && (await localForage.getItem(key));
+  if (cached) {
+    return cached;
+  }
+  const metadata = await fetchMetadata();
+  if (key) {
+    await localForage.setItem(key, metadata);
+  }
+  return metadata;
+}
+
+/**
+ * Keywords for inferring a status that will provide a deploy preview URL.
+ */
+const PREVIEW_CONTEXT_KEYWORDS = ['deploy'];
+
+/**
+ * Check a given status context string to determine if it provides a link to a
+ * deploy preview. Checks for an exact match against `previewContext` if given,
+ * otherwise checks for inclusion of a value from `PREVIEW_CONTEXT_KEYWORDS`.
+ */
+function isPreviewContext(context, previewContext) {
+  if (previewContext) {
+    return context === previewContext;
+  }
+  return PREVIEW_CONTEXT_KEYWORDS.some(keyword => context.includes(keyword));
+}
+let PreviewState = /*#__PURE__*/function (PreviewState) {
+  PreviewState["Other"] = "other";
+  PreviewState["Success"] = "success";
+  return PreviewState;
+}({});
+/**
+ * Retrieve a deploy preview URL from an array of statuses. By default, a
+ * matching status is inferred via `isPreviewContext`.
+ */
+exports.PreviewState = PreviewState;
+function getPreviewStatus(statuses, previewContext) {
+  return statuses.find(({
+    context
+  }) => {
+    return isPreviewContext(context, previewContext);
+  });
+}
+function getConflictingBranches(branchName) {
+  // for cms/posts/post-1, conflicting branches are cms/posts, cms
+  const parts = branchName.split('/');
+  parts.pop();
+  const conflictingBranches = parts.reduce((acc, _, index) => {
+    acc = [...acc, parts.slice(0, index + 1).join('/')];
+    return acc;
+  }, []);
+  return conflictingBranches;
+}
+async function throwOnConflictingBranches(branchName, getBranch, apiName) {
+  const possibleConflictingBranches = getConflictingBranches(branchName);
+  const conflictingBranches = await Promise.all(possibleConflictingBranches.map(b => getBranch(b).then(b => b.name).catch(() => '')));
+  const conflictingBranch = conflictingBranches.filter(Boolean)[0];
+  if (conflictingBranch) {
+    throw new _APIError.default(`Failed creating branch '${branchName}' since there is already a branch named '${conflictingBranch}'. Please delete the '${conflictingBranch}' branch and try again`, 500, apiName);
+  }
+}

package/dist/esm/APIError.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.API_ERROR = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+const API_ERROR = 'API_ERROR';
+exports.API_ERROR = API_ERROR;
+class APIError extends _extendableBuiltin(Error) {
+  constructor(message, status, api, meta = {}) {
+    super(message);
+    _defineProperty(this, "message", void 0);
+    _defineProperty(this, "status", void 0);
+    _defineProperty(this, "api", void 0);
+    _defineProperty(this, "meta", void 0);
+    this.message = message;
+    this.status = status;
+    this.api = api;
+    this.name = API_ERROR;
+    this.meta = meta;
+  }
+}
+exports.default = APIError;

package/dist/esm/APIUtils.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MERGE_COMMIT_MESSAGE = exports.DEFAULT_PR_BODY = exports.CMS_BRANCH_PREFIX = void 0;
+exports.branchFromContentKey = branchFromContentKey;
+exports.contentKeyFromBranch = contentKeyFromBranch;
+exports.generateContentKey = generateContentKey;
+exports.isCMSLabel = isCMSLabel;
+exports.labelToStatus = labelToStatus;
+exports.parseContentKey = parseContentKey;
+exports.statusToLabel = statusToLabel;
+const CMS_BRANCH_PREFIX = 'cms';
+exports.CMS_BRANCH_PREFIX = CMS_BRANCH_PREFIX;
+const DEFAULT_PR_BODY = 'Automatically generated by Decap CMS';
+exports.DEFAULT_PR_BODY = DEFAULT_PR_BODY;
+const MERGE_COMMIT_MESSAGE = 'Automatically generated. Merged on Decap CMS.';
+exports.MERGE_COMMIT_MESSAGE = MERGE_COMMIT_MESSAGE;
+const DEFAULT_DECAP_CMS_LABEL_PREFIX = 'decap-cms/';
+function getLabelPrefix(labelPrefix) {
+  return labelPrefix || DEFAULT_DECAP_CMS_LABEL_PREFIX;
+}
+function isCMSLabel(label, labelPrefix) {
+  return label.startsWith(getLabelPrefix(labelPrefix));
+}
+function labelToStatus(label, labelPrefix) {
+  return label.slice(getLabelPrefix(labelPrefix).length);
+}
+function statusToLabel(status, labelPrefix) {
+  return `${getLabelPrefix(labelPrefix)}${status}`;
+}
+function generateContentKey(collectionName, slug) {
+  return `${collectionName}/${slug}`;
+}
+function parseContentKey(contentKey) {
+  const index = contentKey.indexOf('/');
+  return {
+    collection: contentKey.slice(0, index),
+    slug: contentKey.slice(index + 1)
+  };
+}
+function contentKeyFromBranch(branch) {
+  return branch.slice(`${CMS_BRANCH_PREFIX}/`.length);
+}
+function branchFromContentKey(contentKey) {
+  return `${CMS_BRANCH_PREFIX}/${contentKey}`;
+}

package/dist/esm/AccessTokenError.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.ACCESS_TOKEN_ERROR = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+const ACCESS_TOKEN_ERROR = 'ACCESS_TOKEN_ERROR';
+exports.ACCESS_TOKEN_ERROR = ACCESS_TOKEN_ERROR;
+class AccessTokenError extends _extendableBuiltin(Error) {
+  constructor(message) {
+    super(message);
+    _defineProperty(this, "message", void 0);
+    this.message = message;
+    this.name = ACCESS_TOKEN_ERROR;
+  }
+}
+exports.default = AccessTokenError;

package/dist/esm/Cursor.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.CURSOR_COMPATIBILITY_SYMBOL = void 0;
+var _immutable = require("immutable");
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function jsToMap(obj) {
+  if (obj === undefined) {
+    return (0, _immutable.Map)();
+  }
+  const immutableObj = (0, _immutable.fromJS)(obj);
+  if (!_immutable.Map.isMap(immutableObj)) {
+    throw new Error('Object must be equivalent to a Map.');
+  }
+  return immutableObj;
+}
+const knownMetaKeys = (0, _immutable.Set)(['index', 'page', 'count', 'pageSize', 'pageCount', 'usingOldPaginationAPI', 'extension', 'folder', 'depth']);
+function filterUnknownMetaKeys(meta) {
+  return meta.filter((_v, k) => knownMetaKeys.has(k));
+}
+
+/*
+  createCursorMap takes one of three signatures:
+  - () -> cursor with empty actions, data, and meta
+  - (cursorMap: <object/Map with optional actions, data, and meta keys>) -> cursor
+  - (actions: <array/List>, data: <object/Map>, meta: <optional object/Map>) -> cursor
+*/
+function createCursorStore(...args) {
+  const {
+    actions,
+    data,
+    meta
+  } = args.length === 1 ? jsToMap(args[0]).toObject() : {
+    actions: args[0],
+    data: args[1],
+    meta: args[2]
+  };
+  return (0, _immutable.Map)({
+    // actions are a Set, rather than a List, to ensure an efficient .has
+    actions: (0, _immutable.Set)(actions),
+    // data and meta are Maps
+    data: jsToMap(data),
+    meta: jsToMap(meta).update(filterUnknownMetaKeys)
+  });
+}
+function hasAction(store, action) {
+  return store.hasIn(['actions', action]);
+}
+function getActionHandlers(store, handler) {
+  return store.get('actions', (0, _immutable.Set)()).toMap().map(action => handler(action));
+}
+
+// The cursor logic is entirely functional, so this class simply
+// provides a chainable interface
+class Cursor {
+  static create(...args) {
+    return new Cursor(...args);
+  }
+  constructor(...args) {
+    _defineProperty(this, "store", void 0);
+    _defineProperty(this, "actions", void 0);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _defineProperty(this, "data", void 0);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _defineProperty(this, "meta", void 0);
+    if (args[0] instanceof Cursor) {
+      return args[0];
+    }
+    this.store = createCursorStore(...args);
+    this.actions = this.store.get('actions');
+    this.data = this.store.get('data');
+    this.meta = this.store.get('meta');
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  updateStore(...args) {
+    return new Cursor(this.store.update(...args));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  updateInStore(...args) {
+    return new Cursor(this.store.updateIn(...args));
+  }
+  hasAction(action) {
+    return hasAction(this.store, action);
+  }
+  addAction(action) {
+    return this.updateStore('actions', actions => actions.add(action));
+  }
+  removeAction(action) {
+    return this.updateStore('actions', actions => actions.delete(action));
+  }
+  setActions(actions) {
+    return this.updateStore(store => store.set('actions', (0, _immutable.Set)(actions)));
+  }
+  mergeActions(actions) {
+    return this.updateStore('actions', oldActions => oldActions.union(actions));
+  }
+  getActionHandlers(handler) {
+    return getActionHandlers(this.store, handler);
+  }
+  setData(data) {
+    return new Cursor(this.store.set('data', jsToMap(data)));
+  }
+  mergeData(data) {
+    return new Cursor(this.store.mergeIn(['data'], jsToMap(data)));
+  }
+  wrapData(data) {
+    return this.updateStore('data', oldData => jsToMap(data).set('wrapped_cursor_data', oldData));
+  }
+  unwrapData() {
+    return [this.store.get('data').delete('wrapped_cursor_data'), this.updateStore('data', data => data.get('wrapped_cursor_data'))];
+  }
+  clearData() {
+    return this.updateStore('data', () => (0, _immutable.Map)());
+  }
+  setMeta(meta) {
+    return this.updateStore(store => store.set('meta', jsToMap(meta)));
+  }
+  mergeMeta(meta) {
+    return this.updateStore(store => store.update('meta', oldMeta => oldMeta.merge(jsToMap(meta))));
+  }
+}
+
+// This is a temporary hack to allow cursors to be added to the
+// interface between backend.js and backends without modifying old
+// backends at all. This should be removed in favor of wrapping old
+// backends with a compatibility layer, as part of the backend API
+// refactor.
+exports.default = Cursor;
+const CURSOR_COMPATIBILITY_SYMBOL = Symbol('cursor key for compatibility with old backends');
+exports.CURSOR_COMPATIBILITY_SYMBOL = CURSOR_COMPATIBILITY_SYMBOL;

package/dist/esm/EditorialWorkflowError.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.EDITORIAL_WORKFLOW_ERROR = void 0;
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _extendableBuiltin(cls) {
+  function ExtendableBuiltin() {
+    var instance = Reflect.construct(cls, Array.from(arguments));
+    Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+    return instance;
+  }
+  ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+    constructor: {
+      value: cls,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (Object.setPrototypeOf) {
+    Object.setPrototypeOf(ExtendableBuiltin, cls);
+  } else {
+    ExtendableBuiltin.__proto__ = cls;
+  }
+  return ExtendableBuiltin;
+}
+const EDITORIAL_WORKFLOW_ERROR = 'EDITORIAL_WORKFLOW_ERROR';
+exports.EDITORIAL_WORKFLOW_ERROR = EDITORIAL_WORKFLOW_ERROR;
+class EditorialWorkflowError extends _extendableBuiltin(Error) {
+  constructor(message, notUnderEditorialWorkflow) {
+    super(message);
+    _defineProperty(this, "message", void 0);
+    _defineProperty(this, "notUnderEditorialWorkflow", void 0);
+    this.message = message;
+    this.notUnderEditorialWorkflow = notUnderEditorialWorkflow;
+    this.name = EDITORIAL_WORKFLOW_ERROR;
+  }
+}
+exports.default = EditorialWorkflowError;

package/dist/esm/asyncLock.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.asyncLock = asyncLock;
+var _semaphore = _interopRequireDefault(require("semaphore"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function asyncLock() {
+  let lock = (0, _semaphore.default)(1);
+  function acquire(timeout = 15000) {
+    const promise = new Promise(resolve => {
+      // this makes sure a caller doesn't gets stuck forever awaiting on the lock
+      const timeoutId = setTimeout(() => {
+        // we reset the lock in that case to allow future consumers to use it without being blocked
+        lock = (0, _semaphore.default)(1);
+        resolve(false);
+      }, timeout);
+      lock.take(() => {
+        clearTimeout(timeoutId);
+        resolve(true);
+      });
+    });
+    return promise;
+  }
+  function release() {
+    try {
+      // suppress too many calls to leave error
+      lock.leave();
+    } catch (e) {
+      // calling 'leave' too many times might not be good behavior
+      // but there is no reason to completely fail on it
+      if (e.message !== 'leave called too many times.') {
+        throw e;
+      } else {
+        console.warn('leave called too many times.');
+        lock = (0, _semaphore.default)(1);
+      }
+    }
+  }
+  return {
+    acquire,
+    release
+  };
+}

package/dist/esm/backendUtil.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterByExtension = filterByExtension;
+exports.getAllResponses = getAllResponses;
+exports.getPathDepth = getPathDepth;
+exports.parseLinkHeader = parseLinkHeader;
+exports.parseResponse = parseResponse;
+exports.responseParser = responseParser;
+var _map2 = _interopRequireDefault(require("lodash/fp/map"));
+var _fromPairs2 = _interopRequireDefault(require("lodash/fromPairs"));
+var _flow2 = _interopRequireDefault(require("lodash/flow"));
+var _immutable = require("immutable");
+var _unsentRequest = _interopRequireDefault(require("./unsentRequest"));
+var _APIError = _interopRequireDefault(require("./APIError"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function filterByExtension(file, extension) {
+  const path = (file === null || file === void 0 ? void 0 : file.path) || '';
+  return path.endsWith(extension.startsWith('.') ? extension : `.${extension}`);
+}
+function catchFormatErrors(format, formatter) {
+  return res => {
+    try {
+      return formatter(res);
+    } catch (err) {
+      throw new Error(`Response cannot be parsed into the expected format (${format}): ${err.message}`);
+    }
+  };
+}
+const responseFormatters = (0, _immutable.fromJS)({
+  json: async res => {
+    const contentType = res.headers.get('Content-Type') || '';
+    if (!contentType.startsWith('application/json') && !contentType.startsWith('text/json')) {
+      throw new Error(`${contentType} is not a valid JSON Content-Type`);
+    }
+    return res.json();
+  },
+  text: async res => res.text(),
+  blob: async res => res.blob()
+}).mapEntries(([format, formatter]) => [format, catchFormatErrors(format, formatter)]);
+async function parseResponse(res, {
+  expectingOk = true,
+  format = 'text',
+  apiName = ''
+}) {
+  let body;
+  try {
+    const formatter = responseFormatters.get(format, false);
+    if (!formatter) {
+      throw new Error(`${format} is not a supported response format.`);
+    }
+    body = await formatter(res);
+  } catch (err) {
+    throw new _APIError.default(err.message, res.status, apiName);
+  }
+  if (expectingOk && !res.ok) {
+    var _body$error;
+    const isJSON = format === 'json';
+    const message = isJSON ? body.message || body.msg || ((_body$error = body.error) === null || _body$error === void 0 ? void 0 : _body$error.message) : body;
+    throw new _APIError.default(isJSON && message ? message : body, res.status, apiName);
+  }
+  return body;
+}
+function responseParser(options) {
+  return res => parseResponse(res, options);
+}
+function parseLinkHeader(header) {
+  if (!header) {
+    return {};
+  }
+  return (0, _flow2.default)([linksString => linksString.split(','), (0, _map2.default)(str => str.trim().split(';')), (0, _map2.default)(([linkStr, keyStr]) => [keyStr.match(/rel="(.*?)"/)[1], linkStr.trim().match(/<(.*?)>/)[1].replace(/\+/g, '%20')]), _fromPairs2.default])(header);
+}
+async function getAllResponses(url, options = {}, linkHeaderRelName, nextUrlProcessor) {
+  const maxResponses = 30;
+  let responseCount = 1;
+  let req = _unsentRequest.default.fromFetchArguments(url, options);
+  const pageResponses = [];
+  while (req && responseCount < maxResponses) {
+    const pageResponse = await _unsentRequest.default.performRequest(req);
+    const linkHeader = pageResponse.headers.get('Link');
+    const nextURL = linkHeader && parseLinkHeader(linkHeader)[linkHeaderRelName];
+    const {
+      headers = {}
+    } = options;
+    req = nextURL && _unsentRequest.default.fromFetchArguments(nextUrlProcessor(nextURL), {
+      headers
+    });
+    pageResponses.push(pageResponse);
+    responseCount++;
+  }
+  return pageResponses;
+}
+function getPathDepth(path) {
+  const depth = path.split('/').length;
+  return depth;
+}

package/dist/esm/getBlobSHA.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _jsSha = require("js-sha256");
+var _default = blob => new Promise((resolve, reject) => {
+  const fr = new FileReader();
+  fr.onload = ({
+    target
+  }) => resolve((0, _jsSha.sha256)((target === null || target === void 0 ? void 0 : target.result) || ''));
+  fr.onerror = err => {
+    fr.abort();
+    reject(err);
+  };
+  fr.readAsArrayBuffer(blob);
+});
+exports.default = _default;