@evfrenkel/decap-cms-core 3.13.0-image-conversions.0

package/dist/esm/lib/registry.js

@@ -0,0 +1,332 @@
+import { Map } from 'immutable';
+import { produce } from 'immer';
+import { oneLine } from 'common-tags';
+import EditorComponent from '../valueObjects/EditorComponent';
+const allowedEvents = ['prePublish', 'postPublish', 'preUnpublish', 'postUnpublish', 'preSave', 'postSave'];
+const eventHandlers = {};
+allowedEvents.forEach(e => {
+  eventHandlers[e] = [];
+});
+
+/**
+ * Global Registry Object
+ */
+const registry = {
+  backends: {},
+  templates: {},
+  previewStyles: [],
+  widgets: {},
+  editorComponents: Map(),
+  remarkPlugins: [],
+  widgetValueSerializers: {},
+  mediaLibraries: [],
+  locales: {},
+  eventHandlers,
+  formats: {}
+};
+export default {
+  registerPreviewStyle,
+  getPreviewStyles,
+  registerPreviewTemplate,
+  getPreviewTemplate,
+  registerWidget,
+  getWidget,
+  getWidgets,
+  resolveWidget,
+  registerEditorComponent,
+  getEditorComponents,
+  registerRemarkPlugin,
+  getRemarkPlugins,
+  registerWidgetValueSerializer,
+  getWidgetValueSerializer,
+  registerBackend,
+  getBackend,
+  registerMediaLibrary,
+  getMediaLibrary,
+  registerLocale,
+  getLocale,
+  registerEventListener,
+  removeEventListener,
+  getEventListeners,
+  invokeEvent,
+  registerCustomFormat,
+  getCustomFormats,
+  getCustomFormatsExtensions,
+  getCustomFormatsFormatters
+};
+
+/**
+ * Preview Styles
+ *
+ * Valid options:
+ *  - raw {boolean} if `true`, `style` value is expected to be a CSS string
+ */
+export function registerPreviewStyle(style, opts) {
+  registry.previewStyles.push({
+    ...opts,
+    value: style
+  });
+}
+export function getPreviewStyles() {
+  return registry.previewStyles;
+}
+
+/**
+ * Preview Templates
+ */
+export function registerPreviewTemplate(name, component) {
+  registry.templates[name] = component;
+}
+export function getPreviewTemplate(name) {
+  return registry.templates[name];
+}
+
+/**
+ * Editor Widgets
+ */
+export function registerWidget(name, control, preview, schema = {}) {
+  if (Array.isArray(name)) {
+    name.forEach(widget => {
+      if (typeof widget !== 'object') {
+        console.error(`Cannot register widget: ${widget}`);
+      } else {
+        registerWidget(widget);
+      }
+    });
+  } else if (typeof name === 'string') {
+    // A registered widget control can be reused by a new widget, allowing
+    // multiple copies with different previews.
+    const newControl = typeof control === 'string' ? registry.widgets[control].control : control;
+    registry.widgets[name] = {
+      control: newControl,
+      preview,
+      schema
+    };
+  } else if (typeof name === 'object') {
+    const {
+      name: widgetName,
+      controlComponent: control,
+      previewComponent: preview,
+      schema = {},
+      allowMapValue,
+      globalStyles,
+      ...options
+    } = name;
+    if (registry.widgets[widgetName]) {
+      console.warn(oneLine`
+        Multiple widgets registered with name "${widgetName}". Only the last widget registered with
+        this name will be used.
+      `);
+    }
+    if (!control) {
+      throw Error(`Widget "${widgetName}" registered without \`controlComponent\`.`);
+    }
+    registry.widgets[widgetName] = {
+      control,
+      preview,
+      schema,
+      globalStyles,
+      allowMapValue,
+      ...options
+    };
+  } else {
+    console.error('`registerWidget` failed, called with incorrect arguments.');
+  }
+}
+export function getWidget(name) {
+  return registry.widgets[name];
+}
+export function getWidgets() {
+  return produce(Object.entries(registry.widgets), draft => {
+    return draft.map(([key, value]) => ({
+      name: key,
+      ...value
+    }));
+  });
+}
+export function resolveWidget(name) {
+  return getWidget(name || 'string') || getWidget('unknown');
+}
+
+/**
+ * Markdown Editor Custom Components
+ */
+export function registerEditorComponent(component) {
+  const plugin = EditorComponent(component);
+  if (plugin.type === 'code-block') {
+    const codeBlock = registry.editorComponents.find(c => c.type === 'code-block');
+    if (codeBlock) {
+      console.warn(oneLine`
+        Only one editor component of type "code-block" may be registered. Previously registered code
+        block component(s) will be overwritten.
+      `);
+      registry.editorComponents = registry.editorComponents.delete(codeBlock.id);
+    }
+  }
+  registry.editorComponents = registry.editorComponents.set(plugin.id, plugin);
+}
+export function getEditorComponents() {
+  return registry.editorComponents;
+}
+
+/**
+ * Remark plugins
+ */
+/** @typedef {import('unified').Pluggable} RemarkPlugin */
+/** @type {(plugin: RemarkPlugin) => void} */
+export function registerRemarkPlugin(plugin) {
+  registry.remarkPlugins.push(plugin);
+}
+/** @type {() => Array<RemarkPlugin>} */
+export function getRemarkPlugins() {
+  return registry.remarkPlugins;
+}
+
+/**
+ * Widget Serializers
+ */
+export function registerWidgetValueSerializer(widgetName, serializer) {
+  registry.widgetValueSerializers[widgetName] = serializer;
+}
+export function getWidgetValueSerializer(widgetName) {
+  return registry.widgetValueSerializers[widgetName];
+}
+
+/**
+ * Backend API
+ */
+export function registerBackend(name, BackendClass) {
+  if (!name || !BackendClass) {
+    console.error("Backend parameters invalid. example: CMS.registerBackend('myBackend', BackendClass)");
+  } else if (registry.backends[name]) {
+    console.error(`Backend [${name}] already registered. Please choose a different name.`);
+  } else {
+    registry.backends[name] = {
+      init: (...args) => new BackendClass(...args)
+    };
+  }
+}
+export function getBackend(name) {
+  return registry.backends[name];
+}
+
+/**
+ * Media Libraries
+ */
+export function registerMediaLibrary(mediaLibrary, options) {
+  if (registry.mediaLibraries.find(ml => mediaLibrary.name === ml.name)) {
+    throw new Error(`A media library named ${mediaLibrary.name} has already been registered.`);
+  }
+  registry.mediaLibraries.push({
+    ...mediaLibrary,
+    options
+  });
+}
+export function getMediaLibrary(name) {
+  return registry.mediaLibraries.find(ml => ml.name === name);
+}
+function validateEventName(name) {
+  if (!allowedEvents.includes(name)) {
+    throw new Error(`Invalid event name '${name}'`);
+  }
+}
+export function getEventListeners(name) {
+  validateEventName(name);
+  return [...registry.eventHandlers[name]];
+}
+export function registerEventListener({
+  name,
+  handler
+}, options = {}) {
+  validateEventName(name);
+  registry.eventHandlers[name].push({
+    handler,
+    options
+  });
+}
+export async function invokeEvent({
+  name,
+  data
+}) {
+  validateEventName(name);
+  const handlers = registry.eventHandlers[name];
+  let _data = {
+    ...data
+  };
+  for (const {
+    handler,
+    options
+  } of handlers) {
+    const result = await handler(_data, options);
+    if (result !== undefined) {
+      const entry = _data.entry.set('data', result);
+      _data = {
+        ...data,
+        entry
+      };
+    }
+  }
+  // Return the full entry object with all metadata (slug, path, meta, etc.)
+  // rather than just the data payload. Callers like invokePreSaveEvent expect
+  // the complete entry object to be preserved through the event handler chain.
+  return _data.entry;
+}
+export function removeEventListener({
+  name,
+  handler
+}) {
+  validateEventName(name);
+  if (handler) {
+    registry.eventHandlers[name] = registry.eventHandlers[name].filter(item => item.handler !== handler);
+  } else {
+    registry.eventHandlers[name] = [];
+  }
+}
+
+/**
+ * Locales
+ */
+export function registerLocale(locale, phrases) {
+  if (!locale || !phrases) {
+    console.error("Locale parameters invalid. example: CMS.registerLocale('locale', phrases)");
+  } else {
+    registry.locales[locale] = phrases;
+  }
+}
+export function getLocale(locale) {
+  return registry.locales[locale];
+}
+export function registerCustomFormat(name, extension, formatter) {
+  registry.formats[name] = {
+    extension,
+    formatter
+  };
+}
+export function getCustomFormats() {
+  return registry.formats;
+}
+export function getCustomFormatsExtensions() {
+  return Object.entries(registry.formats).reduce(function (acc, [name, {
+    extension
+  }]) {
+    return {
+      ...acc,
+      [name]: extension
+    };
+  }, {});
+}
+
+/** @type {() => Record<string, unknown>} */
+export function getCustomFormatsFormatters() {
+  return Object.entries(registry.formats).reduce(function (acc, [name, {
+    formatter
+  }]) {
+    return {
+      ...acc,
+      [name]: formatter
+    };
+  }, {});
+}
+export function getFormatter(name) {
+  return registry.formats[name]?.formatter;
+}

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,129 @@
+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, options) {
+  const {
+    replacement,
+    preserveSlashes
+  } = options;
+  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, i = 0, arr = [char]) => {
+    if (preserveSlashes && char === '/' && i !== 0 && i !== arr.length - 1) {
+      return char;
+    }
+    return 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',
+    preserveSlashes
+  } = 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,
+    preserveSlashes
+  })).join('');
+}
+export function sanitizeChar(char, options) {
+  const {
+    encoding = 'unicode',
+    sanitize_replacement: replacement = ''
+  } = options || {};
+  return getCharReplacer(encoding, {
+    replacement
+  })(char);
+}
+export function sanitizeSlug(str, options, preserveSlashes) {
+  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,
+    preserveSlashes
+  }), preserveSlashes ? slug => slug.split('/').filter(Boolean).map(part => sanitizeFilename(part, {
+    replacement
+  })).join('/') : 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);
+}