@ckeditor/ckeditor5-html-support 0.0.0-internal-20241017.0

package/src/integrations/mediaembed.js

@@ -0,0 +1,125 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module html-support/integrations/mediaembed
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import DataFilter from '../datafilter.js';
+import DataSchema from '../dataschema.js';
+import { updateViewAttributes, getHtmlAttributeName } from '../utils.js';
+import { getDescendantElement } from './integrationutils.js';
+/**
+ * Provides the General HTML Support integration with {@link module:media-embed/mediaembed~MediaEmbed Media Embed} feature.
+ */
+export default class MediaEmbedElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [DataFilter];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'MediaEmbedElementSupport';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        // Stop here if MediaEmbed plugin is not provided or the integrator wants to output markup with previews as
+        // we do not support filtering previews.
+        if (!editor.plugins.has('MediaEmbed') || editor.config.get('mediaEmbed.previewsInData')) {
+            return;
+        }
+        const schema = editor.model.schema;
+        const conversion = editor.conversion;
+        const dataFilter = this.editor.plugins.get(DataFilter);
+        const dataSchema = this.editor.plugins.get(DataSchema);
+        const mediaElementName = editor.config.get('mediaEmbed.elementName');
+        // Overwrite GHS schema definition for a given elementName.
+        dataSchema.registerBlockElement({
+            model: 'media',
+            view: mediaElementName
+        });
+        dataFilter.on('register:figure', () => {
+            conversion.for('upcast').add(viewToModelFigureAttributesConverter(dataFilter));
+        });
+        dataFilter.on(`register:${mediaElementName}`, (evt, definition) => {
+            if (definition.model !== 'media') {
+                return;
+            }
+            schema.extend('media', {
+                allowAttributes: [
+                    getHtmlAttributeName(mediaElementName),
+                    'htmlFigureAttributes'
+                ]
+            });
+            conversion.for('upcast').add(viewToModelMediaAttributesConverter(dataFilter, mediaElementName));
+            conversion.for('dataDowncast').add(modelToViewMediaAttributeConverter(mediaElementName));
+            evt.stop();
+        });
+    }
+}
+function viewToModelMediaAttributesConverter(dataFilter, mediaElementName) {
+    const upcastMedia = (evt, data, conversionApi) => {
+        const viewMediaElement = data.viewItem;
+        preserveElementAttributes(viewMediaElement, getHtmlAttributeName(mediaElementName));
+        function preserveElementAttributes(viewElement, attributeName) {
+            const viewAttributes = dataFilter.processViewAttributes(viewElement, conversionApi);
+            if (viewAttributes) {
+                conversionApi.writer.setAttribute(attributeName, viewAttributes, data.modelRange);
+            }
+        }
+    };
+    return (dispatcher) => {
+        dispatcher.on(`element:${mediaElementName}`, upcastMedia, { priority: 'low' });
+    };
+}
+/**
+ * View-to-model conversion helper preserving allowed attributes on {@link module:media-embed/mediaembed~MediaEmbed MediaEmbed}
+ * feature model element from figure view element.
+ *
+ * @returns Returns a conversion callback.
+ */
+function viewToModelFigureAttributesConverter(dataFilter) {
+    return (dispatcher) => {
+        dispatcher.on('element:figure', (evt, data, conversionApi) => {
+            const viewFigureElement = data.viewItem;
+            if (!data.modelRange || !viewFigureElement.hasClass('media')) {
+                return;
+            }
+            const viewAttributes = dataFilter.processViewAttributes(viewFigureElement, conversionApi);
+            if (viewAttributes) {
+                conversionApi.writer.setAttribute('htmlFigureAttributes', viewAttributes, data.modelRange);
+            }
+        }, { priority: 'low' });
+    };
+}
+function modelToViewMediaAttributeConverter(mediaElementName) {
+    return (dispatcher) => {
+        addAttributeConversionDispatcherHandler(mediaElementName, getHtmlAttributeName(mediaElementName));
+        addAttributeConversionDispatcherHandler('figure', 'htmlFigureAttributes');
+        function addAttributeConversionDispatcherHandler(elementName, attributeName) {
+            dispatcher.on(`attribute:${attributeName}:media`, (evt, data, conversionApi) => {
+                if (!conversionApi.consumable.consume(data.item, evt.name)) {
+                    return;
+                }
+                const { attributeOldValue, attributeNewValue } = data;
+                const containerElement = conversionApi.mapper.toViewElement(data.item);
+                const viewElement = getDescendantElement(conversionApi.writer, containerElement, elementName);
+                updateViewAttributes(conversionApi.writer, attributeOldValue, attributeNewValue, viewElement);
+            });
+        }
+    };
+}

