ckeditor5-elements-schema 0.0.0-stage → 49.0.0-alpha.4

package/dist/definition/validateElementSchema.js

@@ -0,0 +1,145 @@
+import { ROOT, whyNot } from './canHold.js';
+import { ATTRIBUTE_NAME, ELEMENT_KEYS, ELEMENT_NAME, TAG_NAME, checkKeys, isRecord, readKind, readNames } from './readDefinition.js';
+import { suggest } from './suggest.js';
+/**
+ * Checks an element schema, so that it is not contradictory, and returns the problems. An empty array means that the
+ * schema is valid.
+ *
+ * The schema is rejected when it:
+ *
+ * * is not of the shape {@link ElementSchemaDefinition}: an object of elements, by name; has keys that are not part of
+ *   it (typos are problems), or has values of the wrong type;
+ * * declares an element with an unknown `type`, or an `empty` element with `allowChildren`;
+ * * has attribute names that are not valid, or that differ only in case (HTML attribute names are not case sensitive),
+ *   or an `editingTag` that is not the name of a tag;
+ * * refers to elements that do not exist (a name that is neither declared in the schema, nor in `external`), or lists the
+ *   same name twice;
+ * * allows what its type cannot hold: text or an inline element in a container or in the root, a block-level (not inline)
+ *   element in a block, or anything in an `empty` element, whichever side says it: `allowChildren` of the parent, or
+ *   `allowIn` of the child.
+ *
+ * `isInline` is about the position and the layout of an element, so it is valid for every type: an inline element is
+ * laid out in a line with its siblings. Inline elements are allowed only in blocks, which can hold several of them,
+ * e.g. inline containers, or inline images between text.
+ *
+ * It does not need an editor. The editor of `ElementSchema` runs it with the elements of the other plugins as `external`.
+ */
+export function validateElementSchema(input, { external = {} } = {}) {
+    const issues = [];
+    const report = (path, message) => {
+        issues.push({ path, message });
+    };
+    if (!isRecord(input)) {
+        report('', 'The schema must be an object of element definitions, by name: { "note": { "type": "container" } }.');
+        return issues;
+    }
+    const elements = input;
+    if (!Object.keys(elements).length) {
+        report('', 'The schema declares no elements: declare at least one.');
+        return issues;
+    }
+    if (isRecord(elements.elements) && !('type' in elements.elements)) {
+        report('elements', 'the schema is the object of the elements itself: remove the "elements" wrapper, and put the elements at the top.');
+        return issues;
+    }
+    // The first pass checks every definition on its own, and collects the kinds and the lists to cross-check.
+    const kinds = new Map();
+    const lists = new Map();
+    for (const [name, definition] of Object.entries(elements)) {
+        const path = name;
+        if (!ELEMENT_NAME.test(name)) {
+            report(path, `"${name}" is not a valid element name: use camelCase letters and digits, starting with a lowercase letter.`);
+        }
+        if (name in external) {
+            report(path, `"${name}" already exists in the editor (it is declared by another plugin): remove it, or rename it.`);
+        }
+        if (!isRecord(definition)) {
+            report(path, 'must be an object, e.g. { "type": "block" }.');
+            continue;
+        }
+        checkKeys(definition, ELEMENT_KEYS, path, report);
+        const kind = readKind(definition, path, report);
+        if (kind) {
+            kinds.set(name, kind);
+        }
+        const allowChildren = readNames(definition, 'allowChildren', path, report);
+        const allowIn = readNames(definition, 'allowIn', path, report);
+        const allowAttributes = readNames(definition, 'allowAttributes', path, report);
+        if (allowIn && !allowIn.length) {
+            report(`${path}.allowIn`, 'is empty, so the element would be allowed nowhere: list its parents, or remove it for the default places.');
+        }
+        const lowercase = new Map();
+        for (const [index, attribute] of (allowAttributes ?? []).entries()) {
+            const attributePath = `${path}.allowAttributes[${String(index)}]`;
+            const collides = lowercase.get(attribute.toLowerCase());
+            if (!ATTRIBUTE_NAME.test(attribute)) {
+                report(attributePath, `"${attribute}" is not a valid attribute name.`);
+            }
+            else if (collides !== undefined) {
+                report(attributePath, `"${attribute}" collides with "${collides}": the names of HTML attributes are not case sensitive, so the data could not tell them apart.`);
+            }
+            else {
+                lowercase.set(attribute.toLowerCase(), attribute);
+            }
+        }
+        if (definition.editingTag !== undefined &&
+            (typeof definition.editingTag !== 'string' || !TAG_NAME.test(definition.editingTag))) {
+            report(`${path}.editingTag`, `must be the name of an HTML tag, in lowercase, e.g. "section", not ${JSON.stringify(definition.editingTag)}.`);
+        }
+        if (kind?.type === 'empty' && allowChildren?.length) {
+            report(`${path}.allowChildren`, 'an empty element has no content: remove allowChildren, or change the type.');
+        }
+        lists.set(name, { allowChildren: kind?.type === 'empty' ? [] : (allowChildren ?? []), allowIn: allowIn ?? [] });
+    }
+    // The second pass checks what the lists refer to, and whether the types can hold each other.
+    const known = (name) => kinds.get(name) ?? external[name];
+    const candidates = [...kinds.keys(), ...Object.keys(external)];
+    for (const [name, { allowChildren, allowIn }] of lists) {
+        const kind = kinds.get(name);
+        if (!kind) {
+            continue;
+        }
+        allowChildren.forEach((child, index) => {
+            const path = `${name}.allowChildren[${String(index)}]`;
+            const childKind = child === '$text' ? child : resolveReference(child, known, candidates, path, report);
+            if (childKind) {
+                const reason = whyNot(kind, childKind);
+                if (reason) {
+                    report(path, `"${child}" cannot be a child of "${name}": ${reason}.`);
+                }
+            }
+        });
+        allowIn.forEach((parent, index) => {
+            const path = `${name}.allowIn[${String(index)}]`;
+            const parentKind = parent === '$root' ? ROOT : resolveReference(parent, known, candidates, path, report);
+            if (parentKind) {
+                const reason = whyNot(parentKind, kind);
+                if (reason) {
+                    report(path, `"${name}" cannot be allowed in ${parent === '$root' ? 'the root' : `"${parent}"`}: ${reason}.`);
+                }
+            }
+        });
+    }
+    // In the order of the file: the problems of an element together, whichever pass found them.
+    const names = Object.keys(elements);
+    const position = ({ path }) => names.findIndex(name => path === name || path.startsWith(`${name}.`));
+    return issues.sort((a, b) => position(a) - position(b));
+}
+/**
+ * Returns the kind of the element the list entry names. Reports an unknown name (with the closest known one), and the
+ * names that cannot be used there: `$text` and `$root` are not elements that can be both parents and children.
+ */
+function resolveReference(name, known, candidates, path, report) {
+    if (name === '$text' || name === '$root') {
+        report(path, name === '$text'
+            ? '"$text" is not an element: it is text, and cannot have children or parents.'
+            : '"$root" is the root of the editor: it can be a parent (allowIn), not a child.');
+        return undefined;
+    }
+    const kind = known(name);
+    if (!kind) {
+        report(path, `unknown element "${name}"${suggest(name, candidates)}. It must be declared in the schema, or be an element of another plugin that is loaded.`);
+    }
+    return kind;
+}
+//# sourceMappingURL=validateElementSchema.js.map

