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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivan Kildyushov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,45 @@
-# Temporary Holding Version
+# ckeditor5-elements-schema
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Element schema for CKEditor 5 Elements: `ElementSchema` declares elements in the model schema from a simple definition,
+e.g. a JSON file, with three types of elements (`empty`, `block`, `container`), and rejects definitions that are
+contradictory.
+
+## Installation
+
+This package is part of `ckeditor5-elements`. Install the whole package to use it:
+
+```sh
+npm install ckeditor5 ckeditor5-elements
+```
+
+## Usage
+
+```json
+{
+	"note": { "type": "container", "allowAttributes": ["type"] },
+	"title": { "type": "block", "allowIn": ["note"] },
+	"badge": { "type": "empty", "isInline": true, "allowAttributes": ["color"] }
+}
+```
+
+```ts
+import { ElementSchema } from 'ckeditor5-elements';
+import schema from './schema.json';
+
+// In the editor config:
+plugins: [..., ElementSchema],
+elementSchema: schema,
+elementSchemaConverters: true // Optional: converts the elements one to one, as `div` and `span`
+```
+
+The `empty` and `container` elements can be selected as a whole, by a click and by the arrow keys, when `ElementSelectable`
+(from `ckeditor5-elements-selectable`) is loaded too.
+
+`validateElementSchema(schema)` checks a definition without an editor, e.g. in a test or in CI. In Node.js, import it from
+`ckeditor5-elements/validate-schema`: the main entry loads CKEditor, which needs a browser.
+
+See the [Element schema guide](https://ivankild.github.io/ckeditor5-elements/guide/schema) of the documentation.
+
+## License
+
+MIT

package/dist/augmentation.d.ts

@@ -0,0 +1,19 @@
+import type { ElementSchema, ElementSchemaInput } from './index.js';
+declare module 'ckeditor5' {
+    interface PluginsMap {
+        [ElementSchema.pluginName]: ElementSchema;
+    }
+    interface EditorConfig {
+        /**
+         * The elements to declare in the model schema: an object, e.g. a JSON file. See {@link ElementSchema}.
+         */
+        elementSchema?: ElementSchemaInput;
+        /**
+         * Whether to declare the converters of the elements of `elementSchema`, one to one: `div` or `span` with the name as
+         * the class, and the attributes as `data-*` attributes, in the data and in the editing view; `editingTag` of an
+         * element sets another tag for the editing view. See {@link ElementSchema}. Default: `false`.
+         */
+        elementSchemaConverters?: boolean;
+    }
+}
+//# sourceMappingURL=augmentation.d.ts.map

package/dist/augmentation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"augmentation.d.ts","sourceRoot":"","sources":["../src/augmentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEpE,OAAO,QAAQ,WAAW,CAAC;IAC1B,UAAU,UAAU;QACnB,CAAC,aAAa,CAAC,UAAU,CAAC,EAAE,aAAa,CAAC;KAC1C;IAED,UAAU,YAAY;QACrB;;WAEG;QACH,aAAa,CAAC,EAAE,kBAAkB,CAAC;QAEnC;;;;WAIG;QACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;KAClC;CACD"}

package/dist/augmentation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=augmentation.js.map

package/dist/augmentation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"augmentation.js","sourceRoot":"","sources":["../src/augmentation.ts"],"names":[],"mappings":""}

package/dist/canHold.d.ts

@@ -0,0 +1,10 @@
+import type { ElementSchemaKind } from './types.js';
+/**
+ * The root can hold blocks, containers and block-level empty elements, like a container.
+ */
+export declare const ROOT: ElementSchemaKind;
+/**
+ * Returns why `parent` cannot contain `child` (an element, or `'$text'`), or `null` when it can.
+ */
+export declare function whyNot(parent: ElementSchemaKind, child: ElementSchemaKind | '$text'): string | null;
+//# sourceMappingURL=canHold.d.ts.map

package/dist/canHold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canHold.d.ts","sourceRoot":"","sources":["../src/canHold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,iBAA0D,CAAC;AAE9E;;GAEG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,iBAAiB,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAkBnG"}

package/dist/canHold.js

