botframework-webchat-component 4.18.1 → 4.19.0

package/src/Utils/FixedWidthImage.tsx

@@ -0,0 +1,60 @@
+import classNames from 'classnames';
+import React, { memo } from 'react';
+
+import { useStyleToEmotionObject } from '../hooks/internal/styleToEmotionObject';
+import CSSTokens from '../Styles/CSSTokens';
+
+const ROOT_STYLE = {
+  '&.webchat__fixed-width-image': {
+    display: 'flex',
+    justifyContent: 'center',
+    maxHeight: CSSTokens.MaxHeightImageBubble,
+    minHeight: CSSTokens.MinHeightImageBubble,
+    overflow: 'hidden',
+    position: 'relative',
+
+    '& .webchat__fixed-width-image__filler': {
+      visibility: 'hidden',
+      width: '100%'
+    },
+
+    '& .webchat__fixed-width-image__image': {
+      left: '50%',
+      objectFit: 'cover',
+      position: 'absolute',
+      top: '50%',
+      transform: 'translate(-50%, -50%)',
+      width: '100%'
+    }
+  }
+};
+
+/**
+ * Shows the image with fixed width but cropped top/bottom.
+ */
+const FixedWidthImage = memo(
+  ({
+    alt,
+    className,
+    src
+  }: Readonly<{
+    alt: string;
+    className?: string | undefined;
+    src: string;
+  }>) => (
+    <div
+      className={classNames(
+        'webchat__fixed-width-image',
+        useStyleToEmotionObject()(ROOT_STYLE) + '',
+        (className || '') + ''
+      )}
+    >
+      <img alt="" className="webchat__fixed-width-image__filler" role="none" src={src} />
+      <img alt={alt} className="webchat__fixed-width-image__image" src={src} />
+    </div>
+  )
+);
+
+FixedWidthImage.displayName = 'FixedWidthImage';
+
+export default FixedWidthImage;

package/src/Utils/FocusRedirector.tsx

@@ -1,7 +1,20 @@
-import PropTypes from 'prop-types';
+import { validateProps } from '@msinternal/botframework-webchat-react-valibot';
 import React, { useCallback } from 'react';
-
-import type { FC, MutableRefObject } from 'react';
+import {
+  custom,
+  function_,
+  instance,
+  is,
+  nullable,
+  object,
+  optional,
+  pipe,
+  readonly,
+  string,
+  type InferInput
+} from 'valibot';
+
+import mutableRefObject from '../types/internal/mutableRefObject';
 
 // This is an element, when focused, will send the focus to the ref specified in "redirectRef".
 // Although the focus is being redirected, browser will scroll this redirector element into view.
@@ -12,13 +25,20 @@ import type { FC, MutableRefObject } from 'react';
 // When this focus redirector is put inside a scrollable container, you may want to resize or reposition
 // it to prevent unintentional scroll done by the browser default behavior.
 
