@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/constants/validationErrorTypes.js

@@ -0,0 +1,6 @@
+export default {
+  PRESENCE: 'PRESENCE',
+  PATTERN: 'PATTERN',
+  RANGE: 'RANGE',
+  CUSTOM: 'CUSTOM'
+};

package/dist/esm/formats/formats.js

@@ -0,0 +1,83 @@
+import { List } from 'immutable';
+import get from 'lodash/get';
+import yamlFormatter from './yaml';
+import tomlFormatter from './toml';
+import jsonFormatter from './json';
+import { FrontmatterInfer, frontmatterJSON, frontmatterTOML, frontmatterYAML } from './frontmatter';
+import { getCustomFormatsExtensions, getCustomFormatsFormatters } from '../lib/registry';
+export const frontmatterFormats = ['yaml-frontmatter', 'toml-frontmatter', 'json-frontmatter'];
+export const formatExtensions = {
+  yml: 'yml',
+  yaml: 'yml',
+  toml: 'toml',
+  json: 'json',
+  frontmatter: 'md',
+  'json-frontmatter': 'md',
+  'toml-frontmatter': 'md',
+  'yaml-frontmatter': 'md'
+};
+export function getFormatExtensions() {
+  return {
+    ...formatExtensions,
+    ...getCustomFormatsExtensions()
+  };
+}
+export const extensionFormatters = {
+  yml: yamlFormatter,
+  yaml: yamlFormatter,
+  toml: tomlFormatter,
+  json: jsonFormatter,
+  md: FrontmatterInfer,
+  markdown: FrontmatterInfer,
+  html: FrontmatterInfer
+};
+function formatByName(name, customDelimiter) {
+  const formatters = {
+    yml: yamlFormatter,
+    yaml: yamlFormatter,
+    toml: tomlFormatter,
+    json: jsonFormatter,
+    frontmatter: FrontmatterInfer,
+    'json-frontmatter': frontmatterJSON(customDelimiter),
+    'toml-frontmatter': frontmatterTOML(customDelimiter),
+    'yaml-frontmatter': frontmatterYAML(customDelimiter),
+    ...getCustomFormatsFormatters()
+  };
+  if (name in formatters) {
+    return formatters[name];
+  }
+  throw new Error(`No formatter available with name: ${name}`);
+}
+function frontmatterDelimiterIsList(frontmatterDelimiter) {
+  return List.isList(frontmatterDelimiter);
+}
+export 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 get(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 get(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,146 @@
+import matter from 'gray-matter';
+import tomlFormatter from './toml';
+import yamlFormatter from './yaml';
+import jsonFormatter from './json';
+const Languages = {
+  YAML: 'yaml',
+  TOML: 'toml',
+  JSON: 'json'
+};
+const parsers = {
+  toml: {
+    parse: input => tomlFormatter.fromFile(input),
+    stringify: (metadata, opts) => {
+      const {
+        sortedKeys
+      } = opts || {};
+      return tomlFormatter.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 jsonFormatter.fromFile(JSONinput);
+    },
+    stringify: metadata => {
+      let JSONoutput = jsonFormatter.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 => yamlFormatter.fromFile(input),
+    stringify: (metadata, opts) => {
+      const {
+        sortedKeys,
+        comments
+      } = opts || {};
+      return yamlFormatter.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.');
+  }
+}
+export 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
+  };
+}
+export class FrontmatterFormatter {
+  constructor(format, customDelimiter) {
+    this.format = getFormatOpts(format, customDelimiter);
+  }
+  fromFile(content) {
+    const format = this.format || inferFrontmatterFormat(content);
+    const result = matter(content, {
+      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 {
+      ...result.data,
+      ...(result.content.trim() && {
+        body: result.content
+      })
+    };
+  }
+  toFile(data, sortedKeys, comments) {
+    const {
+      body = '',
+      ...meta
+    } = data;
+
+    // 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 = matter.stringify(body, meta, {
+      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;
+  }
+}
+export const FrontmatterInfer = new FrontmatterFormatter();
+export function frontmatterYAML(customDelimiter) {
+  return new FrontmatterFormatter(Languages.YAML, customDelimiter);
+}
+export function frontmatterTOML(customDelimiter) {
+  return new FrontmatterFormatter(Languages.TOML, customDelimiter);
+}
+export function frontmatterJSON(customDelimiter) {
+  return new FrontmatterFormatter(Languages.JSON, customDelimiter);
+}

package/dist/esm/formats/helpers.js

@@ -0,0 +1,12 @@
+export 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,8 @@
+export default {
+  fromFile(content) {
+    return JSON.parse(content);
+  },
+  toFile(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};

package/dist/esm/formats/toml.js

@@ -0,0 +1,32 @@
+import parseToml from '@iarna/toml/parse-string';
+import tomlify from 'tomlify-j0.4';
+import dayjs from 'dayjs';
+import AssetProxy from '../valueObjects/AssetProxy';
+import { sortKeys } from './helpers';
+function outputReplacer(_key, value) {
+  if (dayjs.isDayjs(value)) {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    return value.format(value._f);
+  }
+  if (value instanceof AssetProxy) {
+    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;
+}
+export default {
+  fromFile(content) {
+    return parseToml(content);
+  },
+  toFile(data, sortedKeys = []) {
+    return tomlify.toToml(data, {
+      replace: outputReplacer,
+      sort: sortKeys(sortedKeys)
+    });
+  }
+};

package/dist/esm/formats/yaml.js

@@ -0,0 +1,51 @@
+import yaml from 'yaml';
+import { sortKeys } from './helpers';
+function addComments(items, comments, prefix = '') {
+  items.forEach(item => {
+    if (item.key !== undefined) {
+      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?.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()
+};
+export default {
+  fromFile(content) {
+    if (content && content.trim().endsWith('---')) {
+      content = content.trim().slice(0, -3);
+    }
+    return yaml.parse(content, {
+      customTags: [timestampTag]
+    });
+  },
+  toFile(data, sortedKeys = [], comments = {}) {
+    const contents = yaml.createNode(data);
+    addComments(contents.items, comments);
+    contents.items.sort(sortKeys(sortedKeys, item => item.key?.toString()));
+    const doc = new yaml.Document();
+    doc.contents = contents;
+    return doc.toString();
+  }
+};

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import bootstrap from './bootstrap';
+import Registry from './lib/registry';
+export const DecapCmsCore = {
+  ...Registry,
+  init: bootstrap
+};
+export default DecapCmsCore;

package/dist/esm/integrations/index.js

@@ -0,0 +1,28 @@
+import { Map } from 'immutable';
+import Algolia from './providers/algolia/implementation';
+import AssetStore from './providers/assetStore/implementation';
+export function resolveIntegrations(integrationsConfig, getToken) {
+  let integrationInstances = Map({});
+  integrationsConfig.get('providers').forEach((providerData, providerName) => {
+    switch (providerName) {
+      case 'algolia':
+        integrationInstances = integrationInstances.set('algolia', new Algolia(providerData));
+        break;
+      case 'assetStore':
+        integrationInstances = integrationInstances.set('assetStore', new AssetStore(providerData, getToken));
+        break;
+    }
+  });
+  return integrationInstances;
+}
+export const getIntegrationProvider = function () {
+  let integrations = null;
+  return (integrationsConfig, getToken, provider) => {
+    if (integrations) {
+      return integrations.get(provider);
+    } else {
+      integrations = resolveIntegrations(integrationsConfig, getToken);
+      return integrations.get(provider);
+    }
+  };
+}();

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

@@ -0,0 +1,174 @@
+import flatten from 'lodash/flatten';
+import { unsentRequest } from 'decap-cms-lib-util';
+import { createEntry } from '../../../valueObjects/Entry';
+import { selectEntrySlug } from '../../../reducers/collections';
+const {
+  fetchWithTimeout: fetch
+} = unsentRequest;
+function getSlug(path) {
+  return path.split('/').pop().replace(/\.[^.]+$/, '');
+}
+export default 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 {
+      '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, {
+      ...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 createEntry(collections[index], slug, hit.path, {
+          data: hit.data,
+          partial: true
+        });
+      }));
+      return {
+        entries: flatten(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 = selectEntrySlug(collection, hit.path);
+          return 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: {
+          ...params,
+          page
+        }
+      });
+      hits = [...hits, ...response.hits];
+      page = page + 1;
+    }
+    const entries = hits.map(hit => {
+      const slug = selectEntrySlug(collection, hit.path);
+      return 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 createEntry(collection.get('name'), slug, entry.path, {
+        data: entry.data,
+        partial: true
+      });
+    });
+  }
+}