@@ -0,0 +1,22 @@
+/**
+ * The root can hold blocks, containers and block-level empty elements, like a container.
+ */
+export const ROOT = { type: 'container', isInline: false };
+/**
+ * Returns why `parent` cannot contain `child` (an element, or `'$text'`), or `null` when it can.
+ */
+export function whyNot(parent, child) {
+    const isText = child === '$text';
+    if (parent.type === 'empty') {
+        return 'an empty element cannot contain anything';
+    }
+    if (parent.type === 'block') {
+        const what = parent.isInline ? 'an inline text element' : 'a block';
+        return isText || child.isInline ? null : `${what} can contain only text and inline elements`;
+    }
+    if (isText) {
+        return 'a container cannot contain text: put the text in a block';
+    }
+    return child.isInline ? 'a container cannot contain inline elements: put them in a block' : null;
+}
+//# sourceMappingURL=canHold.js.map

package/dist/canHold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canHold.js","sourceRoot":"","sources":["../src/canHold.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAsB,EAAE,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAE9E;;GAEG;AACH,MAAM,UAAU,MAAM,CAAC,MAAyB,EAAE,KAAkC;IACnF,MAAM,MAAM,GAAG,KAAK,KAAK,OAAO,CAAC;IAEjC,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,OAAO,0CAA0C,CAAC;IACnD,CAAC;IAED,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,wBAAwB,CAAC,CAAC,CAAC,SAAS,CAAC;QAEpE,OAAO,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,4CAA4C,CAAC;IAC9F,CAAC;IAED,IAAI,MAAM,EAAE,CAAC;QACZ,OAAO,0DAA0D,CAAC;IACnE,CAAC;IAED,OAAO,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,iEAAiE,CAAC,CAAC,CAAC,IAAI,CAAC;AAClG,CAAC"}

package/dist/compileElementSchema.d.ts

@@ -0,0 +1,41 @@
+import type { ModelSchemaItemDefinition } from 'ckeditor5';
+import type { ElementSchemaInput } from './types.js';
+/**
+ * The result of {@link compileElementSchema}.
+ */
+export interface CompiledElementSchema {
+    /**
+     * The items to register in CKEditor's schema, by name.
+     */
+    items: [name: string, definition: ModelSchemaItemDefinition][];
+    /**
+     * The `allowChildren` of the elements, as the places to add to the children: `schema.extend(child, { allowIn: parent })`.
+     * The child can be an element of another plugin, which is extended, not registered.
+     */
+    children: {
+        parent: string;
+        child: string;
+    }[];
+}
+/**
+ * Translates a valid element schema to the definitions of CKEditor's schema. Each type is made like a generic item of
+ * CKEditor:
+ *
+ * * `container`: like `$container`: allowed in the root and in containers; holds what is allowed in a container: blocks,
+ *   containers and block objects, not text.
+ * * `block`: like `$block`: a block, allowed in the root and in containers; holds text and inline objects.
+ * * `empty` and not inline: like `$blockObject`: an object, allowed where blocks are.
+ * * `empty` and inline: like `$inlineObject`: an object, allowed where text is, with the attributes of text.
+ * * `block` and inline: an inline element that holds text and inline elements, allowed where text is, with the attributes
+ *   of text: like `$text`, but an element, so it can have attributes of its own.
+ * * `container` and inline: a container laid out in a line, e.g. with others in a block: allowed where text is, like every
+ *   inline element, and holds the same as a container: blocks, not text.
+ *
+ * `isInline` is about the layout and the position of an element, so it is set for every type, and CKEditor's features and
+ * the converters can use it.
+ *
+ * `allowAttributes` is passed as it is. `allowIn` replaces the default places of the type. `allowChildren` adds to what
+ * the type holds, as in CKEditor.
+ */
+export declare function compileElementSchema(input: ElementSchemaInput): CompiledElementSchema;
+//# sourceMappingURL=compileElementSchema.d.ts.map

package/dist/compileElementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileElementSchema.d.ts","sourceRoot":"","sources":["../src/compileElementSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,WAAW,CAAC;AAC3D,OAAO,KAAK,EAAwB,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE3E;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,yBAAyB,CAAC,EAAE,CAAC;IAE/D;;;OAGG;IACH,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,kBAAkB,GAAG,qBAAqB,CAarF"}

package/dist/compileElementSchema.js

