decap-cms-core 2.56.0-beta.1

package/dist/esm/lib/registry.js

@@ -0,0 +1,322 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getBackend = getBackend;
+exports.getEditorComponents = getEditorComponents;
+exports.getEventListeners = getEventListeners;
+exports.getLocale = getLocale;
+exports.getMediaLibrary = getMediaLibrary;
+exports.getPreviewStyles = getPreviewStyles;
+exports.getPreviewTemplate = getPreviewTemplate;
+exports.getRemarkPlugins = getRemarkPlugins;
+exports.getWidget = getWidget;
+exports.getWidgetValueSerializer = getWidgetValueSerializer;
+exports.getWidgets = getWidgets;
+exports.invokeEvent = invokeEvent;
+exports.registerBackend = registerBackend;
+exports.registerEditorComponent = registerEditorComponent;
+exports.registerEventListener = registerEventListener;
+exports.registerLocale = registerLocale;
+exports.registerMediaLibrary = registerMediaLibrary;
+exports.registerPreviewStyle = registerPreviewStyle;
+exports.registerPreviewTemplate = registerPreviewTemplate;
+exports.registerRemarkPlugin = registerRemarkPlugin;
+exports.registerWidget = registerWidget;
+exports.registerWidgetValueSerializer = registerWidgetValueSerializer;
+exports.removeEventListener = removeEventListener;
+exports.resolveWidget = resolveWidget;
+var _immutable = require("immutable");
+var _immer = _interopRequireDefault(require("immer"));
+var _commonTags = require("common-tags");
+var _EditorComponent = _interopRequireDefault(require("../valueObjects/EditorComponent"));
+const _excluded = ["name", "controlComponent", "previewComponent", "schema", "allowMapValue", "globalStyles"];
+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 allowedEvents = ['prePublish', 'postPublish', 'preUnpublish', 'postUnpublish', 'preSave', 'postSave'];
+const eventHandlers = {};
+allowedEvents.forEach(e => {
+  eventHandlers[e] = [];
+});
+
+/**
+ * Global Registry Object
+ */
+const registry = {
+  backends: {},
+  templates: {},
+  previewStyles: [],
+  widgets: {},
+  editorComponents: (0, _immutable.Map)(),
+  remarkPlugins: [],
+  widgetValueSerializers: {},
+  mediaLibraries: [],
+  locales: {},
+  eventHandlers
+};
+var _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
+};
+/**
+ * Preview Styles
+ *
+ * Valid options:
+ *  - raw {boolean} if `true`, `style` value is expected to be a CSS string
+ */
+exports.default = _default;
+function registerPreviewStyle(style, opts) {
+  registry.previewStyles.push(_objectSpread(_objectSpread({}, opts), {}, {
+    value: style
+  }));
+}
+function getPreviewStyles() {
+  return registry.previewStyles;
+}
+
+/**
+ * Preview Templates
+ */
+function registerPreviewTemplate(name, component) {
+  registry.templates[name] = component;
+}
+function getPreviewTemplate(name) {
+  return registry.templates[name];
+}
+
+/**
+ * Editor Widgets
+ */
+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
+      } = name,
+      options = _objectWithoutProperties(name, _excluded);
+    if (registry.widgets[widgetName]) {
+      console.warn((0, _commonTags.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] = _objectSpread({
+      control,
+      preview,
+      schema,
+      globalStyles,
+      allowMapValue
+    }, options);
+  } else {
+    console.error('`registerWidget` failed, called with incorrect arguments.');
+  }
+}
+function getWidget(name) {
+  return registry.widgets[name];
+}
+function getWidgets() {
+  return (0, _immer.default)(Object.entries(registry.widgets), draft => {
+    return draft.map(([key, value]) => _objectSpread({
+      name: key
+    }, value));
+  });
+}
+function resolveWidget(name) {
+  return getWidget(name || 'string') || getWidget('unknown');
+}
+
+/**
+ * Markdown Editor Custom Components
+ */
+function registerEditorComponent(component) {
+  const plugin = (0, _EditorComponent.default)(component);
+  if (plugin.type === 'code-block') {
+    const codeBlock = registry.editorComponents.find(c => c.type === 'code-block');
+    if (codeBlock) {
+      console.warn((0, _commonTags.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);
+}
+function getEditorComponents() {
+  return registry.editorComponents;
+}
+
+/**
+ * Remark plugins
+ */
+/** @typedef {import('unified').Pluggable} RemarkPlugin */
+/** @type {(plugin: RemarkPlugin) => void} */
+function registerRemarkPlugin(plugin) {
+  registry.remarkPlugins.push(plugin);
+}
+/** @type {() => Array<RemarkPlugin>} */
+function getRemarkPlugins() {
+  return registry.remarkPlugins;
+}
+
+/**
+ * Widget Serializers
+ */
+function registerWidgetValueSerializer(widgetName, serializer) {
+  registry.widgetValueSerializers[widgetName] = serializer;
+}
+function getWidgetValueSerializer(widgetName) {
+  return registry.widgetValueSerializers[widgetName];
+}
+
+/**
+ * Backend API
+ */
+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)
+    };
+  }
+}
+function getBackend(name) {
+  return registry.backends[name];
+}
+
+/**
+ * Media Libraries
+ */
+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(_objectSpread(_objectSpread({}, mediaLibrary), {}, {
+    options
+  }));
+}
+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}'`);
+  }
+}
+function getEventListeners(name) {
+  validateEventName(name);
+  return [...registry.eventHandlers[name]];
+}
+function registerEventListener({
+  name,
+  handler
+}, options = {}) {
+  validateEventName(name);
+  registry.eventHandlers[name].push({
+    handler,
+    options
+  });
+}
+async function invokeEvent({
+  name,
+  data
+}) {
+  validateEventName(name);
+  const handlers = registry.eventHandlers[name];
+  let _data = _objectSpread({}, data);
+  for (const {
+    handler,
+    options
+  } of handlers) {
+    const result = await handler(_data, options);
+    if (result !== undefined) {
+      const entry = _data.entry.set('data', result);
+      _data = _objectSpread(_objectSpread({}, data), {}, {
+        entry
+      });
+    }
+  }
+  return _data.entry.get('data');
+}
+function removeEventListener({
+  name,
+  handler
+}) {
+  validateEventName(name);
+  if (handler) {
+    registry.eventHandlers[name] = registry.eventHandlers[name].filter(item => item.handler !== handler);
+  } else {
+    registry.eventHandlers[name] = [];
+  }
+}
+
+/**
+ * Locales
+ */
+function registerLocale(locale, phrases) {
+  if (!locale || !phrases) {
+    console.error("Locale parameters invalid. example: CMS.registerLocale('locale', phrases)");
+  } else {
+    registry.locales[locale] = phrases;
+  }
+}
+function getLocale(locale) {
+  return registry.locales[locale];
+}

