decap-cms-core 3.11.0 → 3.13.0

package/dist/esm/lib/i18n.js

@@ -255,15 +255,20 @@ export async function getI18nEntry(collection, extension, path, slug, getEntryVa
   if (structure === I18N_STRUCTURE.SINGLE_FILE) {
     entryValue = mergeSingleFileValue(await getEntryValue(path), defaultLocale, locales);
   } else {
-    const entryValues = await Promise.all(locales.map(async locale => {
+    const entryValuesResults = await Promise.allSettled(locales.map(async locale => {
       const entryPath = getFilePath(structure, extension, path, slug, locale);
-      const value = await getEntryValue(entryPath).catch(() => null);
+      const value = await getEntryValue(entryPath);
       return {
         value,
         locale
       };
     }));
-    const nonNullValues = entryValues.filter(e => e.value !== null);
+    const nonNullValues = entryValuesResults.map(e => e.status === 'fulfilled' ? e.value : undefined).filter(e => e !== undefined);
+    if (nonNullValues.length === 0) {
+      // mergeValues will throw on an empty list, and show the error messages.
+      const [error = new Error('No entry values found for any locale')] = entryValuesResults.map(e => e.status === 'rejected' ? e.reason : undefined).filter(e => e !== undefined);
+      throw error;
+    }
     entryValue = mergeValues(collection, structure, defaultLocale, nonNullValues);
   }
   return entryValue;

package/dist/esm/lib/urlHelper.js

@@ -43,7 +43,11 @@ function validURIChar(char) {
 function validIRIChar(char) {
   return uriChars.test(char) || ucsChars.test(char);
 }
-export function getCharReplacer(encoding, replacement) {
+export function getCharReplacer(encoding, options) {
+  const {
+    replacement,
+    preserveSlashes
+  } = options;
   let validChar;
   if (encoding === 'unicode') {
     validChar = validIRIChar;
@@ -57,13 +61,19 @@ export function getCharReplacer(encoding, replacement) {
   if (!Array.from(replacement).every(validChar)) {
     throw new Error('The replacement character(s) (options.replacement) is itself unsafe.');
   }
-  return char => validChar(char) ? char : replacement;
+  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'
+    encoding = 'unicode',
+    preserveSlashes
   } = options || {};
   if (!isString(str)) {
     throw new Error('The input slug must be a string.');
@@ -74,16 +84,21 @@ export function sanitizeURI(str, options) {
 
   // `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('');
+  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);
+  return getCharReplacer(encoding, {
+    replacement
+  })(char);
 }
-export function sanitizeSlug(str, options) {
+export function sanitizeSlug(str, options, preserveSlashes) {
   if (!isString(str)) {
     throw new Error('The input slug must be a string.');
   }
@@ -94,8 +109,11 @@ export function sanitizeSlug(str, options) {
   } = options || {};
   const sanitizedSlug = flow([...(stripDiacritics ? [diacritics.remove] : []), partialRight(sanitizeURI, {
     replacement,
-    encoding
-  }), partialRight(sanitizeFilename, {
+    encoding,
+    preserveSlashes
+  }), preserveSlashes ? slug => slug.split('/').filter(Boolean).map(part => sanitizeFilename(part, {
+    replacement
+  })).join('/') : partialRight(sanitizeFilename, {
     replacement
   })])(str);
 

package/index.d.ts

@@ -310,6 +310,7 @@ declare module 'decap-cms-core' {
     slug?: string;
     preview_path?: string;
     preview_path_date_field?: string;
+    preview_path_preserve_slashes?: boolean;
     create?: boolean;
     delete?: boolean;
     hide?: boolean;
@@ -364,6 +365,7 @@ declare module 'decap-cms-core' {
     auth_type?: 'implicit' | 'pkce';
     cms_label_prefix?: string;
     squash_merges?: boolean;
+    signoff_commits?: boolean;
     proxy_url?: string;
     commit_messages?: {
       create?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decap-cms-core",
   "description": "Decap CMS core application, see decap-cms package for the main distribution.",
-  "version": "3.11.0",
+  "version": "3.13.0",
   "repository": "https://github.com/decaporg/decap-cms/tree/main/packages/decap-cms-core",
   "bugs": "https://github.com/decaporg/decap-cms/issues",
   "module": "dist/esm/index.js",
@@ -28,7 +28,6 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@vercel/stega": "^0.1.2",
     "buffer": "^6.0.3",
-    "copy-text-to-clipboard": "^3.0.0",
     "dayjs": "^1.11.10",
     "deepmerge": "^4.2.2",
     "diacritics": "^1.3.0",
@@ -99,5 +98,5 @@
   "browser": {
     "path": "path-browserify"
   },
-  "gitHead": "af84ddd0532948c38a9da26026404518a59d0903"
+  "gitHead": "02e3fe3e42ffac8cf7ac50fde1984ef3bd4d788c"
 }

package/src/backend.ts

@@ -1178,6 +1178,7 @@ export class Backend {
         path,
         authorLogin: user.login,
         authorName: user.name,
+        authorEmail: user.email,
       },
       user.useOpenAuthoring,
     );
@@ -1253,6 +1254,7 @@ export class Backend {
           path: file.path,
           authorLogin: user.login,
           authorName: user.name,
+          authorEmail: user.email,
         },
         user.useOpenAuthoring,
       ),
@@ -1279,6 +1281,7 @@ export class Backend {
         path,
         authorLogin: user.login,
         authorName: user.name,
+        authorEmail: user.email,
       },
       user.useOpenAuthoring,
     );
@@ -1303,6 +1306,7 @@ export class Backend {
         path,
         authorLogin: user.login,
         authorName: user.name,
+        authorEmail: user.email,
       },
       user.useOpenAuthoring,
     );

package/src/components/Editor/EditorPreviewPane/EditorPreviewContent.js

@@ -67,6 +67,7 @@ class PreviewContent extends React.Component {
 
 PreviewContent.propTypes = {
   previewComponent: PropTypes.func.isRequired,
+  getEditorComponents: PropTypes.func,
   previewProps: PropTypes.object,
   onFieldClick: PropTypes.func,
 };

package/src/components/Editor/EditorPreviewPane/EditorPreviewPane.js

@@ -13,6 +13,7 @@ import {
   getPreviewTemplate,
   getPreviewStyles,
   getRemarkPlugins,
+  getEditorComponents,
 } from '../../../lib/registry';
 import { getAllEntries, tryLoadEntry } from '../../../actions/entries';
 import { ErrorBoundary } from '../../UI';
@@ -57,6 +58,7 @@ export class PreviewPane extends React.Component {
         fieldsMetaData={metadata}
         resolveWidget={resolveWidget}
         getRemarkPlugins={getRemarkPlugins}
+        getEditorComponents={getEditorComponents}
       />
     );
   };
@@ -261,6 +263,7 @@ export class PreviewPane extends React.Component {
         this.widgetFor(name, fields, values, fieldsMetaData),
       widgetsFor: this.widgetsFor,
       getCollection: this.getCollection,
+      getEditorComponents,
     };
 
     const styleEls = getPreviewStyles().map((style, i) => {

package/src/components/MediaLibrary/MediaLibraryButtons.js

@@ -2,7 +2,6 @@ import React from 'react';
 import PropTypes from 'prop-types';
 import { css } from '@emotion/react';
 import styled from '@emotion/styled';
-import copyToClipboard from 'copy-text-to-clipboard';
 import { isAbsolutePath } from 'decap-cms-lib-util';
 import { buttons, shadows, zIndex } from 'decap-cms-ui-default';
 
@@ -87,10 +86,10 @@ export class CopyToClipBoardButton extends React.Component {
     this.mounted = false;
   }
 
-  handleCopy = () => {
+  handleCopy = async () => {
     clearTimeout(this.timeout);
     const { path, draft, name } = this.props;
-    copyToClipboard(isAbsolutePath(path) || !draft ? path : name);
+    await navigator.clipboard.writeText(isAbsolutePath(path) || !draft ? path : name);
     this.setState({ copied: true });
     this.timeout = setTimeout(() => this.mounted && this.setState({ copied: false }), 1500);
   };

package/src/components/UI/ErrorBoundary.js

@@ -4,7 +4,6 @@ import { translate } from 'react-polyglot';
 import styled from '@emotion/styled';
 import yaml from 'yaml';
 import truncate from 'lodash/truncate';
-import copyToClipboard from 'copy-text-to-clipboard';
 import { localForage } from 'decap-cms-lib-util';
 import { buttons, colors } from 'decap-cms-ui-default';
 
@@ -117,7 +116,7 @@ function RecoveredEntry({ entry, t }) {
       <hr />
       <h2>{t('ui.errorBoundary.recoveredEntry.heading')}</h2>
       <strong>{t('ui.errorBoundary.recoveredEntry.warning')}</strong>
-      <CopyButton onClick={() => copyToClipboard(entry)}>
+      <CopyButton onClick={() => navigator.clipboard.writeText(entry)}>
         {t('ui.errorBoundary.recoveredEntry.copyButtonLabel')}
       </CopyButton>
       <pre>

package/src/constants/configSchema.js

@@ -224,6 +224,7 @@ function getConfigSchema() {
                   file: { type: 'string' },
                   preview_path: { type: 'string' },
                   preview_path_date_field: { type: 'string' },
+                  preview_path_preserve_slashes: { type: 'boolean' },
                   fields: fieldsConfig(),
                 },
                 required: ['name', 'label', 'file', 'fields'],
@@ -236,6 +237,7 @@ function getConfigSchema() {
             path: { type: 'string' },
             preview_path: { type: 'string' },
             preview_path_date_field: { type: 'string' },
+            preview_path_preserve_slashes: { type: 'boolean' },
             create: { type: 'boolean' },
             publish: { type: 'boolean' },
             hide: { type: 'boolean' },

package/src/formats/__tests__/frontmatter.spec.js

@@ -72,6 +72,27 @@ describe('Frontmatter', () => {
       });
     });
 
+    it('should throw on duplicate frontmatter keys', () => {
+      expect(() =>
+        FrontmatterInfer.fromFile('---\ntitle: Hello\ntitle: World\n---\nContent'),
+      ).toThrow(/Map keys must be unique/);
+    });
+
+    it('should throw on duplicate frontmatter keys with explicit YAML format', () => {
+      expect(() =>
+        frontmatterYAML().fromFile('---\ntitle: Hello\ntitle: World\n---\nContent'),
+      ).toThrow(/Map keys must be unique/);
+    });
+
+    it('should not throw when body contains YAML-like patterns', () => {
+      expect(
+        FrontmatterInfer.fromFile('---\ntitle: Hello\n---\ntitle: this is not a duplicate'),
+      ).toEqual({
+        title: 'Hello',
+        body: 'title: this is not a duplicate',
+      });
+    });
+
     it('should stringify YAML with --- delimiters', () => {
       expect(
         FrontmatterInfer.toFile({

package/src/formats/__tests__/yaml.spec.js

@@ -85,6 +85,33 @@ describe('yaml', () => {
         time: '10:05',
       });
     });
+
+    test('throws on duplicate keys', () => {
+      expect(() => yaml.fromFile('title: Hello\ntitle: World')).toThrow(
+        /Map keys must be unique; "title" is repeated/,
+      );
+    });
+
+    test('throws on duplicate nested keys', () => {
+      expect(() => yaml.fromFile('nested:\n  a: 1\n  a: 2')).toThrow(
+        /Map keys must be unique; "a" is repeated/,
+      );
+    });
+
+    test('does not throw when same key appears in different nested objects', () => {
+      expect(yaml.fromFile('obj1:\n  name: foo\nobj2:\n  name: bar')).toEqual({
+        obj1: { name: 'foo' },
+        obj2: { name: 'bar' },
+      });
+    });
+
+    test('logs warnings to console.warn', () => {
+      const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      // Valid YAML should produce no warnings
+      yaml.fromFile('title: Hello');
+      expect(warnSpy).not.toHaveBeenCalled();
+      warnSpy.mockRestore();
+    });
   });
   describe('toFile', () => {
     test('outputs valid yaml', () => {

package/src/formats/yaml.ts

@@ -41,7 +41,22 @@ export default {
     if (content && content.trim().endsWith('---')) {
       content = content.trim().slice(0, -3);
     }
-    return yaml.parse(content, { customTags: [timestampTag] });
+
+    const doc = yaml.parseDocument(content, {
+      customTags: [timestampTag],
+      prettyErrors: true,
+    });
+
+    for (const warn of doc.warnings) {
+      console.warn(`YAML warning: ${warn.message}`);
+    }
+
+    if (doc.errors.length > 0) {
+      const messages = doc.errors.map(e => e.message).join('\n');
+      throw new Error(`YAML parsing error:\n${messages}`);
+    }
+
+    return doc.toJSON();
   },
 
   toFile(data: object, sortedKeys: string[] = [], comments: Record<string, string> = {}) {

package/src/lib/__tests__/formatters.spec.js

@@ -247,6 +247,27 @@ describe('formatters', () => {
         'Ignoring unknown variable “author-email” in open authoring message template.',
       );
     });
+
+    it('should return commit with trailer when signoff_commits is enabled', () => {
+      const collection = Map({ label_singular: 'Collection' });
+      const config = {
+        backend: {
+          signoff_commits: true,
+        },
+      };
+
+      expect(
+        commitMessageFormatter('create', config, {
+          slug: 'doc-slug',
+          path: 'file-path',
+          collection,
+          authorName: 'Test User',
+          authorEmail: 'test-user@example.org',
+        }),
+      ).toEqual(
+        'Create Collection “doc-slug”\n\nSigned-off-by: Test User <test-user@example.org>\n',
+      );
+    });
   });
 
   describe('prepareSlug', () => {
@@ -566,6 +587,66 @@ describe('formatters', () => {
         'Collection "posts" configuration error:\n  `preview_path_date_field` must be a field with a valid date. Ignoring `preview_path`.',
       );
     });
+
+    it('should preserve slashes in value when configured', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+            preview_path_preserve_slashes: true,
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested/value');
+    });
+
+    it('should sanitize slashes in value when not configured', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested-value');
+    });
+
+    it('should preserve slashes in value for nested collections by default', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+            nested: { depth: 10 },
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested/value');
+    });
+
+    it('should sanitize slashes in value for nested collections when explicitly disabled', () => {
+      expect(
+        previewUrlFormatter(
+          'https://www.example.com',
+          Map({
+            preview_path: 'prefix/{{value}}',
+            nested: { depth: 10 },
+            preview_path_preserve_slashes: false,
+          }),
+          'backendSlug',
+          Map({ data: Map({ value: 'nested/value' }) }),
+          slugConfig,
+        ),
+      ).toBe('https://www.example.com/prefix/nested-value');
+    });
   });
 
   describe('summaryFormatter', () => {

package/src/lib/__tests__/urlHelper.spec.js

@@ -125,6 +125,13 @@ describe('sanitizeSlug', () => {
       'test_test',
     );
   });
+
+  it('preserves slashes when requested', () => {
+    const input = '/this-is-a/nested/page';
+
+    expect(sanitizeSlug(input, slugConfig, false)).toEqual('this-is-a-nested-page');
+    expect(sanitizeSlug(input, slugConfig, true)).toEqual('this-is-a/nested/page');
+  });
 });
 
 describe('sanitizeChar', () => {

package/src/lib/formatters.ts

@@ -44,16 +44,28 @@ type Options = {
   collection?: Collection;
   authorLogin?: string;
   authorName?: string;
+  authorEmail?: string;
 };
 
 export function commitMessageFormatter(
   type: keyof typeof commitMessageTemplates,
   config: CmsConfig,
-  { slug, path, collection, authorLogin, authorName }: Options,
+  { slug, path, collection, authorLogin, authorName, authorEmail }: Options,
   isOpenAuthoring?: boolean,
 ) {
   const templates = { ...commitMessageTemplates, ...(config.backend.commit_messages || {}) };
 
+  let trailers = '';
+  if (config.backend.signoff_commits) {
+    if (!authorName) {
+      console.warn('Option signoff_commits is enabled, but author name is unknown');
+    } else if (!authorEmail) {
+      console.warn('Option signoff_commits is enabled, but author email is unknown');
+    } else {
+      trailers = `\n\nSigned-off-by: ${authorName} <${authorEmail}>\n`;
+    }
+  }
+
   const commitMessage = templates[type].replace(variableRegex, (_, variable) => {
     switch (variable) {
       case 'slug':
@@ -73,7 +85,7 @@ export function commitMessageFormatter(
   });
 
   if (!isOpenAuthoring) {
-    return commitMessage;
+    return commitMessage + trailers;
   }
 
   const message = templates.openAuthoring.replace(variableRegex, (_, variable) => {
@@ -90,7 +102,7 @@ export function commitMessageFormatter(
     }
   });
 
-  return message;
+  return message + trailers;
 }
 
 export function prepareSlug(slug: string) {
@@ -108,11 +120,19 @@ export function prepareSlug(slug: string) {
   );
 }
 
-export function getProcessSegment(slugConfig?: CmsSlug, ignoreValues?: string[]) {
+export function getProcessSegment(
+  slugConfig?: CmsSlug,
+  ignoreValues?: string[],
+  preserveSlashes?: boolean,
+) {
   return (value: string) =>
     ignoreValues && ignoreValues.includes(value)
       ? value
-      : flow([value => String(value), prepareSlug, partialRight(sanitizeSlug, slugConfig)])(value);
+      : flow([
+          value => String(value),
+          prepareSlug,
+          partialRight(sanitizeSlug, slugConfig, preserveSlashes),
+        ])(value);
 }
 
 export function slugFormatter(
@@ -193,19 +213,21 @@ export function previewUrlFormatter(
   fields = addFileTemplateFields(entry.get('path'), fields, collection.get('folder'));
   const dateFieldName = getDateField() || selectInferredField(collection, 'date');
   const date = parseDateFromEntry(entry as unknown as Map<string, unknown>, dateFieldName);
+  const previewPathPreserveSlashes = collection.get('preview_path_preserve_slashes');
+  const preserveSlashes = !!(previewPathPreserveSlashes ?? collection.has('nested'));
 
   // Prepare and sanitize slug variables only, leave the rest of the
   // `preview_path` template as is.
-  const processSegment = getProcessSegment(slugConfig, [fields.get('dirname')]);
+  const processSegment = getProcessSegment(slugConfig, [fields.get('dirname')], preserveSlashes);
   let compiledPath;
 
   try {
     compiledPath = compileStringTemplate(pathTemplate, date, slug, fields, processSegment);
-  } catch (err) {
+  } catch (err: unknown) {
     // Print an error and ignore `preview_path` if both:
     //   1. Date is invalid (according to DayJs), and
     //   2. A date expression (eg. `{{year}}`) is used in `preview_path`
-    if (err.name === SLUG_MISSING_REQUIRED_DATE) {
+    if (err instanceof Error && err.name === SLUG_MISSING_REQUIRED_DATE) {
       console.error(stripIndent`
         Collection "${collection.get('name')}" configuration error:
           \`preview_path_date_field\` must be a field with a valid date. Ignoring \`preview_path\`.

package/src/lib/i18n.ts

@@ -308,18 +308,26 @@ export async function getI18nEntry(
   if (structure === I18N_STRUCTURE.SINGLE_FILE) {
     entryValue = mergeSingleFileValue(await getEntryValue(path), defaultLocale, locales);
   } else {
-    const entryValues = await Promise.all(
+    const entryValuesResults = await Promise.allSettled(
       locales.map(async locale => {
         const entryPath = getFilePath(structure, extension, path, slug, locale);
-        const value = await getEntryValue(entryPath).catch(() => null);
+        const value = await getEntryValue(entryPath);
         return { value, locale };
       }),
     );
 
-    const nonNullValues = entryValues.filter(e => e.value !== null) as {
-      value: EntryValue;
-      locale: string;
-    }[];
+    const nonNullValues = entryValuesResults
+      .map(e => (e.status === 'fulfilled' ? e.value : undefined))
+      .filter((e): e is { value: EntryValue; locale: string } => e !== undefined);
+
+    if (nonNullValues.length === 0) {
+      // mergeValues will throw on an empty list, and show the error messages.
+      const [error = new Error('No entry values found for any locale')] = entryValuesResults
+        .map(e => (e.status === 'rejected' ? e.reason : undefined))
+        .filter(e => e !== undefined);
+
+      throw error;
+    }
 
     entryValue = mergeValues(collection, structure, defaultLocale, nonNullValues);
   }

package/src/lib/urlHelper.ts

@@ -51,7 +51,14 @@ function validIRIChar(char: string) {
   return uriChars.test(char) || ucsChars.test(char);
 }
 
-export function getCharReplacer(encoding: string, replacement: string) {
+export function getCharReplacer(
+  encoding: string,
+  options: {
+    replacement: NonNullable<CmsSlug['sanitize_replacement']>;
+    preserveSlashes?: boolean;
+  },
+) {
+  const { replacement, preserveSlashes } = options;
   let validChar: (char: string) => boolean;
 
   if (encoding === 'unicode') {
@@ -67,14 +74,24 @@ export function getCharReplacer(encoding: string, replacement: string) {
     throw new Error('The replacement character(s) (options.replacement) is itself unsafe.');
   }
 
-  return (char: string) => (validChar(char) ? char : replacement);
+  return (char: string, i = 0, arr: string[] = [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: string,
-  options?: { replacement: CmsSlug['sanitize_replacement']; encoding: CmsSlug['encoding'] },
+  options?: {
+    replacement: CmsSlug['sanitize_replacement'];
+    encoding: CmsSlug['encoding'];
+    preserveSlashes?: boolean;
+  },
 ) {
-  const { replacement = '', encoding = 'unicode' } = options || {};
+  const { replacement = '', encoding = 'unicode', preserveSlashes } = options || {};
 
   if (!isString(str)) {
     throw new Error('The input slug must be a string.');
@@ -85,15 +102,15 @@ export function sanitizeURI(
 
   // `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('');
+  return Array.from(str).map(getCharReplacer(encoding, { replacement, preserveSlashes })).join('');
 }
 
 export function sanitizeChar(char: string, options?: CmsSlug) {
   const { encoding = 'unicode', sanitize_replacement: replacement = '' } = options || {};
-  return getCharReplacer(encoding, replacement)(char);
+  return getCharReplacer(encoding, { replacement })(char);
 }
 
-export function sanitizeSlug(str: string, options?: CmsSlug) {
+export function sanitizeSlug(str: string, options?: CmsSlug, preserveSlashes?: boolean) {
   if (!isString(str)) {
     throw new Error('The input slug must be a string.');
   }
@@ -106,8 +123,15 @@ export function sanitizeSlug(str: string, options?: CmsSlug) {
 
   const sanitizedSlug = flow([
     ...(stripDiacritics ? [diacritics.remove] : []),
-    partialRight(sanitizeURI, { replacement, encoding }),
-    partialRight(sanitizeFilename, { replacement }),
+    partialRight(sanitizeURI, { replacement, encoding, preserveSlashes }),
+    preserveSlashes
+      ? (slug: string) =>
+          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).