decap-cms-core 2.56.0-beta.1

package/dist/esm/constants/publishModes.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.statusDescriptions = exports.status = exports.Statues = exports.SIMPLE = exports.EDITORIAL_WORKFLOW = void 0;
+var _immutable = require("immutable");
+// Create/edit workflow modes
+const SIMPLE = 'simple';
+exports.SIMPLE = SIMPLE;
+const EDITORIAL_WORKFLOW = 'editorial_workflow';
+exports.EDITORIAL_WORKFLOW = EDITORIAL_WORKFLOW;
+const Statues = {
+  DRAFT: 'draft',
+  PENDING_REVIEW: 'pending_review',
+  PENDING_PUBLISH: 'pending_publish'
+};
+
+// Available status
+exports.Statues = Statues;
+const status = (0, _immutable.OrderedMap)(Statues);
+exports.status = status;
+const statusDescriptions = (0, _immutable.Map)({
+  [status.get('DRAFT')]: 'Draft',
+  [status.get('PENDING_REVIEW')]: 'Waiting for Review',
+  [status.get('PENDING_PUBLISH')]: 'Waiting to go live'
+});
+exports.statusDescriptions = statusDescriptions;

package/dist/esm/constants/validationErrorTypes.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  PRESENCE: 'PRESENCE',
+  PATTERN: 'PATTERN',
+  RANGE: 'RANGE',
+  CUSTOM: 'CUSTOM'
+};
+exports.default = _default;

package/dist/esm/formats/formats.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.frontmatterFormats = exports.formatExtensions = exports.extensionFormatters = void 0;
+exports.resolveFormat = resolveFormat;
+var _get2 = _interopRequireDefault(require("lodash/get"));
+var _immutable = require("immutable");
+var _yaml = _interopRequireDefault(require("./yaml"));
+var _toml = _interopRequireDefault(require("./toml"));
+var _json = _interopRequireDefault(require("./json"));
+var _frontmatter = require("./frontmatter");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const frontmatterFormats = ['yaml-frontmatter', 'toml-frontmatter', 'json-frontmatter'];
+exports.frontmatterFormats = frontmatterFormats;
+const formatExtensions = {
+  yml: 'yml',
+  yaml: 'yml',
+  toml: 'toml',
+  json: 'json',
+  frontmatter: 'md',
+  'json-frontmatter': 'md',
+  'toml-frontmatter': 'md',
+  'yaml-frontmatter': 'md'
+};
+exports.formatExtensions = formatExtensions;
+const extensionFormatters = {
+  yml: _yaml.default,
+  yaml: _yaml.default,
+  toml: _toml.default,
+  json: _json.default,
+  md: _frontmatter.FrontmatterInfer,
+  markdown: _frontmatter.FrontmatterInfer,
+  html: _frontmatter.FrontmatterInfer
+};
+exports.extensionFormatters = extensionFormatters;
+function formatByName(name, customDelimiter) {
+  return {
+    yml: _yaml.default,
+    yaml: _yaml.default,
+    toml: _toml.default,
+    json: _json.default,
+    frontmatter: _frontmatter.FrontmatterInfer,
+    'json-frontmatter': (0, _frontmatter.frontmatterJSON)(customDelimiter),
+    'toml-frontmatter': (0, _frontmatter.frontmatterTOML)(customDelimiter),
+    'yaml-frontmatter': (0, _frontmatter.frontmatterYAML)(customDelimiter)
+  }[name];
+}
+function frontmatterDelimiterIsList(frontmatterDelimiter) {
+  return _immutable.List.isList(frontmatterDelimiter);
+}
+function resolveFormat(collection, entry) {
+  // Check for custom delimiter
+  const frontmatter_delimiter = collection.get('frontmatter_delimiter');
+  const customDelimiter = frontmatterDelimiterIsList(frontmatter_delimiter) ? frontmatter_delimiter.toArray() : frontmatter_delimiter;
+
+  // If the format is specified in the collection, use that format.
+  const formatSpecification = collection.get('format');
+  if (formatSpecification) {
+    return formatByName(formatSpecification, customDelimiter);
+  }
+
+  // If a file already exists, infer the format from its file extension.
+  const filePath = entry && entry.path;
+  if (filePath) {
+    const fileExtension = filePath.split('.').pop();
+    if (fileExtension) {
+      return (0, _get2.default)(extensionFormatters, fileExtension);
+    }
+  }
+
+  // If creating a new file, and an `extension` is specified in the
+  //   collection config, infer the format from that extension.
+  const extension = collection.get('extension');
+  if (extension) {
+    return (0, _get2.default)(extensionFormatters, extension);
+  }
+
+  // If no format is specified and it cannot be inferred, return the default.
+  return formatByName('frontmatter', customDelimiter);
+}