package/dist/definition/validateElementSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateElementSchema.js","sourceRoot":"","sources":["../../src/definition/validateElementSchema.ts"],"names":[],"mappings":"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"}

package/dist/elementSchema.d.ts

@@ -0,0 +1,47 @@
+import { Plugin } from 'ckeditor5';
+/**
+ * Declares elements in the model schema of the editor from a simple definition, the `elementSchema` editor option: a
+ * plain object, e.g. a JSON file.
+ *
+ * ```json
+ * {
+ *   "note": { "type": "container", "allowAttributes": ["type"] },
+ *   "title": { "type": "block", "allowIn": ["note"] },
+ *   "badge": { "type": "empty", "isInline": true, "allowAttributes": ["color"] }
+ * }
+ * ```
+ *
+ * Every element has one of three types, instead of CKEditor's many `is*` flags and generic items:
+ *
+ * * `empty`: has no content, like an image. It is an object, selected as a whole. With `isInline`, it is in a line of text.
+ * * `block`: can contain text and inline elements, like a paragraph. With `isInline`, it is an inline element with text,
+ *   like a bold that is an element with attributes.
+ * * `container`: cannot contain text, but blocks, containers and empty elements, like a block quote.
+ *
+ * `allowAttributes` and `allowChildren` work as in CKEditor's schema. `allowIn` too, but it replaces the default places.
+ * See {@link ElementSchemaElement}.
+ *
+ * The schema is validated first, and a schema that is contradictory or refers to unknown elements is not accepted: the
+ * editor is not created, and the {@link ElementSchemaError} lists all the problems (see {@link validateElementSchema}).
+ *
+ * The elements are registered after the plugins are initialized (in `afterInit()`), so they can refer to the elements
+ * of other plugins, e.g. `paragraph`. Plugins that extend or convert the elements must do it in `afterInit()` too, or
+ * later; the converters can be declared at any time.
+ *
+ * The `empty` and `container` elements can be selected as a whole, by a click on them and by the arrow keys, when
+ * the `ElementSelectable` plugin is loaded too: the element schema does not depend on it, and uses it when it is there
+ * (with `elementSchemaConverters`, it warns when it is not).
+ *
+ * The plugin declares the schema only: how the elements look in the editor and in the data is declared with
+ * converters, or by the plugin when the `elementSchemaConverters` option is `true`: one to one, as `div` and `span`.
+ */
+export default class ElementSchema extends Plugin {
+    static get pluginName(): 'ElementSchema';
+    afterInit(): void;
+    /**
+     * Makes the `empty` elements and the containers selectable as a whole, by a click on them and by the arrow keys, with
+     * `ElementSelectable`. Not the blocks: a click in a block puts the cursor in its text.
+     */
+    private _makeSelectable;
+}
+//# sourceMappingURL=elementSchema.d.ts.map

