@pranaysahith/decap-cms-core 3.9.1

package/dist/esm/lib/serializeEntryValues.js

@@ -0,0 +1,67 @@
+import isNil from 'lodash/isNil';
+import { Map, List } from 'immutable';
+import { getWidgetValueSerializer } from './registry';
+
+/**
+ * Methods for serializing/deserializing entry field values. Most widgets don't
+ * require this for their values, and those that do can typically serialize/
+ * deserialize on every change from within the widget. The serialization
+ * handlers here are for widgets whose values require heavy serialization that
+ * would hurt performance if run for every change.
+
+ * An example of this is the markdown widget, whose value is stored as a
+ * markdown string. Instead of stringifying on every change of that field, a
+ * deserialization method is registered from the widget's control module that
+ * converts the stored markdown string to an AST, and that AST serves as the
+ * widget model during editing.
+ *
+ * Serialization handlers should be registered for each widget that requires
+ * them, and the registration method is exposed through the registry. Any
+ * registered deserialization handlers run on entry load, and serialization
+ * handlers run on persist.
+ */
+function runSerializer(values, fields, method) {
+  /**
+   * Reduce the list of fields to a map where keys are field names and values
+   * are field values, serializing the values of fields whose widgets have
+   * registered serializers.  If the field is a list or object, call recursively
+   * for nested fields.
+   */
+  let serializedData = fields.reduce((acc, field) => {
+    const fieldName = field.get('name');
+    const value = values.get(fieldName);
+    const serializer = getWidgetValueSerializer(field.get('widget'));
+    const nestedFields = field.get('fields');
+
+    // Call recursively for fields within lists
+    if (nestedFields && List.isList(value)) {
+      return acc.set(fieldName, value.map(val => runSerializer(val, nestedFields, method)));
+    }
+
+    // Call recursively for fields within objects
+    if (nestedFields && Map.isMap(value)) {
+      return acc.set(fieldName, runSerializer(value, nestedFields, method));
+    }
+
+    // Run serialization method on value if not null or undefined
+    if (serializer && !isNil(value)) {
+      return acc.set(fieldName, serializer[method](value));
+    }
+
+    // If no serializer is registered for the field's widget, use the field as is
+    if (!isNil(value)) {
+      return acc.set(fieldName, value);
+    }
+    return acc;
+  }, Map());
+
+  //preserve unknown fields value
+  serializedData = values.mergeDeep(serializedData);
+  return serializedData;
+}
+export function serializeValues(values, fields) {
+  return runSerializer(values, fields, 'serialize');
+}
+export function deserializeValues(values, fields) {
+  return runSerializer(values, fields, 'deserialize');
+}

package/dist/esm/lib/stega.js

@@ -0,0 +1,142 @@
+import { vercelStegaEncode } from '@vercel/stega';
+import { isImmutableMap, isImmutableList } from '../types/immutable';
+
+/**
+ * Context passed to encode functions, containing the current state of the encoding process
+ */
+
+/**
+ * Get the fields that should be used for encoding nested values
+ */
+function getNestedFields(f) {
+  if (f) {
+    if ('types' in f) {
+      return f.types ?? [];
+    }
+    if ('fields' in f) {
+      return f.fields ?? [];
+    }
+    if ('field' in f) {
+      return f.field ? [f.field] : [];
+    }
+    return [f];
+  }
+  return [];
+}
+
+/**
+ * Encode a string value by appending steganographic data
+ * For markdown fields, encode each paragraph separately
+ */
+function encodeString(value, {
+  fields,
+  path
+}) {
+  const [field] = fields;
+  if (!field) return value;
+  const {
+    widget
+  } = field;
+  if (widget === 'string' || widget === 'text') {
+    if ('visualEditing' in field && field.visualEditing === false) return value;
+    const stega = vercelStegaEncode({
+      decap: path
+    });
+    return value + stega;
+  }
+  if (widget === 'markdown') {
+    const stega = vercelStegaEncode({
+      decap: path
+    });
+    const blocks = value.split(/(\n\n+)/);
+    return blocks.map(block => block.trim() ? block + stega : block).join('');
+  }
+  return value;
+}
+
+/**
+ * Encode a list of values, handling both simple values and nested objects/lists
+ * For typed lists, use the type field to determine which fields to use
+ */
+function encodeList(list, ctx) {
+  let newList = list;
+  for (let i = 0; i < newList.size; i++) {
+    const item = newList.get(i);
+    if (isImmutableMap(item)) {
+      const itemType = item.get('type');
+      if (typeof itemType === 'string') {
+        // For typed items, look up fields based on type
+        const field = ctx.fields.find(f => f.name === itemType);
+        const newItem = ctx.visit(item, getNestedFields(field), `${ctx.path}.${i}`);
+        newList = newList.set(i, newItem);
+      } else {
+        // For untyped items, use current fields
+        const newItem = ctx.visit(item, ctx.fields, `${ctx.path}.${i}`);
+        newList = newList.set(i, newItem);
+      }
+    } else {
+      // For simple values, use first field if available
+      const field = ctx.fields[0];
+      const newItem = ctx.visit(item, field ? [field] : [], `${ctx.path}.${i}`);
+      if (newItem !== item) {
+        newList = newList.set(i, newItem);
+      }
+    }
+  }
+  return newList;
+}
+
+/**
+ * Encode a map of values, looking up the appropriate field for each key
+ * and recursively encoding nested values
+ */
+function encodeMap(map, ctx) {
+  let newMap = map;
+  for (const [key, val] of newMap.entrySeq().toArray()) {
+    const field = ctx.fields.find(f => f.name === key);
+    if (field) {
+      const fields = getNestedFields(field);
+      const newVal = ctx.visit(val, fields, ctx.path ? `${ctx.path}.${key}` : key);
+      if (newVal !== val) {
+        newMap = newMap.set(key, newVal);
+      }
+    }
+  }
+  return newMap;
+}
+
+/**
+ * Cache for encoded values to prevent re-encoding unchanged values
+ * across keystrokes. The cache is keyed by path.
+ */
+const encodingCache = new Map();
+
+/**
+ * Main entry point for encoding steganographic data into entry values
+ * Uses a visitor pattern with caching to handle recursive structures
+ */
+export function encodeEntry(value, fields) {
+  const plainFields = fields.toJS();
+  function visit(value, fields, path = '') {
+    const cached = encodingCache.get(path);
+    if (cached === value) return value;
+    const ctx = {
+      fields,
+      path,
+      visit
+    };
+    let result;
+    if (isImmutableList(value)) {
+      result = encodeList(value, ctx);
+    } else if (isImmutableMap(value)) {
+      result = encodeMap(value, ctx);
+    } else if (typeof value === 'string') {
+      result = encodeString(value, ctx);
+    } else {
+      result = value;
+    }
+    encodingCache.set(path, result);
+    return result;
+  }
+  return visit(value, plainFields);
+}