package/src/integrations/script.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module html-support/integrations/script
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import DataFilter from '../datafilter.js';
+/**
+ * Provides the General HTML Support for `script` elements.
+ */
+export default class ScriptElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof DataFilter];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "ScriptElementSupport";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}

package/src/integrations/script.js

@@ -0,0 +1,65 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module html-support/integrations/script
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import { createObjectView, modelToViewBlockAttributeConverter, viewToModelBlockAttributeConverter, viewToModelObjectConverter } from '../converters.js';
+import DataFilter from '../datafilter.js';
+/**
+ * Provides the General HTML Support for `script` elements.
+ */
+export default class ScriptElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [DataFilter];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'ScriptElementSupport';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const dataFilter = this.editor.plugins.get(DataFilter);
+        dataFilter.on('register:script', (evt, definition) => {
+            const editor = this.editor;
+            const schema = editor.model.schema;
+            const conversion = editor.conversion;
+            schema.register('htmlScript', definition.modelSchema);
+            schema.extend('htmlScript', {
+                allowAttributes: ['htmlScriptAttributes', 'htmlContent'],
+                isContent: true
+            });
+            editor.data.registerRawContentMatcher({
+                name: 'script'
+            });
+            conversion.for('upcast').elementToElement({
+                view: 'script',
+                model: viewToModelObjectConverter(definition)
+            });
+            conversion.for('upcast').add(viewToModelBlockAttributeConverter(definition, dataFilter));
+            conversion.for('downcast').elementToElement({
+                model: 'htmlScript',
+                view: (modelElement, { writer }) => {
+                    return createObjectView('script', modelElement, writer);
+                }
+            });
+            conversion.for('downcast').add(modelToViewBlockAttributeConverter(definition));
+            evt.stop();
+        });
+    }
+}

package/src/integrations/style.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module html-support/integrations/style
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import DataFilter from '../datafilter.js';
+/**
+ * Provides the General HTML Support for `style` elements.
+ */
+export default class StyleElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof DataFilter];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "StyleElementSupport";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}

package/src/integrations/style.js

@@ -0,0 +1,65 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+/**
+ * @module html-support/integrations/style
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import { createObjectView, modelToViewBlockAttributeConverter, viewToModelBlockAttributeConverter, viewToModelObjectConverter } from '../converters.js';
+import DataFilter from '../datafilter.js';
+/**
+ * Provides the General HTML Support for `style` elements.
+ */
+export default class StyleElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [DataFilter];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'StyleElementSupport';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const dataFilter = this.editor.plugins.get(DataFilter);
+        dataFilter.on('register:style', (evt, definition) => {
+            const editor = this.editor;
+            const schema = editor.model.schema;
+            const conversion = editor.conversion;
+            schema.register('htmlStyle', definition.modelSchema);
+            schema.extend('htmlStyle', {
+                allowAttributes: ['htmlStyleAttributes', 'htmlContent'],
+                isContent: true
+            });
+            editor.data.registerRawContentMatcher({
+                name: 'style'
+            });
+            conversion.for('upcast').elementToElement({
+                view: 'style',
+                model: viewToModelObjectConverter(definition)
+            });
+            conversion.for('upcast').add(viewToModelBlockAttributeConverter(definition, dataFilter));
+            conversion.for('downcast').elementToElement({
+                model: 'htmlStyle',
+                view: (modelElement, { writer }) => {
+                    return createObjectView('style', modelElement, writer);
+                }
+            });
+            conversion.for('downcast').add(modelToViewBlockAttributeConverter(definition));
+            evt.stop();
+        });
+    }
+}