package/dist/esm/formats/frontmatter.js

@@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FrontmatterInfer = exports.FrontmatterFormatter = void 0;
+exports.frontmatterJSON = frontmatterJSON;
+exports.frontmatterTOML = frontmatterTOML;
+exports.frontmatterYAML = frontmatterYAML;
+exports.getFormatOpts = getFormatOpts;
+var _grayMatter = _interopRequireDefault(require("gray-matter"));
+var _toml = _interopRequireDefault(require("./toml"));
+var _yaml = _interopRequireDefault(require("./yaml"));
+var _json = _interopRequireDefault(require("./json"));
+const _excluded = ["body"];
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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); }
+const Languages = {
+  YAML: 'yaml',
+  TOML: 'toml',
+  JSON: 'json'
+};
+const parsers = {
+  toml: {
+    parse: input => _toml.default.fromFile(input),
+    stringify: (metadata, opts) => {
+      const {
+        sortedKeys
+      } = opts || {};
+      return _toml.default.toFile(metadata, sortedKeys);
+    }
+  },
+  json: {
+    parse: input => {
+      let JSONinput = input.trim();
+      // Fix JSON if leading and trailing brackets were trimmed.
+      if (JSONinput.slice(0, 1) !== '{') {
+        JSONinput = '{' + JSONinput + '}';
+      }
+      return _json.default.fromFile(JSONinput);
+    },
+    stringify: metadata => {
+      let JSONoutput = _json.default.toFile(metadata).trim();
+      // Trim leading and trailing brackets.
+      if (JSONoutput.slice(0, 1) === '{' && JSONoutput.slice(-1) === '}') {
+        JSONoutput = JSONoutput.slice(1, -1);
+      }
+      return JSONoutput;
+    }
+  },
+  yaml: {
+    parse: input => _yaml.default.fromFile(input),
+    stringify: (metadata, opts) => {
+      const {
+        sortedKeys,
+        comments
+      } = opts || {};
+      return _yaml.default.toFile(metadata, sortedKeys, comments);
+    }
+  }
+};
+function inferFrontmatterFormat(str) {
+  const lineEnd = str.indexOf('\n');
+  const firstLine = str.slice(0, lineEnd !== -1 ? lineEnd : 0).trim();
+  if (firstLine.length > 3 && firstLine.slice(0, 3) === '---') {
+    // No need to infer, `gray-matter` will handle things like `---toml` for us.
+    return;
+  }
+  switch (firstLine) {
+    case '---':
+      return getFormatOpts(Languages.YAML);
+    case '+++':
+      return getFormatOpts(Languages.TOML);
+    case '{':
+      return getFormatOpts(Languages.JSON);
+    default:
+      console.warn('Unrecognized front-matter format.');
+  }
+}
+function getFormatOpts(format, customDelimiter) {
+  if (!format) {
+    return undefined;
+  }
+  const formats = {
+    yaml: {
+      language: Languages.YAML,
+      delimiters: '---'
+    },
+    toml: {
+      language: Languages.TOML,
+      delimiters: '+++'
+    },
+    json: {
+      language: Languages.JSON,
+      delimiters: ['{', '}']
+    }
+  };
+  const {
+    language,
+    delimiters
+  } = formats[format];
+  return {
+    language,
+    delimiters: customDelimiter || delimiters
+  };
+}
+class FrontmatterFormatter {
+  constructor(format, customDelimiter) {
+    _defineProperty(this, "format", void 0);
+    this.format = getFormatOpts(format, customDelimiter);
+  }
+  fromFile(content) {
+    const format = this.format || inferFrontmatterFormat(content);
+    const result = (0, _grayMatter.default)(content, _objectSpread({
+      engines: parsers
+    }, format));
+    // in the absent of a body when serializing an entry we use an empty one
+    // when calling `toFile`, so we don't want to add it when parsing.
+    return _objectSpread(_objectSpread({}, result.data), result.content.trim() && {
+      body: result.content
+    });
+  }
+  toFile(data, sortedKeys, comments) {
+    const {
+        body = ''
+      } = data,
+      meta = _objectWithoutProperties(data, _excluded);
+
+    // Stringify to YAML if the format was not set
+    const format = this.format || getFormatOpts(Languages.YAML);
+
+    // gray-matter always adds a line break at the end which trips our
+    // change detection logic
+    // https://github.com/jonschlinkert/gray-matter/issues/96
+    const trimLastLineBreak = body.slice(-1) !== '\n';
+    const file = _grayMatter.default.stringify(body, meta, _objectSpread({
+      engines: parsers,
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore `sortedKeys` is not recognized by gray-matter, so it gets passed through to the parser
+      sortedKeys,
+      comments
+    }, format));
+    return trimLastLineBreak && file.slice(-1) === '\n' ? file.slice(0, -1) : file;
+  }
+}
+exports.FrontmatterFormatter = FrontmatterFormatter;
+const FrontmatterInfer = new FrontmatterFormatter();
+exports.FrontmatterInfer = FrontmatterInfer;
+function frontmatterYAML(customDelimiter) {
+  return new FrontmatterFormatter(Languages.YAML, customDelimiter);
+}
+function frontmatterTOML(customDelimiter) {
+  return new FrontmatterFormatter(Languages.TOML, customDelimiter);
+}
+function frontmatterJSON(customDelimiter) {
+  return new FrontmatterFormatter(Languages.JSON, customDelimiter);
+}