@@ -0,0 +1,60 @@
+/**
+ * Translates a valid element schema to the definitions of CKEditor's schema. Each type is made like a generic item of
+ * CKEditor:
+ *
+ * * `container`: like `$container`: allowed in the root and in containers; holds what is allowed in a container: blocks,
+ *   containers and block objects, not text.
+ * * `block`: like `$block`: a block, allowed in the root and in containers; holds text and inline objects.
+ * * `empty` and not inline: like `$blockObject`: an object, allowed where blocks are.
+ * * `empty` and inline: like `$inlineObject`: an object, allowed where text is, with the attributes of text.
+ * * `block` and inline: an inline element that holds text and inline elements, allowed where text is, with the attributes
+ *   of text: like `$text`, but an element, so it can have attributes of its own.
+ * * `container` and inline: a container laid out in a line, e.g. with others in a block: allowed where text is, like every
+ *   inline element, and holds the same as a container: blocks, not text.
+ *
+ * `isInline` is about the layout and the position of an element, so it is set for every type, and CKEditor's features and
+ * the converters can use it.
+ *
+ * `allowAttributes` is passed as it is. `allowIn` replaces the default places of the type. `allowChildren` adds to what
+ * the type holds, as in CKEditor.
+ */
+export function compileElementSchema(input) {
+    const items = [];
+    const children = [];
+    for (const [name, element] of Object.entries(input)) {
+        items.push([name, compileElement(element)]);
+        for (const child of element.allowChildren ?? []) {
+            children.push({ parent: name, child });
+        }
+    }
+    return { items, children };
+}
+function compileElement({ type, isInline, allowIn, allowAttributes }) {
+    // Where the element is allowed: the places of its type, or the given ones.
+    const places = (defaultPlaces) => allowIn ? { allowIn } : { allowWhere: defaultPlaces };
+    const attributes = allowAttributes ? { allowAttributes } : {};
+    if (type === 'empty' && isInline) {
+        return { inheritTypesFrom: '$inlineObject', allowAttributesOf: '$text', ...places('$text'), ...attributes };
+    }
+    if (type === 'empty') {
+        return { inheritTypesFrom: '$blockObject', ...places('$block'), ...attributes };
+    }
+    if (type === 'block' && isInline) {
+        return {
+            isInline: true,
+            allowContentOf: '$block',
+            allowAttributesOf: '$text',
+            ...places('$text'),
+            ...attributes
+        };
+    }
+    if (type === 'block') {
+        return { inheritTypesFrom: '$block', allowContentOf: '$block', ...places('$block'), ...attributes };
+    }
+    return {
+        allowContentOf: '$container',
+        ...(isInline ? { isInline: true, ...places('$text') } : places('$block')),
+        ...attributes
+    };
+}
+//# sourceMappingURL=compileElementSchema.js.map

package/dist/compileElementSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compileElementSchema.js","sourceRoot":"","sources":["../src/compileElementSchema.ts"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAyB;IAC7D,MAAM,KAAK,GAAmC,EAAE,CAAC;IACjD,MAAM,QAAQ,GAAsC,EAAE,CAAC;IAEvD,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,cAAc,CAAC,OAA+B,CAAC,CAAC,CAAC,CAAC;QAEpE,KAAK,MAAM,KAAK,IAAI,OAAO,CAAC,aAAa,IAAI,EAAE,EAAE,CAAC;YACjD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACxC,CAAC;IACF,CAAC;IAED,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,cAAc,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,EAAwB;IACzF,2EAA2E;IAC3E,MAAM,MAAM,GAAG,CAAC,aAAqB,EAA6D,EAAE,CACnG,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,aAAa,EAAE,CAAC;IACvD,MAAM,UAAU,GAAG,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAE9D,IAAI,IAAI,KAAK,OAAO,IAAI,QAAQ,EAAE,CAAC;QAClC,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,iBAAiB,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;IAC7G,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACtB,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;IACjF,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,IAAI,QAAQ,EAAE,CAAC;QAClC,OAAO;YACN,QAAQ,EAAE,IAAI;YACd,cAAc,EAAE,QAAQ;YACxB,iBAAiB,EAAE,OAAO;YAC1B,GAAG,MAAM,CAAC,OAAO,CAAC;YAClB,GAAG,UAAU;SACb,CAAC;IACH,CAAC;IAED,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;QACtB,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,cAAc,EAAE,QAAQ,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,GAAG,UAAU,EAAE,CAAC;IACrG,CAAC;IAED,OAAO;QACN,cAAc,EAAE,YAAY;QAC5B,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzE,GAAG,UAAU;KACb,CAAC;AACH,CAAC"}

package/dist/convertElementSchema.d.ts