package/dist/esm/lib/textHelper.js

@@ -0,0 +1,9 @@
+export function stringToRGB(str) {
+  if (!str) return '000000';
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = str.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const c = (hash & 0x00ffffff).toString(16).toUpperCase();
+  return `00000${c}`.slice(-6);
+}

package/dist/esm/lib/urlHelper.js

@@ -0,0 +1,111 @@
+import url from 'url';
+import urlJoin from 'url-join';
+import diacritics from 'diacritics';
+import sanitizeFilename from 'sanitize-filename';
+import isString from 'lodash/isString';
+import escapeRegExp from 'lodash/escapeRegExp';
+import flow from 'lodash/flow';
+import partialRight from 'lodash/partialRight';
+function getUrl(urlString, direct) {
+  return `${direct ? '/#' : ''}${urlString}`;
+}
+export function getCollectionUrl(collectionName, direct) {
+  return getUrl(`/collections/${collectionName}`, direct);
+}
+export function getNewEntryUrl(collectionName, direct) {
+  return getUrl(`/collections/${collectionName}/new`, direct);
+}
+export function addParams(urlString, params) {
+  const parsedUrl = url.parse(urlString, true);
+  parsedUrl.query = {
+    ...parsedUrl.query,
+    ...params
+  };
+  return url.format(parsedUrl);
+}
+export function stripProtocol(urlString) {
+  const protocolEndIndex = urlString.indexOf('//');
+  return protocolEndIndex > -1 ? urlString.slice(protocolEndIndex + 2) : urlString;
+}
+
+/* See https://www.w3.org/International/articles/idn-and-iri/#path.
+ * According to the new IRI (Internationalized Resource Identifier) spec, RFC 3987,
+ *   ASCII chars should be kept the same way as in standard URIs (letters digits _ - . ~).
+ * Non-ASCII chars (unless they are not in the allowed "ucschars" list) should be percent-encoded.
+ * If the string is not encoded in Unicode, it should be converted to UTF-8 and normalized first,
+ *   but JS stores strings as UTF-16/UCS-2 internally, so we should not normalize or re-encode.
+ */
+const uriChars = /[\w\-.~]/i;
+const ucsChars = /[\xA0-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFEF}\u{10000}-\u{1FFFD}\u{20000}-\u{2FFFD}\u{30000}-\u{3FFFD}\u{40000}-\u{4FFFD}\u{50000}-\u{5FFFD}\u{60000}-\u{6FFFD}\u{70000}-\u{7FFFD}\u{80000}-\u{8FFFD}\u{90000}-\u{9FFFD}\u{A0000}-\u{AFFFD}\u{B0000}-\u{BFFFD}\u{C0000}-\u{CFFFD}\u{D0000}-\u{DFFFD}\u{E1000}-\u{EFFFD}]/u;
+function validURIChar(char) {
+  return uriChars.test(char);
+}
+function validIRIChar(char) {
+  return uriChars.test(char) || ucsChars.test(char);
+}
+export function getCharReplacer(encoding, replacement) {
+  let validChar;
+  if (encoding === 'unicode') {
+    validChar = validIRIChar;
+  } else if (encoding === 'ascii') {
+    validChar = validURIChar;
+  } else {
+    throw new Error('`options.encoding` must be "unicode" or "ascii".');
+  }
+
+  // Check and make sure the replacement character is actually a safe char itself.
+  if (!Array.from(replacement).every(validChar)) {
+    throw new Error('The replacement character(s) (options.replacement) is itself unsafe.');
+  }
+  return char => validChar(char) ? char : replacement;
+}
+// `sanitizeURI` does not actually URI-encode the chars (that is the browser's and server's job), just removes the ones that are not allowed.
+export function sanitizeURI(str, options) {
+  const {
+    replacement = '',
+    encoding = 'unicode'
+  } = options || {};
+  if (!isString(str)) {
+    throw new Error('The input slug must be a string.');
+  }
+  if (!isString(replacement)) {
+    throw new Error('`options.replacement` must be a string.');
+  }
+
+  // `Array.from` must be used instead of `String.split` because
+  //   `split` converts things like emojis into UTF-16 surrogate pairs.
+  return Array.from(str).map(getCharReplacer(encoding, replacement)).join('');
+}
+export function sanitizeChar(char, options) {
+  const {
+    encoding = 'unicode',
+    sanitize_replacement: replacement = ''
+  } = options || {};
+  return getCharReplacer(encoding, replacement)(char);
+}
+export function sanitizeSlug(str, options) {
+  if (!isString(str)) {
+    throw new Error('The input slug must be a string.');
+  }
+  const {
+    encoding,
+    clean_accents: stripDiacritics,
+    sanitize_replacement: replacement
+  } = options || {};
+  const sanitizedSlug = flow([...(stripDiacritics ? [diacritics.remove] : []), partialRight(sanitizeURI, {
+    replacement,
+    encoding
+  }), partialRight(sanitizeFilename, {
+    replacement
+  })])(str);
+
+  // Remove any doubled or leading/trailing replacement characters (that were added in the sanitizers).
+  const doubleReplacement = new RegExp(`(?:${escapeRegExp(replacement)})+`, 'g');
+  const trailingReplacement = new RegExp(`${escapeRegExp(replacement)}$`);
+  const leadingReplacement = new RegExp(`^${escapeRegExp(replacement)}`);
+  const normalizedSlug = sanitizedSlug.replace(doubleReplacement, replacement).replace(leadingReplacement, '').replace(trailingReplacement, '');
+  return normalizedSlug;
+}
+export function joinUrlPath(base, ...path) {
+  return urlJoin(base, ...path);
+}