package/dist/esm/formats/helpers.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortKeys = sortKeys;
+function sortKeys(sortedKeys,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+selector = a => a) {
+  return (a, b) => {
+    const idxA = sortedKeys.indexOf(selector(a));
+    const idxB = sortedKeys.indexOf(selector(b));
+    if (idxA === -1 || idxB === -1) return 0;
+    if (idxA > idxB) return 1;
+    if (idxA < idxB) return -1;
+    return 0;
+  };
+}

package/dist/esm/formats/json.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = {
+  fromFile(content) {
+    return JSON.parse(content);
+  },
+  toFile(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};
+exports.default = _default;

package/dist/esm/formats/toml.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _toml = _interopRequireDefault(require("@iarna/toml"));
+var _tomlifyJ = _interopRequireDefault(require("tomlify-j0.4"));
+var _moment = _interopRequireDefault(require("moment"));
+var _AssetProxy = _interopRequireDefault(require("../valueObjects/AssetProxy"));
+var _helpers = require("./helpers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function outputReplacer(_key, value) {
+  if (_moment.default.isMoment(value)) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return value.format(value._f);
+  }
+  if (value instanceof _AssetProxy.default) {
+    return `${value.path}`;
+  }
+  if (typeof value === 'number' && Number.isInteger(value)) {
+    // Return the string representation of integers so tomlify won't render with tenths (".0")
+    return value.toString();
+  }
+  // Return `false` to use default (`undefined` would delete key).
+  return false;
+}
+var _default = {
+  fromFile(content) {
+    return _toml.default.parse(content);
+  },
+  toFile(data, sortedKeys = []) {
+    return _tomlifyJ.default.toToml(data, {
+      replace: outputReplacer,
+      sort: (0, _helpers.sortKeys)(sortedKeys)
+    });
+  }
+};
+exports.default = _default;