-type FocusRedirectorProps = {
-  className?: string;
-  onFocus?: () => void;
-  redirectRef?: MutableRefObject<HTMLElement>;
-};
+const focusRedirectorPropsSchema = pipe(
+  object({
+    className: optional(string()),
+    onFocus: optional(custom<() => void>(value => is(function_(), value))),
+    redirectRef: optional(mutableRefObject(nullable(instance(HTMLElement))))
+  }),
+  readonly()
+);
+
+type FocusRedirectorProps = InferInput<typeof focusRedirectorPropsSchema>;
+
+function FocusRedirector(props: FocusRedirectorProps) {
+  const { className, onFocus, redirectRef } = validateProps(focusRedirectorPropsSchema, props);
 
-const FocusRedirector: FC<FocusRedirectorProps> = ({ className, onFocus, redirectRef }) => {
   const handleFocus = useCallback(() => {
     redirectRef?.current?.focus();
     onFocus && onFocus();
@@ -32,22 +52,7 @@ const FocusRedirector: FC<FocusRedirectorProps> = ({ className, onFocus, redirec
   //             However, reacting with browse mode is currently okay. Just better to leave it alone.
 
   return <div className={className} onFocus={handleFocus} tabIndex={0} />;
-};
-
-FocusRedirector.defaultProps = {
-  className: undefined,
-  onFocus: undefined,
-  redirectRef: undefined
-};
-
-FocusRedirector.propTypes = {
-  className: PropTypes.string,
-  onFocus: PropTypes.func,
-  // PropTypes is not fully compatible with TypeScript.
-  // @ts-ignore
-  redirectRef: PropTypes.shape({
-    current: PropTypes.instanceOf(HTMLElement)
-  })
-};
+}
 
 export default FocusRedirector;
+export { focusRedirectorPropsSchema, type FocusRedirectorProps };

package/src/Utils/InlineMarkdown.js

@@ -9,7 +9,7 @@ import updateIn from 'simple-update-in';
 import createCustomEvent from './createCustomEvent';
 import randomId from './randomId';
 import useInternalMarkdownIt from '../hooks/internal/useInternalMarkdownIt';
-import useStyleToEmotionObject from '../hooks/internal/useStyleToEmotionObject';
+import { useStyleToEmotionObject } from '../hooks/internal/styleToEmotionObject';
 import walkMarkdownTokens from './walkMarkdownTokens';
 
 const { useStyleOptions } = hooks;
@@ -46,6 +46,9 @@ function replaceAnchorWithButton(markdownTokens) {
 const InlineMarkdown = ({ children, onReference, references }) => {
   if (typeof children !== 'string') {
     console.warn('botframework-webchat: "children" prop passed to <InlineMarkdown> must be of type string.');
+
+    // Shortcut for disabling invalid props.
+    // eslint-disable-next-line react-hooks/immutability
     children = '';
   }
 
@@ -80,6 +83,8 @@ const InlineMarkdown = ({ children, onReference, references }) => {
   );
 
   // Markdown-It only support references in uppercase.
+  // Re-shaping input.
+  // eslint-disable-next-line react-hooks/immutability
   references = references.map(reference => reference.toUpperCase());
 
   const { hrefToRef, refToHref } = references.reduce(

package/src/Utils/JSONLinkedData/__snapshots__/dereferenceBlankNodes.spec.ts.snap

@@ -1,24 +1,24 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`should dereference unconnected blank nodes in array in cyclic fashion 1`] = `
-Object {
+{
   "@type": "Book",
-  "about": Array [
-    Object {
+  "about": [
+    {
       "@id": "_:isaac",
       "@type": "Person",
       "name": "Isaac Stevens",
-      "worksFor": Object {
+      "worksFor": {
         "@id": "_:uw",
         "@type": "Organization",
         "founder": [Circular],
         "name": "University of Washington",
       },
     },
-    Object {
+    {
       "@id": "_:uw",
       "@type": "Organization",
-      "founder": Object {
+      "founder": {
         "@id": "_:isaac",
         "@type": "Person",
         "name": "Isaac Stevens",
@@ -27,7 +27,7 @@ Object {
       "name": "University of Washington",
     },
   ],
-  "author": Object {
+  "author": {
     "@type": "Person",
     "name": "Edmond S. Meany",
   },
@@ -36,13 +36,13 @@ Object {
 `;
 
 exports[`should dereference unconnected blank nodes in cyclic fashion 1`] = `
-Object {
+{
   "@type": "Book",
-  "author": Object {
+  "author": {
     "@id": "_:isaac",
     "@type": "Person",
     "name": "Isaac Stevens",
-    "worksFor": Object {
+    "worksFor": {
       "@id": "_:uw",
       "@type": "Organization",
       "founder": [Circular],
@@ -50,10 +50,10 @@ Object {
     },
   },
   "name": "Report of Explorations for a Route for the Pacific Railroad near the 47th and 49th Parallels of North Latitude, from St. Paul, Minnesota, to Puget Sound",
-  "sourceOrganization": Object {
+  "sourceOrganization": {
     "@id": "_:uw",
     "@type": "Organization",
-    "founder": Object {
+    "founder": {
       "@id": "_:isaac",
       "@type": "Person",
       "name": "Isaac Stevens",
@@ -65,22 +65,22 @@ Object {
 `;
 
 exports[`should dereference unconnected blank nodes in the graph 1`] = `
-Array [
-  Object {
+[
+  {
     "@id": "_:isaac",
     "@type": "Person",
     "name": "Isaac Stevens",
-    "worksFor": Object {
+    "worksFor": {
       "@id": "_:uw",
       "@type": "Organization",
       "founder": [Circular],
       "name": "University of Washington",
     },
   },
-  Object {
+  {
     "@id": "_:uw",
     "@type": "Organization",
-    "founder": Object {
+    "founder": {
       "@id": "_:isaac",
       "@type": "Person",
       "name": "Isaac Stevens",

package/src/Utils/JSONLinkedData/dereferenceBlankNodes.spec.ts

@@ -1,3 +1,5 @@
+/// <reference types="jest" />
+
 import dereferenceBlankNodes from './dereferenceBlankNodes';
 
 test('should leave non-blank node as-is', () => {

package/src/Utils/JSONLinkedData/dereferenceBlankNodes.ts

@@ -77,7 +77,7 @@ function dereferenceBlankNodesInline(objects: object[]): void {
  * @param graph A list of nodes in the graph.
  * @returns A structured clone of graph with unconnected blank nodes replaced by their corresponding blank node.
  */
-export default function dereferenceBlankNodes<T extends object>(graph: T[]): readonly T[] {
+export default function dereferenceBlankNodes<T extends Record<any, any>>(graph: T[]): readonly T[] {
   const nextObjects = structuredClone(graph);
 
   dereferenceBlankNodesInline(nextObjects);

package/src/Utils/JSONLinkedData/getSafeOwnPropertyNames.ts

@@ -1,12 +1,12 @@
 const DANGEROUS_PROPERTY_NAMES = ['__proto__', 'constructor', 'prototype'];
 
 /**
- * Returns a whitelisted own-property names.
+ * Returns an allowlisted own-property names.
  *
  * If `null` or `undefined` is passed, an empty list will be returned.
  *
  * @param object An object (including primitives).
- * @returns A whitelisted own-property names.
+ * @returns An allowlisted own-property names.
  */
 export default function getSafeOwnPropertyNames(object: unknown): string[] {
   return Object.getOwnPropertyNames(object).filter(name => !DANGEROUS_PROPERTY_NAMES.includes(name));

package/src/Utils/JSONLinkedData/isUnconnectedBlankNode.spec.ts

@@ -1,3 +1,5 @@
+/// <reference types="jest" />
+
 import isUnconnectedBlankNode from './isUnconnectedBlankNode';
 
 test('passing a blank node identifier should return true', () =>

package/src/Utils/LocalizedString.tsx

@@ -31,16 +31,16 @@ const defaultDecorateLink = (href: string, textContent: string, linkOptions?: Li
     );
 
     // linkDefinition.identifier is uppercase, while linkDefinition.label is as-is.
-    linkDefinition.label === textContent && classes.add('webchat__render-markdown__pure-identifier');
+    linkDefinition.label === textContent && classes.add('render-markdown__pure-identifier');
   }
 
   // For links that would be sanitized out, let's turn them into a button so we could handle them later.
   if (!allowedSchemes.map(scheme => `${scheme}:`).includes(protocol)) {
     decoration.asButton ??= true;
 
-    classes.add('webchat__render-markdown__citation');
+    classes.add('render-markdown__citation');
   } else if (protocol === 'http:' || protocol === 'https:') {
-    decoration.iconClassName = [decoration.iconClassName, 'webchat__render-markdown__external-link-icon']
+    decoration.iconClassName = [decoration.iconClassName, 'render-markdown__external-link-icon']
       .filter((className: string | undefined) => className)
       .join(' ');
 

package/src/Utils/addTargetBlankToHyperlinksMarkdown.spec.js

@@ -10,7 +10,7 @@ test('add to external links', () => {
   const html = markdownIt.renderer.render(updatedTree);
 
   expect(html).toMatchInlineSnapshot(
-    `"Hello, <a href=\\"https://microsoft.com/\\" rel=\\"noopener noreferrer\\" target=\\"_blank\\">Microsoft</a>!"`
+    `"Hello, <a href="https://microsoft.com/" rel="noopener noreferrer" target="_blank">Microsoft</a>!"`
   );
 });
 
@@ -21,7 +21,7 @@ test("don't add for hashes", () => {
   const updatedTree = addTargetBlankToHyperlinksMarkdown(tree);
   const html = markdownIt.renderer.render(updatedTree);
 
-  expect(html).toMatchInlineSnapshot(`"Hello, <a href=\\"#microsoft\\">Microsoft</a>!"`);
+  expect(html).toMatchInlineSnapshot(`"Hello, <a href="#microsoft">Microsoft</a>!"`);
 });
 
 test("don't add for searches", () => {
@@ -31,7 +31,7 @@ test("don't add for searches", () => {
   const updatedTree = addTargetBlankToHyperlinksMarkdown(tree);
   const html = markdownIt.renderer.render(updatedTree);
 
-  expect(html).toMatchInlineSnapshot(`"Hello, <a href=\\"?q=microsoft\\">Microsoft</a>!"`);
+  expect(html).toMatchInlineSnapshot(`"Hello, <a href="?q=microsoft">Microsoft</a>!"`);
 });
 
 test("don't add for cross references", () => {
@@ -41,5 +41,5 @@ test("don't add for cross references", () => {
   const updatedTree = addTargetBlankToHyperlinksMarkdown(tree);
   const html = markdownIt.renderer.render(updatedTree);
 
-  expect(html).toMatchInlineSnapshot(`"Hello, <a href=\\"#microsoft\\">Microsoft</a>!"`);
+  expect(html).toMatchInlineSnapshot(`"Hello, <a href="#microsoft">Microsoft</a>!"`);
 });

package/src/Utils/createIconComponent.tsx

@@ -0,0 +1,126 @@
+import { useStyles } from '@msinternal/botframework-webchat-styles/react';
+import { validateProps } from '@msinternal/botframework-webchat-react-valibot';
+import cx from 'classnames';
+import {
+  object,
+  optional,
+  picklist,
+  pipe,
+  readonly,
+  type BaseIssue,
+  type BaseSchema,
+  type OptionalSchema,
+  type PicklistSchema
+} from 'valibot';
+import React, { type ComponentType } from 'react';
+
+type CSSModuleClasses = { readonly [key: string]: any };
+
+type Prefixes<T> = T extends `${infer P}--${string}` ? P : never;
+
+type SuffixesOf<Prefix extends string, T> = T extends `${Prefix}--${infer S}` ? S : never;
+
+type ModifierMap<T> = {
+  [P in Prefixes<keyof T>]?: SuffixesOf<P, keyof T>;
+};
+
+type SafeModifierList<TCSSModuleClasses> = keyof ModifierMap<TCSSModuleClasses> extends never
+  ? string
+  : keyof ModifierMap<TCSSModuleClasses>;
+
+type ModifierSchemaEntry = OptionalSchema<PicklistSchema<readonly [string, ...string[]], undefined>, undefined>;
+
+export type IconModifierPropsSchema<TModifiers extends string> = BaseSchema<
+  Partial<Record<TModifiers, string>>,
+  Readonly<Partial<Record<TModifiers, string>>>,
+  BaseIssue<unknown>
+> & {
+  readonly entries: Partial<Record<TModifiers, ModifierSchemaEntry>>;
+};
+
+function createPropsSchema<
+  const TCSSModuleClasses extends CSSModuleClasses,
+  const TModifiers extends SafeModifierList<TCSSModuleClasses>
+>(styles: TCSSModuleClasses, modifiers: TModifiers[]): IconModifierPropsSchema<TModifiers> {
+  const props = Object.keys(styles).reduce((acc, key) => {
+    const [rawBase, modifier] = key.split('--') as [string, string | undefined];
+
+    if (!modifier) {
+      return acc;
+    }
+
+    const base = rawBase as TModifiers;
+
+    if (!modifiers.includes(base)) {
+      return acc;
+    }
+
+    let modifierSet = acc.get(base);
+
+    if (!modifierSet) {
+      modifierSet = new Set<string>();
+      acc.set(base, modifierSet);
+    }
+
+    modifierSet.add(modifier);
+
+    return acc;
+  }, new Map<TModifiers, Set<string>>());
+
+  const schemaEntries = Array.from(props.entries()).reduce<Partial<Record<TModifiers, ModifierSchemaEntry>>>(
+    (acc, [base, modifierSet]) => {
+      const values = Array.from(modifierSet);
+
+      if (values.length) {
+        // eslint-disable-next-line security/detect-object-injection
+        acc[base] = optional(picklist(values as unknown as readonly [string, ...string[]])) as ModifierSchemaEntry;
+      }
+
+      return acc;
+    },
+    {}
+  );
+
+  const schema = object(schemaEntries as Partial<Record<TModifiers, ModifierSchemaEntry>>);
+
+  return pipe(schema, readonly()) as IconModifierPropsSchema<TModifiers>;
+}
+
+export default function createIconComponent<
+  const TProps extends { className?: string | undefined },
+  const TModifiers extends SafeModifierList<TCSSModuleClasses>,
+  const TCSSModuleClasses extends CSSModuleClasses
+>(
+  styles: TCSSModuleClasses,
+  modifiers: TModifiers[],
+  BaseIcon: ComponentType<TProps>
+): {
+  component: ComponentType<
+    (TModifiers extends Prefixes<keyof TCSSModuleClasses>
+      ? Pick<ModifierMap<TCSSModuleClasses>, TModifiers>
+      : Partial<Record<TModifiers, string>>) &
+      TProps
+  >;
+  modifierPropsSchema: IconModifierPropsSchema<TModifiers>;
+} {
+  type CSSModuleModifiers = ModifierMap<TCSSModuleClasses>;
+
+  // Do not bail if no CSS modules TypeScript plugin is provided.
+  type FinalCSSModuleModifiers = TModifiers extends keyof CSSModuleModifiers
+    ? Pick<CSSModuleModifiers, TModifiers>
+    : Partial<Record<TModifiers, string>>;
+
+  const modifierPropsSchema = createPropsSchema(styles, modifiers);
+
+  const component = (props => {
+    const { className, ...rest } = props;
+    const validatedProps = validateProps(modifierPropsSchema, props);
+    const classNames = useStyles(styles);
+
+    const classes = Object.entries(validatedProps).map(([key, value]) => classNames[`${key}--${value}`]);
+
+    return <BaseIcon className={cx(className, classes)} {...(rest as TProps)} />;
+  }) as ComponentType<FinalCSSModuleModifiers & TProps>;
+
+  return { component, modifierPropsSchema };
+}

package/src/Utils/downscaleImageToDataURL/downscaleImageToDataURLUsingBrowser.ts

@@ -39,6 +39,8 @@ function createCanvas(width: number, height: number): HTMLCanvasElement {
 }
 
 function loadImageFromBlob(blob: Blob): Promise<HTMLImageElement> {
+  // Blob is only loaded in <img> created inline and not presented in HTML.
+  // eslint-disable-next-line no-restricted-properties
   const blobURL = URL.createObjectURL(blob);
 
   return new Promise<HTMLImageElement>((resolve, reject) => {

package/src/Utils/downscaleImageToDataURL/downscaleImageToDataURLUsingWorker.ts

@@ -1,7 +1,7 @@
 import workerFunction from './downscaleImageToDataURLUsingWorker.worker';
 import { type WorkerJob, type WorkerReturnValue } from './WorkerJob';
 
-function createWorker(fn: Function | string): Promise<Worker> {
+function createWorker(fn: ((...args: unknown[]) => unknown) | string): Promise<Worker> {
   const blob = new Blob([`(${fn})()`], { type: 'text/javascript' });
   const url = window.URL.createObjectURL(blob);
 
@@ -52,7 +52,7 @@ const checkSupportOffscreenCanvas = () => {
     try {
       new OffscreenCanvas(1, 1).getContext('2d');
       isOffscreenCanvasSupportGetContext2D = true;
-    } catch (err) {
+    } catch {
       isOffscreenCanvasSupportGetContext2D = false;
     }
   }
@@ -74,7 +74,7 @@ function checkSupportWebWorker(): Promise<boolean> {
 
       try {
         worker = await createWorker('function(){postMessage("ready")}');
-      } catch (err) {
+      } catch {
         return false;
       }
 
@@ -95,7 +95,7 @@ function checkSupport(): Promise<boolean> {
         const results = await Promise.all([checkSupportOffscreenCanvas(), checkSupportWebWorker()]);
 
         return results.every(result => result);
-      } catch (err) {
+      } catch {
         return false;
       }
     })())

package/src/Utils/firstTabbableDescendant.js

@@ -27,7 +27,6 @@ function orSelf(element) {
   }
 
   // "msMatchesSelector" is vendor-prefixed version of "matches".
-  // eslint-disable-next-line dot-notation
   if ((element.matches || element['msMatchesSelector']).call(element, SELECTOR)) {
     return element;
   }

package/src/Utils/orgSchema/getFirstBaseOfSoftwareSourceCode.ts

@@ -0,0 +1,15 @@
+import { type OrgSchemaCreativeWork, type OrgSchemaSoftwareSourceCode } from 'botframework-webchat-core/org-schema.js';
+
+/**
+ * Finds the first `isBasedOf` element that is of type `SoftwareSourceCode`.
+ *
+ * @param messageThing The `CreativeWork` to find.
+ * @returns A `SoftwareSourceCode` if found, otherwise, `undefined`.
+ */
+export default function getFirstBaseOfSoftwareSourceCode(
+  messageThing: OrgSchemaCreativeWork | undefined
+): OrgSchemaSoftwareSourceCode | undefined {
+  return (messageThing?.isBasedOn ?? []).find(({ '@type': jsonLinkedDataTypes }) =>
+    jsonLinkedDataTypes.includes('SoftwareSourceCode')
+  );
+}

package/src/Utils/parseDocumentFragmentFromString.ts

@@ -0,0 +1,9 @@
+export default function parseDocumentFragmentFromString(html: string): DocumentFragment {
+  const parser = new DOMParser();
+  const parsedDocument = parser.parseFromString(html, 'text/html');
+  const fragment = parsedDocument.createDocumentFragment();
+
+  fragment.append(...parsedDocument.body.childNodes);
+
+  return fragment;
+}

package/src/Utils/readDataURIToBlob.ts

@@ -0,0 +1,37 @@
+import { toByteArray } from 'base64-js';
+
+const PATTERN = /^data:([^,]*?)(;(base64)){0,1},([A-Za-z0-9+/=]+)/u;
+
+const DEFAULT_CONTENT_TYPE = 'text/plain;charset=US-ASCII';
+
+export function parse(dataURI: string):
+  | {
+      base64: string;
+      contentType: string;
+      encoding: string;
+    }
+  | undefined {
+  const match = PATTERN.exec(dataURI);
+
+  if (!match) {
+    return;
+  }
+
+  const [, contentType, , encoding, base64] = match;
+
+  if (encoding !== 'base64') {
+    return;
+  }
+
+  return { base64, contentType: contentType || DEFAULT_CONTENT_TYPE, encoding };
+}
+
+export default function readDataURIToBlob(dataURI: string): Blob | undefined {
+  const parsed = parse(dataURI);
+
+  if (!parsed) {
+    return;
+  }
+
+  return new Blob([toByteArray(parsed.base64).buffer as ArrayBuffer], { type: parsed.contentType });
+}

package/src/Utils/serializeDocumentFragmentIntoString.ts

@@ -0,0 +1,3 @@
+export default function serializeDocumentFragmentIntoString(documentFragment: DocumentFragment): string {
+  return new XMLSerializer().serializeToString(documentFragment);
+}

package/src/Utils/supportPseudoClass.ts

@@ -9,7 +9,7 @@ export default function supportPseudoClass(pseudoClass: string, nonce?: string):
     styleElement.sheet.insertRule('html' + pseudoClass + '{}', 0);
 
     return true;
-  } catch (error) {
+  } catch {
     return false;
   } finally {
     document.head.removeChild(styleElement);

package/src/Utils/tabbableElements.ts

@@ -7,9 +7,15 @@ export default function tabbableElements(element?: HTMLElement): HTMLElement[] {
     ) || [];
 
   return ([] as HTMLElement[]).filter.call(candidates, (element: HTMLElement) => {
+    const style = window.getComputedStyle(element);
+
+    if (style.visibility === 'hidden' || style.display === 'none' || style.display === 'contents') {
+      return false;
+    }
+
     const tabIndexAttribute = element.attributes.getNamedItem('tabindex');
 
-    if (tabIndexAttribute && tabIndexAttribute.specified) {
+    if (tabIndexAttribute) {
       const value = parseInt(tabIndexAttribute.value, 10);
 
       return value >= 0 || (isNaN(value) && element.nodeName.toLowerCase() === 'input');

package/src/Utils/textFormatToContentType.ts

@@ -0,0 +1,14 @@
+export default function textFormatToContentType(
+  textFormat: string | undefined
+): 'text/markdown' | 'text/plain' | 'text/xml' {
+  switch (textFormat) {
+    case 'plain':
+      return 'text/plain';
+
+    case 'xml':
+      return 'text/xml';
+
+    default:
+      return 'text/markdown';
+  }
+}