package/dist/esm/lib/serializeEntryValues.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deserializeValues = deserializeValues;
+exports.serializeValues = serializeValues;
+var _isNil2 = _interopRequireDefault(require("lodash/isNil"));
+var _immutable = require("immutable");
+var _registry = require("./registry");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 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 = (0, _registry.getWidgetValueSerializer)(field.get('widget'));
+    const nestedFields = field.get('fields');
+
+    // Call recursively for fields within lists
+    if (nestedFields && _immutable.List.isList(value)) {
+      return acc.set(fieldName, value.map(val => runSerializer(val, nestedFields, method)));
+    }
+
+    // Call recursively for fields within objects
+    if (nestedFields && _immutable.Map.isMap(value)) {
+      return acc.set(fieldName, runSerializer(value, nestedFields, method));
+    }
+
+    // Run serialization method on value if not null or undefined
+    if (serializer && !(0, _isNil2.default)(value)) {
+      return acc.set(fieldName, serializer[method](value));
+    }
+
+    // If no serializer is registered for the field's widget, use the field as is
+    if (!(0, _isNil2.default)(value)) {
+      return acc.set(fieldName, value);
+    }
+    return acc;
+  }, (0, _immutable.Map)());
+
+  //preserve unknown fields value
+  serializedData = values.mergeDeep(serializedData);
+  return serializedData;
+}
+function serializeValues(values, fields) {
+  return runSerializer(values, fields, 'serialize');
+}
+function deserializeValues(values, fields) {
+  return runSerializer(values, fields, 'deserialize');
+}