package/dist/esm/formats/yaml.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _yaml = _interopRequireDefault(require("yaml"));
+var _helpers = require("./helpers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function addComments(items, comments, prefix = '') {
+  items.forEach(item => {
+    if (item.key !== undefined) {
+      var _item$value;
+      const itemKey = item.key.toString();
+      const key = prefix ? `${prefix}.${itemKey}` : itemKey;
+      if (comments[key]) {
+        const value = comments[key].split('\\n').join('\n ');
+        item.commentBefore = ` ${value}`;
+      }
+      if (Array.isArray((_item$value = item.value) === null || _item$value === void 0 ? void 0 : _item$value.items)) {
+        addComments(item.value.items, comments, key);
+      }
+    }
+  });
+}
+const timestampTag = {
+  identify: value => value instanceof Date,
+  default: true,
+  tag: '!timestamp',
+  test: RegExp('^' + '([0-9]{4})-([0-9]{2})-([0-9]{2})' +
+  // YYYY-MM-DD
+  'T' +
+  // T
+  '([0-9]{2}):([0-9]{2}):([0-9]{2}(\\.[0-9]+)?)' +
+  // HH:MM:SS(.ss)?
+  'Z' +
+  // Z
+  '$'),
+  resolve: str => new Date(str),
+  stringify: value => value.toISOString()
+};
+var _default = {
+  fromFile(content) {
+    if (content && content.trim().endsWith('---')) {
+      content = content.trim().slice(0, -3);
+    }
+    return _yaml.default.parse(content, {
+      customTags: [timestampTag]
+    });
+  },
+  toFile(data, sortedKeys = [], comments = {}) {
+    const contents = _yaml.default.createNode(data);
+    addComments(contents.items, comments);
+    contents.items.sort((0, _helpers.sortKeys)(sortedKeys, item => {
+      var _item$key;
+      return (_item$key = item.key) === null || _item$key === void 0 ? void 0 : _item$key.toString();
+    }));
+    const doc = new _yaml.default.Document();
+    doc.contents = contents;
+    return doc.toString();
+  }
+};
+exports.default = _default;

package/dist/esm/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.DecapCmsCore = void 0;
+var _bootstrap = _interopRequireDefault(require("./bootstrap"));
+var _registry = _interopRequireDefault(require("./lib/registry"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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); }
+const DecapCmsCore = _objectSpread(_objectSpread({}, _registry.default), {}, {
+  init: _bootstrap.default
+});
+exports.DecapCmsCore = DecapCmsCore;
+var _default = DecapCmsCore;
+exports.default = _default;