package/dist/elementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchema.d.ts","sourceRoot":"","sources":["../src/elementSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoB,MAAM,WAAW,CAAC;AAQrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,MAAM;IAChD,WAAkB,UAAU,IAAI,eAAe,CAE9C;IAEM,SAAS,IAAI,IAAI;IA+BxB;;;OAGG;IACH,OAAO,CAAC,eAAe;CAiBvB"}

package/dist/elementSchema.js

@@ -0,0 +1,108 @@
+import { Plugin } from 'ckeditor5';
+import { findPlugin } from 'ckeditor5-elements-core';
+import { compileElementSchema } from './definition/compileElementSchema.js';
+import { convertElementSchema } from './conversion/convertElementSchema.js';
+import ElementSchemaError from './definition/elementSchemaError.js';
+import { validateElementSchema } from './definition/validateElementSchema.js';
+/**
+ * Declares elements in the model schema of the editor from a simple definition, the `elementSchema` editor option: a
+ * plain object, e.g. a JSON file.
+ *
+ * ```json
+ * {
+ *   "note": { "type": "container", "allowAttributes": ["type"] },
+ *   "title": { "type": "block", "allowIn": ["note"] },
+ *   "badge": { "type": "empty", "isInline": true, "allowAttributes": ["color"] }
+ * }
+ * ```
+ *
+ * Every element has one of three types, instead of CKEditor's many `is*` flags and generic items:
+ *
+ * * `empty`: has no content, like an image. It is an object, selected as a whole. With `isInline`, it is in a line of text.
+ * * `block`: can contain text and inline elements, like a paragraph. With `isInline`, it is an inline element with text,
+ *   like a bold that is an element with attributes.
+ * * `container`: cannot contain text, but blocks, containers and empty elements, like a block quote.
+ *
+ * `allowAttributes` and `allowChildren` work as in CKEditor's schema. `allowIn` too, but it replaces the default places.
+ * See {@link ElementSchemaElement}.
+ *
+ * The schema is validated first, and a schema that is contradictory or refers to unknown elements is not accepted: the
+ * editor is not created, and the {@link ElementSchemaError} lists all the problems (see {@link validateElementSchema}).
+ *
+ * The elements are registered after the plugins are initialized (in `afterInit()`), so they can refer to the elements
+ * of other plugins, e.g. `paragraph`. Plugins that extend or convert the elements must do it in `afterInit()` too, or
+ * later; the converters can be declared at any time.
+ *
+ * The `empty` and `container` elements can be selected as a whole, by a click on them and by the arrow keys, when
+ * the `ElementSelectable` plugin is loaded too: the element schema does not depend on it, and uses it when it is there
+ * (with `elementSchemaConverters`, it warns when it is not).
+ *
+ * The plugin declares the schema only: how the elements look in the editor and in the data is declared with
+ * converters, or by the plugin when the `elementSchemaConverters` option is `true`: one to one, as `div` and `span`.
+ */
+export default class ElementSchema extends Plugin {
+    static get pluginName() {
+        return 'ElementSchema';
+    }
+    afterInit() {
+        const input = this.editor.config.get('elementSchema');
+        if (input === undefined) {
+            return;
+        }
+        const schema = this.editor.model.schema;
+        const issues = validateElementSchema(input, { external: getExternalKinds(schema) });
+        if (issues.length) {
+            throw new ElementSchemaError(issues);
+        }
+        const { items, children } = compileElementSchema(input);
+        for (const [name, definition] of items) {
+            schema.register(name, definition);
+        }
+        for (const { parent, child } of children) {
+            schema.extend(child, { allowIn: parent });
+        }
+        this._makeSelectable(input);
+        if (this.editor.config.get('elementSchemaConverters')) {
+            convertElementSchema(this.editor, input);
+        }
+    }
+    /**
+     * Makes the `empty` elements and the containers selectable as a whole, by a click on them and by the arrow keys, with
+     * `ElementSelectable`. Not the blocks: a click in a block puts the cursor in its text.
+     */
+    _makeSelectable(input) {
+        const names = Object.entries(input)
+            .filter(([, element]) => element.type === 'empty' || element.type === 'container')
+            .map(([name]) => name);
+        const selectable = findPlugin(this.editor, 'ElementSelectable', isSelectablePlugin);
+        if (selectable) {
+            selectable.add(...names);
+        }
+        else if (names.length && this.editor.config.get('elementSchemaConverters')) {
+            // The converters make the elements, and nothing selects them: say it, as it is a silent loss. Not CKEditor's
+            // `logWarning()`: it links to CKEditor's list of errors, which does not have this one.
+            // eslint-disable-next-line no-console -- A warning for the developer, once, when the editor is created.
+            console.warn(`ElementSchema: load ElementSelectable to select the elements of the schema as a whole: ${names.join(', ')}.`);
+        }
+    }
+}
+function isSelectablePlugin(plugin) {
+    return 'add' in plugin && typeof plugin.add === 'function';
+}
+/**
+ * Returns the kinds of the elements of other plugins: inline or not, and `empty` for objects, `block` for what can
+ * contain text, `container` for the rest. The generic items (`$block`, …) are not elements.
+ */
+function getExternalKinds(schema) {
+    const kinds = {};
+    for (const name of Object.keys(schema.getDefinitions())) {
+        if (!name.startsWith('$')) {
+            kinds[name] = {
+                isInline: schema.isInline(name),
+                type: schema.isObject(name) ? 'empty' : schema.checkChild(name, '$text') ? 'block' : 'container'
+            };
+        }
+    }
+    return kinds;
+}
+//# sourceMappingURL=elementSchema.js.map