package/src/integrations/table.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import DataFilter from '../datafilter.js';
+/**
+ * Provides the General HTML Support integration with {@link module:table/table~Table Table} feature.
+ */
+export default class TableElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires(): readonly [typeof DataFilter];
+    /**
+     * @inheritDoc
+     */
+    static get pluginName(): "TableElementSupport";
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin(): true;
+    /**
+     * @inheritDoc
+     */
+    init(): void;
+}

package/src/integrations/table.js

@@ -0,0 +1,169 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import { Plugin } from 'ckeditor5/src/core.js';
+import { updateViewAttributes } from '../utils.js';
+import DataFilter from '../datafilter.js';
+import { getDescendantElement } from './integrationutils.js';
+/**
+ * Provides the General HTML Support integration with {@link module:table/table~Table Table} feature.
+ */
+export default class TableElementSupport extends Plugin {
+    /**
+     * @inheritDoc
+     */
+    static get requires() {
+        return [DataFilter];
+    }
+    /**
+     * @inheritDoc
+     */
+    static get pluginName() {
+        return 'TableElementSupport';
+    }
+    /**
+     * @inheritDoc
+     */
+    static get isOfficialPlugin() {
+        return true;
+    }
+    /**
+     * @inheritDoc
+     */
+    init() {
+        const editor = this.editor;
+        if (!editor.plugins.has('TableEditing')) {
+            return;
+        }
+        const schema = editor.model.schema;
+        const conversion = editor.conversion;
+        const dataFilter = editor.plugins.get(DataFilter);
+        const tableUtils = editor.plugins.get('TableUtils');
+        dataFilter.on('register:figure', () => {
+            conversion.for('upcast').add(viewToModelFigureAttributeConverter(dataFilter));
+        });
+        dataFilter.on('register:table', (evt, definition) => {
+            if (definition.model !== 'table') {
+                return;
+            }
+            schema.extend('table', {
+                allowAttributes: [
+                    'htmlTableAttributes',
+                    // Figure, thead and tbody elements don't have model counterparts.
+                    // We will be preserving attributes on table element using these attribute keys.
+                    'htmlFigureAttributes', 'htmlTheadAttributes', 'htmlTbodyAttributes'
+                ]
+            });
+            conversion.for('upcast').add(viewToModelTableAttributeConverter(dataFilter));
+            conversion.for('downcast').add(modelToViewTableAttributeConverter());
+            editor.model.document.registerPostFixer(createHeadingRowsPostFixer(editor.model, tableUtils));
+            evt.stop();
+        });
+    }
+}
+/**
+ * Creates a model post-fixer for thead and tbody GHS related attributes.
+ */
+function createHeadingRowsPostFixer(model, tableUtils) {
+    return writer => {
+        const changes = model.document.differ.getChanges();
+        let wasFixed = false;
+        for (const change of changes) {
+            if (change.type != 'attribute' || change.attributeKey != 'headingRows') {
+                continue;
+            }
+            const table = change.range.start.nodeAfter;
+            const hasTHeadAttributes = table.getAttribute('htmlTheadAttributes');
+            const hasTBodyAttributes = table.getAttribute('htmlTbodyAttributes');
+            if (hasTHeadAttributes && !change.attributeNewValue) {
+                writer.removeAttribute('htmlTheadAttributes', table);
+                wasFixed = true;
+            }
+            else if (hasTBodyAttributes && change.attributeNewValue == tableUtils.getRows(table)) {
+                writer.removeAttribute('htmlTbodyAttributes', table);
+                wasFixed = true;
+            }
+        }
+        return wasFixed;
+    };
+}
+/**
+ * View-to-model conversion helper preserving allowed attributes on {@link module:table/table~Table Table}
+ * feature model element.
+ *
+ * @returns Returns a conversion callback.
+ */
+function viewToModelTableAttributeConverter(dataFilter) {
+    return (dispatcher) => {
+        dispatcher.on('element:table', (evt, data, conversionApi) => {
+            if (!data.modelRange) {
+                return;
+            }
+            const viewTableElement = data.viewItem;
+            preserveElementAttributes(viewTableElement, 'htmlTableAttributes');
+            for (const childNode of viewTableElement.getChildren()) {
+                if (childNode.is('element', 'thead')) {
+                    preserveElementAttributes(childNode, 'htmlTheadAttributes');
+                }
+                if (childNode.is('element', 'tbody')) {
+                    preserveElementAttributes(childNode, 'htmlTbodyAttributes');
+                }
+            }
+            function preserveElementAttributes(viewElement, attributeName) {
+                const viewAttributes = dataFilter.processViewAttributes(viewElement, conversionApi);
+                if (viewAttributes) {
+                    conversionApi.writer.setAttribute(attributeName, viewAttributes, data.modelRange);
+                }
+            }
+        }, { priority: 'low' });
+    };
+}
+/**
+ * View-to-model conversion helper preserving allowed attributes on {@link module:table/table~Table Table}
+ * feature model element from figure view element.
+ *
+ * @returns Returns a conversion callback.
+ */
+function viewToModelFigureAttributeConverter(dataFilter) {
+    return (dispatcher) => {
+        dispatcher.on('element:figure', (evt, data, conversionApi) => {
+            const viewFigureElement = data.viewItem;
+            if (!data.modelRange || !viewFigureElement.hasClass('table')) {
+                return;
+            }
+            const viewAttributes = dataFilter.processViewAttributes(viewFigureElement, conversionApi);
+            if (viewAttributes) {
+                conversionApi.writer.setAttribute('htmlFigureAttributes', viewAttributes, data.modelRange);
+            }
+        }, { priority: 'low' });
+    };
+}
+/**
+ * Model-to-view conversion helper applying attributes from {@link module:table/table~Table Table}
+ * feature.
+ *
+ * @returns Returns a conversion callback.
+ */
+function modelToViewTableAttributeConverter() {
+    return (dispatcher) => {
+        addAttributeConversionDispatcherHandler('table', 'htmlTableAttributes');
+        addAttributeConversionDispatcherHandler('figure', 'htmlFigureAttributes');
+        addAttributeConversionDispatcherHandler('thead', 'htmlTheadAttributes');
+        addAttributeConversionDispatcherHandler('tbody', 'htmlTbodyAttributes');
+        function addAttributeConversionDispatcherHandler(elementName, attributeName) {
+            dispatcher.on(`attribute:${attributeName}:table`, (evt, data, conversionApi) => {
+                if (!conversionApi.consumable.test(data.item, evt.name)) {
+                    return;
+                }
+                const containerElement = conversionApi.mapper.toViewElement(data.item);
+                const viewElement = getDescendantElement(conversionApi.writer, containerElement, elementName);
+                if (!viewElement) {
+                    return;
+                }
+                conversionApi.consumable.consume(data.item, evt.name);
+                updateViewAttributes(conversionApi.writer, data.attributeOldValue, data.attributeNewValue, viewElement);
+            });
+        }
+    };
+}

package/src/schemadefinitions.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @license Copyright (c) 2003-2024, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-oss-license
+ */
+import type { DataSchemaBlockElementDefinition, DataSchemaInlineElementDefinition } from './dataschema.js';
+/**
+ * @module html-support/schemadefinitions
+ */
+declare const _default: {
+    block: DataSchemaBlockElementDefinition[];
+    inline: DataSchemaInlineElementDefinition[];
+};
+export default _default;