@@ -0,0 +1,16 @@
+import type { Editor } from 'ckeditor5';
+import type { ElementSchemaElement, ElementSchemaInput } from './types.js';
+/**
+ * Returns the tag of an element in the data: a `span` for what is in a line of text (an inline element that is empty or
+ * has text), a `div` for the rest. An inline container is a `div`: it holds blocks, which a `span` cannot hold.
+ */
+export declare function getViewTag({ type, isInline }: Pick<ElementSchemaElement, 'type' | 'isInline'>): 'div' | 'span';
+/**
+ * Declares the converters of the elements of a schema, one to one: an element is a `div` or a `span` in the data (see
+ * {@link getViewTag}), with its name as the class. Its attributes are `data-*` attributes. The data is loaded as it is
+ * saved. The editing view is the same, except for the tag, when the element has an `editingTag`.
+ *
+ * The `empty` elements are empty in the data too: `<div class="divider"></div>`, with no filler.
+ */
+export declare function convertElementSchema(editor: Editor, input: ElementSchemaInput): void;
+//# sourceMappingURL=convertElementSchema.d.ts.map

package/dist/convertElementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertElementSchema.d.ts","sourceRoot":"","sources":["../src/convertElementSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE3E;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG,KAAK,GAAG,MAAM,CAE9G;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAgCpF"}

package/dist/convertElementSchema.js

@@ -0,0 +1,43 @@
+/**
+ * Returns the tag of an element in the data: a `span` for what is in a line of text (an inline element that is empty or
+ * has text), a `div` for the rest. An inline container is a `div`: it holds blocks, which a `span` cannot hold.
+ */
+export function getViewTag({ type, isInline }) {
+    return isInline && type !== 'container' ? 'span' : 'div';
+}
+/**
+ * Declares the converters of the elements of a schema, one to one: an element is a `div` or a `span` in the data (see
+ * {@link getViewTag}), with its name as the class. Its attributes are `data-*` attributes. The data is loaded as it is
+ * saved. The editing view is the same, except for the tag, when the element has an `editingTag`.
+ *
+ * The `empty` elements are empty in the data too: `<div class="divider"></div>`, with no filler.
+ */
+export function convertElementSchema(editor, input) {
+    const { conversion } = editor;
+    for (const [name, element] of Object.entries(input)) {
+        const { type, editingTag, allowAttributes } = element;
+        const tag = getViewTag(element);
+        const view = { name: tag, classes: name };
+        for (const key of allowAttributes ?? []) {
+            // The names of HTML attributes are lowercase, so the data has them in lowercase; the model keeps the key as it is.
+            conversion.attributeToAttribute({ model: { name, key }, view: `data-${key.toLowerCase()}` });
+        }
+        // Upcast, data downcast and editing downcast at once; what differs is declared with a higher priority.
+        conversion.elementToElement({ model: name, view });
+        if (type === 'empty') {
+            conversion.for('dataDowncast').elementToElement({
+                model: name,
+                view: (_element, { writer }) => writer.createEmptyElement(tag, { class: name }),
+                converterPriority: 'high'
+            });
+        }
+        if (editingTag) {
+            conversion.for('editingDowncast').elementToElement({
+                model: name,
+                view: { name: editingTag, classes: name },
+                converterPriority: 'high'
+            });
+        }
+    }
+}
+//# sourceMappingURL=convertElementSchema.js.map

package/dist/convertElementSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertElementSchema.js","sourceRoot":"","sources":["../src/convertElementSchema.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,UAAU,UAAU,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAmD;IAC7F,OAAO,QAAQ,IAAI,IAAI,KAAK,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC;AAC1D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAAC,MAAc,EAAE,KAAyB;IAC7E,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IAE9B,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,eAAe,EAAE,GAAG,OAA+B,CAAC;QAC9E,MAAM,GAAG,GAAG,UAAU,CAAC,OAA+B,CAAC,CAAC;QACxD,MAAM,IAAI,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;QAE1C,KAAK,MAAM,GAAG,IAAI,eAAe,IAAI,EAAE,EAAE,CAAC;YACzC,mHAAmH;YACnH,UAAU,CAAC,oBAAoB,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,GAAG,CAAC,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC;QAC9F,CAAC;QAED,uGAAuG;QACvG,UAAU,CAAC,gBAAgB,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAEnD,IAAI,IAAI,KAAK,OAAO,EAAE,CAAC;YACtB,UAAU,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,gBAAgB,CAAC;gBAC/C,KAAK,EAAE,IAAI;gBACX,IAAI,EAAE,CAAC,QAAQ,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,kBAAkB,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;gBAC/E,iBAAiB,EAAE,MAAM;aACzB,CAAC,CAAC;QACJ,CAAC;QAED,IAAI,UAAU,EAAE,CAAC;YAChB,UAAU,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC,gBAAgB,CAAC;gBAClD,KAAK,EAAE,IAAI;gBACX,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,IAAI,EAAE;gBACzC,iBAAiB,EAAE,MAAM;aACzB,CAAC,CAAC;QACJ,CAAC;IACF,CAAC;AACF,CAAC"}

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 './compileElementSchema.js';
+import { convertElementSchema } from './convertElementSchema.js';
+import ElementSchemaError from './elementSchemaError.js';
+import { validateElementSchema } from './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":"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"}