package/dist/elementSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchema.js","sourceRoot":"","sources":["../src/elementSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAoB,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACrD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,kBAAkB,MAAM,oCAAoC,CAAC;AAEpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,MAAM;IACzC,MAAM,KAAK,UAAU;QAC3B,OAAO,eAAwB,CAAC;IACjC,CAAC;IAEM,SAAS;QACf,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAEtD,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO;QACR,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC;QACxC,MAAM,MAAM,GAAG,qBAAqB,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAEpF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,IAAI,kBAAkB,CAAC,MAAM,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAExD,KAAK,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,IAAI,KAAK,EAAE,CAAC;YACxC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QACnC,CAAC;QAED,KAAK,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,QAAQ,EAAE,CAAC;YAC1C,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;QAC3C,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QAE5B,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,EAAE,CAAC;YACvD,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QAC1C,CAAC;IACF,CAAC;IAED;;;OAGG;IACK,eAAe,CAAC,KAAyB;QAChD,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;aACjC,MAAM,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,OAAO,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW,CAAC;aACjF,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;QACxB,MAAM,UAAU,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,mBAAmB,EAAE,kBAAkB,CAAC,CAAC;QAEpF,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC;QAC1B,CAAC;aAAM,IAAI,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,yBAAyB,CAAC,EAAE,CAAC;YAC9E,6GAA6G;YAC7G,uFAAuF;YACvF,wGAAwG;YACxG,OAAO,CAAC,IAAI,CACX,0FAA0F,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAC7G,CAAC;QACH,CAAC;IACF,CAAC;CACD;AAUD,SAAS,kBAAkB,CAAC,MAAc;IACzC,OAAO,KAAK,IAAI,MAAM,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,UAAU,CAAC;AAC5D,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CAAC,MAAmB;IAC5C,MAAM,KAAK,GAAsC,EAAE,CAAC;IAEpD,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC;QACzD,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3B,KAAK,CAAC,IAAI,CAAC,GAAG;gBACb,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAC/B,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW;aAChG,CAAC;QACH,CAAC;IACF,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/elementSchemaCommands.d.ts

