Creating Custom Widgets

The Static CMS exposes a window.CMS global object that you can use to register custom widgets via registerWidget. The same object is also the default export if you import Static CMS as an npm module.

React Components Inline

The registerPreviewTemplate requires you to provide a React component. If you have a build process in place for your project, it is possible to integrate with this build process.

However, although possible, it may be cumbersome or even impractical to add a React build phase. For this reason, Static CMS exposes some constructs globally to allow you to create components inline: h (alias for React.createElement) as well some basic hooks (useState, useMemo, useEffect, useCallback).

NOTE: createClass is still provided, allowing for the creation of react class components. However it has now been deprecated and will be removed in v2.0.0.

Register Widget

Register a custom widget.

// Using global window object
CMS.registerWidget(name, control, [preview], [schema]);

// Using npm module import
import CMS from '@staticcms/core';
CMS.registerWidget(name, control, [preview], [schema]);

Params

Control Component

The react component that renders the control. It receives the following props:

Open Media Library

openMediaLibrary allows you to open up the media library popup. It accepts the following props:

Query

query allows you to search the entries of a given collection. It accepts the following props:

Preview Component

The react component that renders the preview. It receives the following props:

Options

Register widget takes an optional object of options. These options include:

Example

admin/index.html

<script src="https://unpkg.com/@staticcms/app@%5E1.0.0/dist/static-cms-app.js"></script>
<script>
  const CategoriesControl = ({ label, value, field, onChange }) => {
    const separator = useMemo(() => field.separator ?? ', ', [field.separator]);

    const handleChange = useCallback((e) => {
      onChange(e.target.value.split(separator).map(e => e.trim()));
    }, [separator, onChange]);

    return h('div', {}, {
      h('label', { for: 'inputId' }, label),
      h('input', {
        id: 'inputId',
        type: 'text',
        value: value ? value.join(separator) : '',
        onChange: this.handleChange,
      })
    });
  };

  const CategoriesPreview = ({ value }) => {
    return h(
      'ul',
      {},
      value.map(function (val, index) {
        return h('li', { key: index }, val);
      }),
    );
  };

  const schema = {
    properties: {
      separator: { type: 'string' },
    },
  };

  CMS.registerWidget('categories', CategoriesControl, CategoriesPreview, options: { schema });
</script>

admin/config.yml (or admin/config.js)

collections:
  - name: posts
    label: Posts
    folder: content/posts
    fields:
      - name: title
        label: Title
        widget: string
      - name: categories
        label: Categories
        widget: categories
        separator: __

Advanced field validation

All widget fields, including those for built-in widgets, include basic validation capability using the required and pattern options.

With custom widgets, the widget can also optionally pass in a validator method to perform custom validations, in addition to presence and pattern. The validator function will be automatically called, and it can return either a boolean value, an object with a type and error message or a promise.

Examples

No Errors

const validator = () => {
  // Do internal validation
  return true;
};

Has Error

const validator = () => {
  // Do internal validation
  return false;
};

Error With Type

const validator = () => {
  // Do internal validation
  return { type: 'custom-error' };
};

Error With Type and Message

Useful for returning custom error messages

const validator = () => {
  // Do internal validation
  return { type: 'custom-error', message: 'Your error message.' };
};

Promise

You can also return a promise from validator. The promise can return boolean value, an object with a type and error message or a promise.

const validator = () => {
  return this.existingPromise;
};