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

package/dist/readDefinition.js

@@ -0,0 +1,60 @@
+import { suggest } from './suggest.js';
+const TYPES = ['empty', 'block', 'container'];
+export const ELEMENT_KEYS = ['type', 'isInline', 'allowChildren', 'allowIn', 'allowAttributes', 'editingTag'];
+export const ELEMENT_NAME = /^[a-z][A-Za-z0-9]*$/;
+export const ATTRIBUTE_NAME = /^[A-Za-z][\w.:-]*$/;
+export const TAG_NAME = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+export function readKind(definition, path, report) {
+    const { type, isInline } = definition;
+    if (isInline !== undefined && typeof isInline !== 'boolean') {
+        report(`${path}.isInline`, 'must be true or false.');
+    }
+    if (type === undefined) {
+        report(`${path}.type`, 'is required: "empty", "block" or "container".');
+        return null;
+    }
+    if (typeof type !== 'string' || !TYPES.includes(type)) {
+        report(`${path}.type`, `must be "empty", "block" or "container", not ${JSON.stringify(type)}${typeof type === 'string' ? suggest(type, TYPES) : ''}.`);
+        return null;
+    }
+    return { type: type, isInline: isInline === true };
+}
+/**
+ * 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 function readNames(definition, key, path, report) {
+    const value = definition[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        report(`${path}.${key}`, `must be an array of names, e.g. ["a", "b"].`);
+        return undefined;
+    }
+    const names = [];
+    value.forEach((item, index) => {
+        const itemPath = `${path}.${key}[${String(index)}]`;
+        if (typeof item !== 'string' || !item) {
+            report(itemPath, 'must be a non-empty string.');
+        }
+        else if (names.includes(item)) {
+            report(itemPath, `"${item}" is listed twice.`);
+        }
+        else {
+            names.push(item);
+        }
+    });
+    return names;
+}
+export function checkKeys(object, allowed, path, report) {
+    for (const key of Object.keys(object)) {
+        if (!allowed.includes(key)) {
+            report(path ? `${path}.${key}` : key, `is not a known key${suggest(key, allowed)}. The keys are: ${allowed.map(name => `"${name}"`).join(', ')}.`);
+        }
+    }
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=readDefinition.js.map

package/dist/readDefinition.js.map

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

package/dist/suggest.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns ` Did you mean "x"?` for the closest candidate, when it is close enough to be a typo.
+ */
+export declare function suggest(name: string, candidates: readonly string[]): string;
+//# sourceMappingURL=suggest.d.ts.map

package/dist/suggest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../src/suggest.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAc3E"}

package/dist/suggest.js

@@ -0,0 +1,27 @@
+/**
+ * Returns ` Did you mean "x"?` for the closest candidate, when it is close enough to be a typo.
+ */
+export function suggest(name, candidates) {
+    let best;
+    let bestDistance = 3;
+    for (const candidate of candidates) {
+        const distance = editDistance(name.toLowerCase(), candidate.toLowerCase());
+        if (distance < bestDistance) {
+            best = candidate;
+            bestDistance = distance;
+        }
+    }
+    return best ? ` (did you mean "${best}"?)` : '';
+}
+function editDistance(a, b) {
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        for (let j = 1; j <= b.length; j++) {
+            current[j] = Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        previous = current;
+    }
+    return previous[b.length] ?? 0;
+}
+//# sourceMappingURL=suggest.js.map