@@ -0,0 +1,83 @@
+import { Plugin } from 'ckeditor5';
+import ElementSchema from './elementSchema.js';
+/**
+ * An element of {@link ElementSchemaCommands}: its command and its button.
+ */
+export interface ElementSchemaCommandDefinition {
+    /**
+     * The model element: of the element schema, or of another plugin. Default: the name of the command.
+     */
+    element?: string;
+    /**
+     * The title of the command, and the label of its button, e.g. `'Bold'`.
+     */
+    title: string;
+    /**
+     * The icon of the command and of its button (an SVG string), e.g. `IconBold` of CKEditor.
+     */
+    icon?: string;
+    /**
+     * The keystroke that executes the command, e.g. `'Ctrl+B'`.
+     */
+    keystroke?: string;
+    /**
+     * The tag of the element in the data and in the editing view, e.g. `'strong'` or `'hr'`. The converters of the plugin
+     * replace the ones of the element schema (`elementSchemaConverters`) in the downcast, and the upcast takes both.
+     * Without it, the element is converted by the schema, or by your converters.
+     */
+    view?: string;
+}
+/**
+ * The `elementSchemaCommands` option: the elements, by the name of their command and of their button.
+ */
+export type ElementSchemaCommandsConfig = Record<string, ElementSchemaCommandDefinition>;
+/**
+ * Commands and toolbar buttons for the elements of the element schema, as CKEditor's features have for theirs: the
+ * command of an element is the one of its kind (see {@link ElementSchemaCommand}).
+ *
+ * | Element                       | Command                     | Works as CKEditor's           |
+ * | ----------------------------- | --------------------------- | ----------------------------- |
+ * | inline `block`                | {@link ElementInlineCommand}    | bold: wraps text              |
+ * | `block`                       | {@link ElementBlockCommand}     | heading: renames blocks       |
+ * | `container`                   | {@link ElementContainerCommand} | block quote: wraps blocks     |
+ * | `empty`, inline `container`   | {@link ElementInsertCommand}    | horizontal line: inserts      |
+ *
+ * ```ts
+ * elementSchema: schema,
+ * elementSchemaCommands: {
+ *   bold: { title: 'Bold', icon: IconBold, keystroke: 'Ctrl+B', view: 'strong' },
+ *   callout: { title: 'Callout', icon: IconQuote },
+ *   divider: { title: 'Divider', icon: IconHorizontalLine, view: 'hr' }
+ * },
+ * toolbar: ['bold', 'callout', 'divider']
+ * ```
+ *
+ * Each key is the name of the command and of its toolbar button. The commands have titles and icons, so they can be
+ * menu items too, e.g. of the context menu.
+ *
+ * At the ends of the inline elements with text, the left and right arrow keys move in two steps, as CKEditor's two-step
+ * caret movement does at the ends of a bold: in the element, then in the text.
+ *
+ * The commands are made when the elements are registered, after `ElementSchema` and the other plugins are initialized.
+ * The editor is not created when an element is unknown.
+ */
+export default class ElementSchemaCommands extends Plugin {
+    static get pluginName(): 'ElementSchemaCommands';
+    static get requires(): readonly [typeof ElementSchema];
+    /**
+     * The commands, by their name.
+     */
+    private readonly _commands;
+    init(): void;
+    /**
+     * Makes the commands of the elements, which are registered then, and their converters.
+     */
+    afterInit(): void;
+    private _getDefinitions;
+    /**
+     * Declares the converters of an element with the tag of its `view`: the downcast with the highest priority, so it
+     * replaces the ones of the element schema, and the upcast.
+     */
+    private _convert;
+}
+//# sourceMappingURL=elementSchemaCommands.d.ts.map