package/dist/esm/lib/textHelper.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringToRGB = stringToRGB;
+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,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addParams = addParams;
+exports.getCharReplacer = getCharReplacer;
+exports.getCollectionUrl = getCollectionUrl;
+exports.getNewEntryUrl = getNewEntryUrl;
+exports.joinUrlPath = joinUrlPath;
+exports.sanitizeChar = sanitizeChar;
+exports.sanitizeSlug = sanitizeSlug;
+exports.sanitizeURI = sanitizeURI;
+exports.stripProtocol = stripProtocol;
+var _partialRight2 = _interopRequireDefault(require("lodash/partialRight"));
+var _flow2 = _interopRequireDefault(require("lodash/flow"));
+var _escapeRegExp2 = _interopRequireDefault(require("lodash/escapeRegExp"));
+var _isString2 = _interopRequireDefault(require("lodash/isString"));
+var _url = _interopRequireDefault(require("url"));
+var _urlJoin = _interopRequireDefault(require("url-join"));
+var _diacritics = _interopRequireDefault(require("diacritics"));
+var _sanitizeFilename = _interopRequireDefault(require("sanitize-filename"));
+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); }
+function getUrl(urlString, direct) {
+  return `${direct ? '/#' : ''}${urlString}`;
+}
+function getCollectionUrl(collectionName, direct) {
+  return getUrl(`/collections/${collectionName}`, direct);
+}
+function getNewEntryUrl(collectionName, direct) {
+  return getUrl(`/collections/${collectionName}/new`, direct);
+}
+function addParams(urlString, params) {
+  const parsedUrl = _url.default.parse(urlString, true);
+  parsedUrl.query = _objectSpread(_objectSpread({}, parsedUrl.query), params);
+  return _url.default.format(parsedUrl);
+}
+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);
+}
+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.
+function sanitizeURI(str, options) {
+  const {
+    replacement = '',
+    encoding = 'unicode'
+  } = options || {};
+  if (!(0, _isString2.default)(str)) {
+    throw new Error('The input slug must be a string.');
+  }
+  if (!(0, _isString2.default)(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('');
+}
+function sanitizeChar(char, options) {
+  const {
+    encoding = 'unicode',
+    sanitize_replacement: replacement = ''
+  } = options || {};
+  return getCharReplacer(encoding, replacement)(char);
+}
+function sanitizeSlug(str, options) {
+  if (!(0, _isString2.default)(str)) {
+    throw new Error('The input slug must be a string.');
+  }
+  const {
+    encoding,
+    clean_accents: stripDiacritics,
+    sanitize_replacement: replacement
+  } = options || {};
+  const sanitizedSlug = (0, _flow2.default)([...(stripDiacritics ? [_diacritics.default.remove] : []), (0, _partialRight2.default)(sanitizeURI, {
+    replacement,
+    encoding
+  }), (0, _partialRight2.default)(_sanitizeFilename.default, {
+    replacement
+  })])(str);
+
+  // Remove any doubled or leading/trailing replacement characters (that were added in the sanitizers).
+  const doubleReplacement = new RegExp(`(?:${(0, _escapeRegExp2.default)(replacement)})+`, 'g');
+  const trailingReplacement = new RegExp(`${(0, _escapeRegExp2.default)(replacement)}$`);
+  const leadingReplacement = new RegExp(`^${(0, _escapeRegExp2.default)(replacement)}`);
+  const normalizedSlug = sanitizedSlug.replace(doubleReplacement, replacement).replace(leadingReplacement, '').replace(trailingReplacement, '');
+  return normalizedSlug;
+}
+function joinUrlPath(base, ...path) {
+  return (0, _urlJoin.default)(base, ...path);
+}

package/dist/esm/mediaLibrary.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _once2 = _interopRequireDefault(require("lodash/once"));
+var _registry = require("./lib/registry");
+var _redux = require("./redux");
+var _config = require("./actions/config");
+var _mediaLibrary = require("./actions/mediaLibrary");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * This module is currently concerned only with external media libraries
+ * registered via `registerMediaLibrary`.
+ */
+
+function handleInsert(url) {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  return _redux.store.dispatch((0, _mediaLibrary.insertMedia)(url, undefined));
+}
+const initializeMediaLibrary = (0, _once2.default)(async function initializeMediaLibrary(name, options) {
+  const lib = (0, _registry.getMediaLibrary)(name);
+  if (!lib) {
+    const err = new Error(`Missing external media library '${name}'. Please use 'registerMediaLibrary' to register it.`);
+    _redux.store.dispatch((0, _config.configFailed)(err));
+  } else {
+    const instance = await lib.init({
+      options,
+      handleInsert
+    });
+    _redux.store.dispatch((0, _mediaLibrary.createMediaLibrary)(instance));
+  }
+});
+_redux.store.subscribe(() => {
+  const state = _redux.store.getState();
+  if (state) {
+    var _state$config$media_l;
+    const mediaLibraryName = (_state$config$media_l = state.config.media_library) === null || _state$config$media_l === void 0 ? void 0 : _state$config$media_l.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,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultState = exports.default = void 0;
+var _immer = require("immer");
+var _auth = require("../actions/auth");
+const defaultState = {
+  isFetching: false,
+  user: undefined,
+  error: undefined
+};
+exports.defaultState = defaultState;
+const auth = (0, _immer.produce)((state, action) => {
+  switch (action.type) {
+    case _auth.AUTH_REQUEST:
+      state.isFetching = true;
+      break;
+    case _auth.AUTH_SUCCESS:
+      state.user = action.payload;
+      break;
+    case _auth.AUTH_FAILURE:
+      state.error = action.payload && action.payload.toString();
+      break;
+    case _auth.AUTH_REQUEST_DONE:
+      state.isFetching = false;
+      break;
+    case _auth.LOGOUT:
+      state.user = undefined;
+      state.isFetching = false;
+  }
+}, defaultState);
+var _default = auth;
+exports.default = _default;