package/dist/elementSchemaError.d.ts

@@ -0,0 +1,12 @@
+import type { ElementSchemaIssue } from './types.js';
+/**
+ * Thrown when the element schema is not valid. It lists all the problems, and has them in {@link issues}.
+ */
+export default class ElementSchemaError extends Error {
+    /**
+     * The problems of the schema.
+     */
+    readonly issues: readonly ElementSchemaIssue[];
+    constructor(issues: readonly ElementSchemaIssue[]);
+}
+//# sourceMappingURL=elementSchemaError.d.ts.map

package/dist/elementSchemaError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchemaError.d.ts","sourceRoot":"","sources":["../src/elementSchemaError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,KAAK;IACpD;;OAEG;IACH,SAAgB,MAAM,EAAE,SAAS,kBAAkB,EAAE,CAAC;gBAE1C,MAAM,EAAE,SAAS,kBAAkB,EAAE;CASjD"}

package/dist/elementSchemaError.js

@@ -0,0 +1,16 @@
+/**
+ * Thrown when the element schema is not valid. It lists all the problems, and has them in {@link issues}.
+ */
+export default class ElementSchemaError extends Error {
+    /**
+     * The problems of the schema.
+     */
+    issues;
+    constructor(issues) {
+        super(`The element schema is not valid (${String(issues.length)} ${issues.length === 1 ? 'problem' : 'problems'}):\n` +
+            issues.map(({ path, message }) => `- ${path ? `${path}: ` : ''}${message}`).join('\n'));
+        this.name = 'ElementSchemaError';
+        this.issues = issues;
+    }
+}
+//# sourceMappingURL=elementSchemaError.js.map

package/dist/elementSchemaError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"elementSchemaError.js","sourceRoot":"","sources":["../src/elementSchemaError.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,kBAAmB,SAAQ,KAAK;IACpD;;OAEG;IACa,MAAM,CAAgC;IAEtD,YAAY,MAAqC;QAChD,KAAK,CACJ,oCAAoC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,MAAM;YAC9G,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CACvF,CAAC;QAEF,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACtB,CAAC;CACD"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ * @module ckeditor5-elements-schema
+ */
+export { default as ElementSchema } from './elementSchema.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;;;;;GAKG;AAGH,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAG9D,cAAc,eAAe,CAAC;AAE9B,OAAO,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ *
+ * @module ckeditor5-elements-schema
+ */
+// Plugins.
+export { default as ElementSchema } from './elementSchema.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;;;;;GAKG;AAEH,WAAW;AACX,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAE9D,8FAA8F;AAC9F,cAAc,eAAe,CAAC;AAE9B,OAAO,mBAAmB,CAAC"}

package/dist/readDefinition.d.ts

@@ -0,0 +1,18 @@
+import type { ElementSchemaKind } from './types.js';
+/**
+ * Reports a problem of the schema, at the path.
+ */
+export type Report = (path: string, message: string) => void;
+export declare const ELEMENT_KEYS: string[];
+export declare const ELEMENT_NAME: RegExp;
+export declare const ATTRIBUTE_NAME: RegExp;
+export declare const TAG_NAME: RegExp;
+export declare function readKind(definition: Record<string, unknown>, path: string, report: Report): ElementSchemaKind | null;
+/**
+ * Reads a list of names, and reports what is not a list of unique, non-empty strings. Returns the list, or
+ * `undefined` when it is missing.
+ */
+export declare function readNames(definition: Record<string, unknown>, key: string, path: string, report: Report): string[] | undefined;
+export declare function checkKeys(object: Record<string, unknown>, allowed: readonly string[], path: string, report: Report): void;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+//# sourceMappingURL=readDefinition.d.ts.map

package/dist/readDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readDefinition.d.ts","sourceRoot":"","sources":["../src/readDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAG7D,eAAO,MAAM,YAAY,UAAoF,CAAC;AAE9G,eAAO,MAAM,YAAY,QAAwB,CAAC;AAClD,eAAO,MAAM,cAAc,QAAuB,CAAC;AACnD,eAAO,MAAM,QAAQ,QAAkC,CAAC;AAExD,wBAAgB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CAuBpH;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACxB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACZ,MAAM,EAAE,GAAG,SAAS,CA4BtB;AAED,wBAAgB,SAAS,CACxB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACZ,IAAI,CASN;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE"}