package/dist/suggest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"suggest.js","sourceRoot":"","sources":["../src/suggest.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,UAAU,OAAO,CAAC,IAAY,EAAE,UAA6B;IAClE,IAAI,IAAwB,CAAC;IAC7B,IAAI,YAAY,GAAG,CAAC,CAAC;IAErB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,MAAM,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC;QAE3E,IAAI,QAAQ,GAAG,YAAY,EAAE,CAAC;YAC7B,IAAI,GAAG,SAAS,CAAC;YACjB,YAAY,GAAG,QAAQ,CAAC;QACzB,CAAC;IACF,CAAC;IAED,OAAO,IAAI,CAAC,CAAC,CAAC,mBAAmB,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AACjD,CAAC;AAED,SAAS,YAAY,CAAC,CAAS,EAAE,CAAS;IACzC,IAAI,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC;IAEzE,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC;QAEpB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CACpB,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EACtB,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,EACzB,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CACxD,CAAC;QACH,CAAC;QAED,QAAQ,GAAG,OAAO,CAAC;IACpB,CAAC;IAED,OAAO,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * The kinds of elements of an element schema:
+ *
+ * * `empty`: has no content, like an image or a line break. It is an object: selected as a whole.
+ * * `block`: can contain text and inline elements, like a paragraph or a heading. With `isInline`, it is an inline
+ *   element with text, like a bold with an `id`.
+ *
+ * * `container`: cannot contain text; holds blocks, empty block elements and other containers, like a block quote or a
+ *   note.
+ *
+ * Every type can be inline (see {@link ElementSchemaElement#isInline}): the type says what the element holds, `isInline`
+ * where and how it is laid out. Inline elements are allowed only in blocks.
+ */
+export type ElementSchemaType = 'empty' | 'block' | 'container';
+/**
+ * The kind of an element: what it is, and whether it is inline: laid out in a line with its siblings, instead of on a
+ * line of its own. Any type can be inline.
+ */
+export interface ElementSchemaKind {
+    type: ElementSchemaType;
+    isInline: boolean;
+}
+/**
+ * The definition of one element of an element schema.
+ */
+export interface ElementSchemaElement {
+    /**
+     * What the element is: `'empty'`, `'block'` or `'container'`.
+     */
+    type: ElementSchemaType;
+    /**
+     * Whether the element is inline: it is about the position and the layout of the element, not about text. An inline
+     * element is laid out in a line with its siblings, where a block-level one has a line of its own. Any type can be:
+     *
+     * * `empty`: like an inline image, or a line break;
+     * * `block`: an element with text in a line of text, like a bold that is an element, with attributes;
+     * * `container`: a box that is not typable, in a line with other boxes, e.g. several in a block.
+     *
+     * Inline elements are allowed only in blocks: by default, where text is. A block holds text and any number of inline
+     * elements; containers and the root hold no inline elements. Default: `false`.
+     */
+    isInline?: boolean;
+    /**
+     * The elements allowed inside this one, in addition to what its type allows: names of elements of the schema, or of
+     * elements of other plugins, and `'$text'`. As in CKEditor's `allowChildren`.
+     *
+     * What a type allows by default: a `block` has text and inline elements; a `container` has blocks, containers and
+     * `empty` block-level elements.
+     */
+    allowChildren?: string[];
+    /**
+     * The elements this one is allowed in, in addition to what its type allows: names of elements, and `'$root'`. As in
+     * CKEditor's `allowIn`.
+     *
+     * Unlike in CKEditor, when it is given it **replaces** the default places (a block-level element is allowed in the
+     * root and in containers; an inline element, where text is), so that an element can be restricted to its parent,
+     * e.g. a row to a table.
+     */
+    allowIn?: string[];
+    /**
+     * The attributes the element can have, as in CKEditor's `allowAttributes`.
+     */
+    allowAttributes?: string[];
+    /**
+     * The tag of the element in the editing view, e.g. `'section'`, when the converters of the schema are on (the
+     * `elementSchemaConverters` option). The data has `div` or `span`, whatever it is. Default: the tag of the data.
+     */
+    editingTag?: string;
+}
+/**
+ * An element schema: the definitions of the elements, by name.
+ */
+export type ElementSchemaDefinition = Record<string, ElementSchemaElement>;
+/**
+ * What the `elementSchema` option accepts: an {@link ElementSchemaDefinition}, or a JSON file imported as it is, whose
+ * strings TypeScript does not know are the allowed ones, and whose arrays are not known to be mutable. Either way, it is
+ * validated when the editor is created.
+ */
+export type ElementSchemaInput = Record<string, {
+    [Key in keyof ElementSchemaElement]: Key extends 'type' ? string : ElementSchemaElement[Key] extends string[] | undefined ? readonly string[] | undefined : ElementSchemaElement[Key];
+}>;
+/**
+ * A problem of an element schema.
+ */
+export interface ElementSchemaIssue {
+    /**
+     * Where the problem is, e.g. `note.allowChildren[1]`.
+     */
+    path: string;
+    /**
+     * What is wrong, and what to do about it.
+     */
+    message: string;
+}
+/**
+ * The options of {@link validateElementSchema}.
+ */
+export interface ValidateElementSchemaOptions {
+    /**
+     * Elements that exist outside the schema, e.g. `paragraph` of the `Paragraph` plugin, by name. The schema can refer to
+     * them, but cannot declare them. Without them, the schema can refer only to its own elements.
+     */
+    external?: Readonly<Record<string, ElementSchemaKind>>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,GAAG,WAAW,CAAC;AAEhE;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IACjC,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC;;OAEG;IACH,IAAI,EAAE,iBAAiB,CAAC;IAExB;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAE3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,CACtC,MAAM,EACN;KACE,GAAG,IAAI,MAAM,oBAAoB,GAAG,GAAG,SAAS,MAAM,GACpD,MAAM,GACN,oBAAoB,CAAC,GAAG,CAAC,SAAS,MAAM,EAAE,GAAG,SAAS,GACrD,SAAS,MAAM,EAAE,GAAG,SAAS,GAC7B,oBAAoB,CAAC,GAAG,CAAC;CAC7B,CACD,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC5C;;;OAGG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;CACvD"}

package/dist/types.js

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

package/dist/types.js.map

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

package/dist/validate.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The part of the element schema that needs no editor and no browser: the validation, the compiling to schema
+ * definitions, the error and the types. It is in its own module, so that it can be used in Node.js, e.g. to validate a
+ * schema file in a test or in CI: the main entry loads CKEditor, which needs a DOM.
+ *
+ * @module ckeditor5-elements-schema/validate
+ */
+export { validateElementSchema } from './validateElementSchema.js';
+export { compileElementSchema, type CompiledElementSchema } from './compileElementSchema.js';
+export { default as ElementSchemaError } from './elementSchemaError.js';
+export type { ElementSchemaDefinition, ElementSchemaElement, ElementSchemaInput, ElementSchemaIssue, ElementSchemaKind, ElementSchemaType, ValidateElementSchemaOptions } from './types.js';
+//# sourceMappingURL=validate.d.ts.map

package/dist/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAC7F,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AACxE,YAAY,EACX,uBAAuB,EACvB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,EAC5B,MAAM,YAAY,CAAC"}

package/dist/validate.js

@@ -0,0 +1,11 @@
+/**
+ * The part of the element schema that needs no editor and no browser: the validation, the compiling to schema
+ * definitions, the error and the types. It is in its own module, so that it can be used in Node.js, e.g. to validate a
+ * schema file in a test or in CI: the main entry loads CKEditor, which needs a DOM.
+ *
+ * @module ckeditor5-elements-schema/validate
+ */
+export { validateElementSchema } from './validateElementSchema.js';
+export { compileElementSchema } from './compileElementSchema.js';
+export { default as ElementSchemaError } from './elementSchemaError.js';
+//# sourceMappingURL=validate.js.map

package/dist/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","sourceRoot":"","sources":["../src/validate.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAA8B,MAAM,2BAA2B,CAAC;AAC7F,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/validateElementSchema.d.ts

@@ -0,0 +1,26 @@
+import type { ElementSchemaIssue, ValidateElementSchemaOptions } from './types.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 declare function validateElementSchema(input: unknown, { external }?: ValidateElementSchemaOptions): ElementSchemaIssue[];
+//# sourceMappingURL=validateElementSchema.d.ts.map

package/dist/validateElementSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateElementSchema.d.ts","sourceRoot":"","sources":["../src/validateElementSchema.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,kBAAkB,EAAqB,4BAA4B,EAAE,MAAM,YAAY,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CACpC,KAAK,EAAE,OAAO,EACd,EAAE,QAAa,EAAE,GAAE,4BAAiC,GAClD,kBAAkB,EAAE,CAkKtB"}

package/dist/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/validateElementSchema.js.map

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

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "ckeditor5-elements-schema",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "49.0.0-alpha.2",
+  "description": "Element schema for CKEditor 5: declare elements in the model schema from a simple definition, e.g. a JSON file, with three types of elements and a validation.",
+  "keywords": [
+    "ckeditor",
+    "ckeditor5",
+    "ckeditor 5",
+    "ckeditor5-feature",
+    "ckeditor5-plugin"
+  ],
+  "license": "MIT",
+  "author": "Ivan Kildyushov",
+  "homepage": "https://ivankild.github.io/ckeditor5-elements/guide/schema",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ivankild/ckeditor5-elements.git",
+    "directory": "packages/ckeditor5-elements-schema"
+  },
+  "bugs": {
+    "url": "https://github.com/ivankild/ckeditor5-elements/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./validate": {
+      "types": "./dist/validate.d.ts",
+      "import": "./dist/validate.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "ckeditor5-elements-core": "49.0.0-alpha.2"
+  },
+  "peerDependencies": {
+    "ckeditor5": "^49.0.0"
+  },
+  "scripts": {
+    "build": "tsc --build"
+  }
 }

package/src/augmentation.ts

@@ -0,0 +1,21 @@
+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;
+	}
+}

package/src/canHold.ts

@@ -0,0 +1,29 @@
+import type { ElementSchemaKind } from './types.js';
+
+/**
+ * The root can hold blocks, containers and block-level empty elements, like a container.
+ */
+export const ROOT: ElementSchemaKind = { type: 'container', isInline: false };
+
+/**
+ * Returns why `parent` cannot contain `child` (an element, or `'$text'`), or `null` when it can.
+ */
+export function whyNot(parent: ElementSchemaKind, child: ElementSchemaKind | '$text'): string | null {
+	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;
+}

package/src/compileElementSchema.ts

@@ -0,0 +1,88 @@
+import type { ModelSchemaItemDefinition } from 'ckeditor5';
+import type { ElementSchemaElement, 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 function compileElementSchema(input: ElementSchemaInput): CompiledElementSchema {
+	const items: CompiledElementSchema['items'] = [];
+	const children: CompiledElementSchema['children'] = [];
+
+	for (const [name, element] of Object.entries(input)) {
+		items.push([name, compileElement(element as ElementSchemaElement)]);
+
+		for (const child of element.allowChildren ?? []) {
+			children.push({ parent: name, child });
+		}
+	}
+
+	return { items, children };
+}
+
+function compileElement({ type, isInline, allowIn, allowAttributes }: ElementSchemaElement): ModelSchemaItemDefinition {
+	// Where the element is allowed: the places of its type, or the given ones.
+	const places = (defaultPlaces: string): Pick<ModelSchemaItemDefinition, 'allowIn' | 'allowWhere'> =>
+		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
+	};
+}