package/dist/elementSchemaCommands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchemaCommands.d.ts","sourceRoot":"","sources":["../src/elementSchemaCommands.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAA+D,MAAM,WAAW,CAAC;AAOhG,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAI/C;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC9C;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,MAAM;IACxD,WAAkB,UAAU,IAAI,uBAAuB,CAEtD;IAED,WAAkB,QAAQ,IAAI,SAAS,CAAC,OAAO,aAAa,CAAC,CAE5D;IAED;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2C;IAE9D,IAAI,IAAI,IAAI;IA2BnB;;OAEG;IACI,SAAS,IAAI,IAAI;IA0CxB,OAAO,CAAC,eAAe;IAIvB;;;OAGG;IACH,OAAO,CAAC,QAAQ;CAWhB"}

package/dist/elementSchemaCommands.js

@@ -0,0 +1,137 @@
+import { Plugin } from 'ckeditor5';
+import { ElementOrPositionButtonView } from 'ckeditor5-elements-core';
+import { createInlineTextElement } from './conversion/inlineTextElement.js';
+import ElementBlockCommand from './commands/elementBlockCommand.js';
+import ElementContainerCommand from './commands/elementContainerCommand.js';
+import ElementInlineCommand from './commands/elementInlineCommand.js';
+import ElementInsertCommand from './commands/elementInsertCommand.js';
+import ElementSchema from './elementSchema.js';
+import { enableTwoStepCaretMovement } from './typing/twoStepCaretMovement.js';
+/**
+ * Commands and toolbar buttons for the elements of the element schema, as CKEditor's features have for theirs: the
+ * command of an element is the one of its kind (see {@link ElementSchemaCommand}).
+ *
+ * | Element                       | Command                     | Works as CKEditor's           |
+ * | ----------------------------- | --------------------------- | ----------------------------- |
+ * | inline `block`                | {@link ElementInlineCommand}    | bold: wraps text              |
+ * | `block`                       | {@link ElementBlockCommand}     | heading: renames blocks       |
+ * | `container`                   | {@link ElementContainerCommand} | block quote: wraps blocks     |
+ * | `empty`, inline `container`   | {@link ElementInsertCommand}    | horizontal line: inserts      |
+ *
+ * ```ts
+ * elementSchema: schema,
+ * elementSchemaCommands: {
+ *   bold: { title: 'Bold', icon: IconBold, keystroke: 'Ctrl+B', view: 'strong' },
+ *   callout: { title: 'Callout', icon: IconQuote },
+ *   divider: { title: 'Divider', icon: IconHorizontalLine, view: 'hr' }
+ * },
+ * toolbar: ['bold', 'callout', 'divider']
+ * ```
+ *
+ * Each key is the name of the command and of its toolbar button. The commands have titles and icons, so they can be
+ * menu items too, e.g. of the context menu.
+ *
+ * At the ends of the inline elements with text, the left and right arrow keys move in two steps, as CKEditor's two-step
+ * caret movement does at the ends of a bold: in the element, then in the text.
+ *
+ * The commands are made when the elements are registered, after `ElementSchema` and the other plugins are initialized.
+ * The editor is not created when an element is unknown.
+ */
+export default class ElementSchemaCommands extends Plugin {
+    static get pluginName() {
+        return 'ElementSchemaCommands';
+    }
+    static get requires() {
+        return [ElementSchema];
+    }
+    /**
+     * The commands, by their name.
+     */
+    _commands = new Map();
+    init() {
+        const editor = this.editor;
+        for (const [name, { title, keystroke }] of this._getDefinitions()) {
+            if (keystroke) {
+                editor.keystrokes.set(keystroke, name);
+                editor.accessibility.addKeystrokeInfos({ keystrokes: [{ label: title, keystroke }] });
+            }
+            editor.ui.componentFactory.add(name, locale => {
+                const command = this._commands.get(name);
+                // The commands are made in `afterInit()`, and the toolbars after it.
+                if (!command) {
+                    throw new Error(`elementSchemaCommands.${name}: the button is created before the command.`);
+                }
+                const button = new ElementOrPositionButtonView(locale, command);
+                button.bind('isOn').to(command, 'isOn');
+                button.keystroke = keystroke;
+                return button;
+            });
+        }
+    }
+    /**
+     * Makes the commands of the elements, which are registered then, and their converters.
+     */
+    afterInit() {
+        const editor = this.editor;
+        const schema = editor.model.schema;
+        const inlineNames = new Set();
+        for (const [name, { element, title, icon, view }] of this._getDefinitions()) {
+            const elementName = element ?? name;
+            if (!schema.isRegistered(elementName)) {
+                throw new Error(`elementSchemaCommands.${name}: unknown element "${elementName}". Declare it in the element schema, or ` +
+                    `set "element" to an element of another plugin.`);
+            }
+            const CommandClass = getCommandClass(schema, elementName);
+            const command = new CommandClass(editor, elementName);
+            command.set({ title, icon });
+            editor.commands.add(name, command);
+            this._commands.set(name, command);
+            if (command instanceof ElementInlineCommand) {
+                inlineNames.add(elementName);
+            }
+            if (view) {
+                this._convert(elementName, view, (writer) => {
+                    if (command instanceof ElementInlineCommand) {
+                        return createInlineTextElement(writer, view);
+                    }
+                    return schema.isObject(elementName)
+                        ? writer.createEmptyElement(view)
+                        : writer.createContainerElement(view);
+                });
+            }
+        }
+        enableTwoStepCaretMovement(this, inlineNames);
+    }
+    _getDefinitions() {
+        return Object.entries(this.editor.config.get('elementSchemaCommands') ?? {});
+    }
+    /**
+     * Declares the converters of an element with the tag of its `view`: the downcast with the highest priority, so it
+     * replaces the ones of the element schema, and the upcast.
+     */
+    _convert(elementName, tag, createView) {
+        const conversion = this.editor.conversion;
+        conversion.for('upcast').elementToElement({ view: tag, model: elementName });
+        conversion.for('downcast').elementToElement({
+            model: elementName,
+            view: (_element, { writer }) => createView(writer),
+            // Over the ones of the schema, some of which are `high` already.
+            converterPriority: 'highest'
+        });
+    }
+}
+/**
+ * Returns the command of an element, by its kind: an object, or an inline element with no text, is inserted; an inline
+ * element with text wraps text; a block-level one with text is a block; the others are containers.
+ */
+function getCommandClass(schema, name) {
+    const holdsText = schema.checkChild(name, '$text');
+    if (schema.isObject(name) || (schema.isInline(name) && !holdsText)) {
+        return ElementInsertCommand;
+    }
+    if (schema.isInline(name)) {
+        return ElementInlineCommand;
+    }
+    return holdsText ? ElementBlockCommand : ElementContainerCommand;
+}
+//# sourceMappingURL=elementSchemaCommands.js.map