package/dist/esm/mediaLibrary.js

@@ -0,0 +1,37 @@
+/**
+ * This module is currently concerned only with external media libraries
+ * registered via `registerMediaLibrary`.
+ */
+import once from 'lodash/once';
+import { getMediaLibrary } from './lib/registry';
+import { store } from './redux';
+import { configFailed } from './actions/config';
+import { createMediaLibrary, insertMedia } from './actions/mediaLibrary';
+function handleInsert(url) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return store.dispatch(insertMedia(url, undefined));
+}
+const initializeMediaLibrary = once(async function initializeMediaLibrary(name, options) {
+  const lib = getMediaLibrary(name);
+  if (!lib) {
+    const err = new Error(`Missing external media library '${name}'. Please use 'registerMediaLibrary' to register it.`);
+    store.dispatch(configFailed(err));
+  } else {
+    const instance = await lib.init({
+      options,
+      handleInsert
+    });
+    store.dispatch(createMediaLibrary(instance));
+  }
+});
+store.subscribe(() => {
+  const state = store.getState();
+  if (state) {
+    const mediaLibraryName = state.config.media_library?.name;
+    if (mediaLibraryName && !state.mediaLibrary.get('externalLibrary')) {
+      const mediaLibraryConfig = state.config.media_library;
+      initializeMediaLibrary(mediaLibraryName, mediaLibraryConfig);
+    }
+  }
+});

package/dist/esm/reducers/auth.js

@@ -0,0 +1,27 @@
+import { produce } from 'immer';
+import { AUTH_REQUEST, AUTH_SUCCESS, AUTH_FAILURE, AUTH_REQUEST_DONE, LOGOUT } from '../actions/auth';
+export const defaultState = {
+  isFetching: false,
+  user: undefined,
+  error: undefined
+};
+const auth = produce((state, action) => {
+  switch (action.type) {
+    case AUTH_REQUEST:
+      state.isFetching = true;
+      break;
+    case AUTH_SUCCESS:
+      state.user = action.payload;
+      break;
+    case AUTH_FAILURE:
+      state.error = action.payload && action.payload.toString();
+      break;
+    case AUTH_REQUEST_DONE:
+      state.isFetching = false;
+      break;
+    case LOGOUT:
+      state.user = undefined;
+      state.isFetching = false;
+  }
+}, defaultState);
+export default auth;