package/dist/esm/integrations/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getIntegrationProvider = void 0;
+exports.resolveIntegrations = resolveIntegrations;
+var _immutable = require("immutable");
+var _implementation = _interopRequireDefault(require("./providers/algolia/implementation"));
+var _implementation2 = _interopRequireDefault(require("./providers/assetStore/implementation"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function resolveIntegrations(interationsConfig, getToken) {
+  let integrationInstances = (0, _immutable.Map)({});
+  interationsConfig.get('providers').forEach((providerData, providerName) => {
+    switch (providerName) {
+      case 'algolia':
+        integrationInstances = integrationInstances.set('algolia', new _implementation.default(providerData));
+        break;
+      case 'assetStore':
+        integrationInstances = integrationInstances.set('assetStore', new _implementation2.default(providerData, getToken));
+        break;
+    }
+  });
+  return integrationInstances;
+}
+const getIntegrationProvider = function () {
+  let integrations = null;
+  return (interationsConfig, getToken, provider) => {
+    if (integrations) {
+      return integrations.get(provider);
+    } else {
+      integrations = resolveIntegrations(interationsConfig, getToken);
+      return integrations.get(provider);
+    }
+  };
+}();
+exports.getIntegrationProvider = getIntegrationProvider;

package/dist/esm/integrations/providers/algolia/implementation.js

@@ -0,0 +1,184 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _flatten2 = _interopRequireDefault(require("lodash/flatten"));
+var _decapCmsLibUtil = require("decap-cms-lib-util");
+var _Entry = require("../../../valueObjects/Entry");
+var _collections = require("../../../reducers/collections");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+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); }
+const {
+  fetchWithTimeout: fetch
+} = _decapCmsLibUtil.unsentRequest;
+function getSlug(path) {
+  return path.split('/').pop().replace(/\.[^.]+$/, '');
+}
+class Algolia {
+  constructor(config) {
+    this.config = config;
+    if (config.get('applicationID') == null || config.get('apiKey') == null) {
+      throw 'The Algolia search integration needs the credentials (applicationID and apiKey) in the integration configuration.';
+    }
+    this.applicationID = config.get('applicationID');
+    this.apiKey = config.get('apiKey');
+    const prefix = config.get('indexPrefix');
+    this.indexPrefix = prefix ? `${prefix}-` : '';
+    this.searchURL = `https://${this.applicationID}-dsn.algolia.net/1`;
+    this.entriesCache = {
+      collection: null,
+      page: null,
+      entries: []
+    };
+  }
+  requestHeaders(headers = {}) {
+    return _objectSpread({
+      'X-Algolia-API-Key': this.apiKey,
+      'X-Algolia-Application-Id': this.applicationID,
+      'Content-Type': 'application/json'
+    }, headers);
+  }
+  parseJsonResponse(response) {
+    return response.json().then(json => {
+      if (!response.ok) {
+        return Promise.reject(json);
+      }
+      return json;
+    });
+  }
+  urlFor(path, options) {
+    const params = [];
+    if (options.params) {
+      for (const key in options.params) {
+        params.push(`${key}=${encodeURIComponent(options.params[key])}`);
+      }
+    }
+    if (params.length) {
+      path += `?${params.join('&')}`;
+    }
+    return path;
+  }
+  request(path, options = {}) {
+    const headers = this.requestHeaders(options.headers || {});
+    const url = this.urlFor(path, options);
+    return fetch(url, _objectSpread(_objectSpread({}, options), {}, {
+      headers
+    })).then(response => {
+      const contentType = response.headers.get('Content-Type');
+      if (contentType && contentType.match(/json/)) {
+        return this.parseJsonResponse(response);
+      }
+      return response.text();
+    });
+  }
+  search(collections, searchTerm, page) {
+    const searchCollections = collections.map(collection => ({
+      indexName: `${this.indexPrefix}${collection}`,
+      params: `query=${searchTerm}&page=${page}`
+    }));
+    return this.request(`${this.searchURL}/indexes/*/queries`, {
+      method: 'POST',
+      body: JSON.stringify({
+        requests: searchCollections
+      })
+    }).then(response => {
+      const entries = response.results.map((result, index) => result.hits.map(hit => {
+        const slug = getSlug(hit.path);
+        return (0, _Entry.createEntry)(collections[index], slug, hit.path, {
+          data: hit.data,
+          partial: true
+        });
+      }));
+      return {
+        entries: (0, _flatten2.default)(entries),
+        pagination: page
+      };
+    });
+  }
+  searchBy(field, collection, query) {
+    return this.request(`${this.searchURL}/indexes/${this.indexPrefix}${collection}`, {
+      params: {
+        restrictSearchableAttributes: field,
+        query
+      }
+    });
+  }
+  listEntries(collection, page) {
+    if (this.entriesCache.collection === collection && this.entriesCache.page === page) {
+      return Promise.resolve({
+        page: this.entriesCache.page,
+        entries: this.entriesCache.entries
+      });
+    } else {
+      return this.request(`${this.searchURL}/indexes/${this.indexPrefix}${collection.get('name')}`, {
+        params: {
+          page
+        }
+      }).then(response => {
+        const entries = response.hits.map(hit => {
+          const slug = (0, _collections.selectEntrySlug)(collection, hit.path);
+          return (0, _Entry.createEntry)(collection.get('name'), slug, hit.path, {
+            data: hit.data,
+            partial: true
+          });
+        });
+        this.entriesCache = {
+          collection,
+          pagination: response.page,
+          entries
+        };
+        return {
+          entries,
+          pagination: response.page
+        };
+      });
+    }
+  }
+  async listAllEntries(collection) {
+    const params = {
+      hitsPerPage: 1000
+    };
+    let response = await this.request(`${this.searchURL}/indexes/${this.indexPrefix}${collection.get('name')}`, {
+      params
+    });
+    let {
+      nbPages = 0,
+      hits,
+      page
+    } = response;
+    page = page + 1;
+    while (page < nbPages) {
+      response = await this.request(`${this.searchURL}/indexes/${this.indexPrefix}${collection.get('name')}`, {
+        params: _objectSpread(_objectSpread({}, params), {}, {
+          page
+        })
+      });
+      hits = [...hits, ...response.hits];
+      page = page + 1;
+    }
+    const entries = hits.map(hit => {
+      const slug = (0, _collections.selectEntrySlug)(collection, hit.path);
+      return (0, _Entry.createEntry)(collection.get('name'), slug, hit.path, {
+        data: hit.data,
+        partial: true
+      });
+    });
+    return entries;
+  }
+  getEntry(collection, slug) {
+    return this.searchBy('slug', collection.get('name'), slug).then(response => {
+      const entry = response.hits.filter(hit => hit.slug === slug)[0];
+      return (0, _Entry.createEntry)(collection.get('name'), slug, entry.path, {
+        data: entry.data,
+        partial: true
+      });
+    });
+  }
+}
+exports.default = Algolia;