package/dist/elementSchemaCommands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchemaCommands.js","sourceRoot":"","sources":["../src/elementSchemaCommands.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Element schema: declare elements in the model schema from a simple definition, e.g. a JSON file, with three types of
+ * elements (`empty`, `block`, `container`), and a validation that rejects contradictory definitions. `ElementSchemaCommands`
+ * makes commands and buttons for its elements.
+ *
+ * @module ckeditor5-elements-schema
+ */
+export { default as ElementSchema } from './elementSchema.js';
+export { default as ElementSchemaCommands, type ElementSchemaCommandDefinition, type ElementSchemaCommandsConfig } from './elementSchemaCommands.js';
+export { default as ElementSchemaCommand } from './commands/elementSchemaCommand.js';
+export { default as ElementInlineCommand } from './commands/elementInlineCommand.js';
+export { default as ElementBlockCommand } from './commands/elementBlockCommand.js';
+export { default as ElementContainerCommand } from './commands/elementContainerCommand.js';
+export { default as ElementInsertCommand } from './commands/elementInsertCommand.js';
+export { withoutBlockFiller } from './conversion/inlineTextElement.js';
+export * from './validate.js';
+import './augmentation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EACN,OAAO,IAAI,qBAAqB,EAChC,KAAK,8BAA8B,EACnC,KAAK,2BAA2B,EAChC,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAC3F,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAGrF,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAGvE,cAAc,eAAe,CAAC;AAE9B,OAAO,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * Element schema: declare elements in the model schema from a simple definition, e.g. a JSON file, with three types of
+ * elements (`empty`, `block`, `container`), and a validation that rejects contradictory definitions. `ElementSchemaCommands`
+ * makes commands and buttons for its elements.
+ *
+ * @module ckeditor5-elements-schema
+ */
+// Plugins.
+export { default as ElementSchema } from './elementSchema.js';
+export { default as ElementSchemaCommands } from './elementSchemaCommands.js';
+// Commands.
+export { default as ElementSchemaCommand } from './commands/elementSchemaCommand.js';
+export { default as ElementInlineCommand } from './commands/elementInlineCommand.js';
+export { default as ElementBlockCommand } from './commands/elementBlockCommand.js';
+export { default as ElementContainerCommand } from './commands/elementContainerCommand.js';
+export { default as ElementInsertCommand } from './commands/elementInsertCommand.js';
+// Utils.
+export { withoutBlockFiller } from './conversion/inlineTextElement.js';
+// Validation and compiling, which do not need an editor (also in `validate.ts`, for Node.js).
+export * from './validate.js';
+import './augmentation.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,WAAW;AACX,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,EACN,OAAO,IAAI,qBAAqB,EAGhC,MAAM,4BAA4B,CAAC;AAEpC,YAAY;AACZ,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AACrF,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACnF,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,uCAAuC,CAAC;AAC3F,OAAO,EAAE,OAAO,IAAI,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAErF,SAAS;AACT,OAAO,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAEvE,8FAA8F;AAC9F,cAAc,eAAe,CAAC;AAE9B,OAAO,mBAAmB,CAAC"}

package/dist/typing/twoStepCaretMovement.d.ts

@@ -0,0 +1,11 @@
+import { type Plugin } from 'ckeditor5';
+/**
+ * Makes the left and right arrow keys move in two steps at the ends of inline elements, as CKEditor's two-step caret
+ * movement does at the ends of a bold: the first step goes into the element (or out of it), where the cursor looks the
+ * same, the next one moves in the text. `a[]<b>bc</b>` is `a<b>[]bc</b>`, then `a<b>b[]c</b>`. The browser would move by
+ * a character at once, and the positions on both sides of the end of an element would be out of reach.
+ *
+ * What is typed then goes where the cursor is. The listeners are the plugin's.
+ */
+export declare function enableTwoStepCaretMovement(plugin: Plugin, names: ReadonlySet<string>): void;
+//# sourceMappingURL=twoStepCaretMovement.d.ts.map

package/dist/typing/twoStepCaretMovement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"twoStepCaretMovement.d.ts","sourceRoot":"","sources":["../../src/typing/twoStepCaretMovement.ts"],"names":[],"mappings":"AAAA,OAAO,EAON,KAAK,MAAM,EAGX,MAAM,WAAW,CAAC;AAEnB;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CA8C3F"}