@ckeditor/ckeditor5-html-support 47.6.1 → 48.0.0-alpha.1

package/src/dataschema.js

@@ -1,199 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module html-support/dataschema
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-import { toArray } from 'ckeditor5/src/utils.js';
-import { defaultConfig } from './schemadefinitions.js';
-import { mergeWith } from 'es-toolkit/compat';
-/**
- * Holds representation of the extended HTML document type definitions to be used by the
- * editor in HTML support.
- *
- * Data schema is represented by data schema definitions.
- *
- * To add new definition for block element,
- * use {@link module:html-support/dataschema~DataSchema#registerBlockElement} method:
- *
- * ```ts
- * dataSchema.registerBlockElement( {
- * 	view: 'section',
- * 	model: 'my-section',
- * 	modelSchema: {
- * 		inheritAllFrom: '$block'
- * 	}
- * } );
- * ```
- *
- * To add new definition for inline element,
- * use {@link module:html-support/dataschema~DataSchema#registerInlineElement} method:
- *
- * ```
- * dataSchema.registerInlineElement( {
- * 	view: 'span',
- * 	model: 'my-span',
- * 	attributeProperties: {
- * 		copyOnEnter: true
- * 	}
- * } );
- * ```
- */
-export class DataSchema extends Plugin {
-    /**
-     * A map of registered data schema definitions.
-     */
-    _definitions = [];
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'DataSchema';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        for (const definition of defaultConfig.block) {
-            this.registerBlockElement(definition);
-        }
-        for (const definition of defaultConfig.inline) {
-            this.registerInlineElement(definition);
-        }
-    }
-    /**
-     * Add new data schema definition describing block element.
-     */
-    registerBlockElement(definition) {
-        this._definitions.push({ ...definition, isBlock: true });
-    }
-    /**
-     * Add new data schema definition describing inline element.
-     */
-    registerInlineElement(definition) {
-        this._definitions.push({ ...definition, isInline: true });
-    }
-    /**
-     * Updates schema definition describing block element with new properties.
-     *
-     * Creates new scheme if it doesn't exist.
-     * Array properties are concatenated with original values.
-     *
-     * @param definition Definition update.
-     */
-    extendBlockElement(definition) {
-        this._extendDefinition({ ...definition, isBlock: true });
-    }
-    /**
-     * Updates schema definition describing inline element with new properties.
-     *
-     * Creates new scheme if it doesn't exist.
-     * Array properties are concatenated with original values.
-     *
-     * @param definition Definition update.
-     */
-    extendInlineElement(definition) {
-        this._extendDefinition({ ...definition, isInline: true });
-    }
-    /**
-     * Returns all definitions matching the given view name.
-     *
-     * @param includeReferences Indicates if this method should also include definitions of referenced models.
-     */
-    getDefinitionsForView(viewName, includeReferences = false) {
-        const definitions = new Set();
-        for (const definition of this._getMatchingViewDefinitions(viewName)) {
-            if (includeReferences) {
-                for (const reference of this._getReferences(definition.model)) {
-                    definitions.add(reference);
-                }
-            }
-            definitions.add(definition);
-        }
-        return definitions;
-    }
-    /**
-     * Returns definitions matching the given model name.
-     */
-    getDefinitionsForModel(modelName) {
-        return this._definitions.filter(definition => definition.model == modelName);
-    }
-    /**
-     * Returns definitions matching the given view name.
-     */
-    _getMatchingViewDefinitions(viewName) {
-        return this._definitions.filter(def => def.view && testViewName(viewName, def.view));
-    }
-    /**
-     * Resolves all definition references registered for the given data schema definition.
-     *
-     * @param modelName Data schema model name.
-     */
-    *_getReferences(modelName) {
-        const inheritProperties = [
-            'inheritAllFrom',
-            'inheritTypesFrom',
-            'allowWhere',
-            'allowContentOf',
-            'allowAttributesOf'
-        ];
-        const definitions = this._definitions.filter(definition => definition.model == modelName);
-        for (const { modelSchema } of definitions) {
-            if (!modelSchema) {
-                continue;
-            }
-            for (const property of inheritProperties) {
-                for (const referenceName of toArray(modelSchema[property] || [])) {
-                    const definitions = this._definitions.filter(definition => definition.model == referenceName);
-                    for (const definition of definitions) {
-                        if (referenceName !== modelName) {
-                            yield* this._getReferences(definition.model);
-                            yield definition;
-                        }
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Updates schema definition with new properties.
-     *
-     * Creates new scheme if it doesn't exist.
-     * Array properties are concatenated with original values.
-     *
-     * @param definition Definition update.
-     */
-    _extendDefinition(definition) {
-        const currentDefinitions = Array.from(this._definitions.entries())
-            .filter(([, currentDefinition]) => currentDefinition.model == definition.model);
-        if (currentDefinitions.length == 0) {
-            this._definitions.push(definition);
-            return;
-        }
-        for (const [idx, currentDefinition] of currentDefinitions) {
-            this._definitions[idx] = mergeWith({}, currentDefinition, definition, (target, source) => {
-                return Array.isArray(target) ? target.concat(source) : undefined;
-            });
-        }
-    }
-}
-/**
- * Test view name against the given pattern.
- */
-function testViewName(pattern, viewName) {
-    if (typeof pattern === 'string') {
-        return pattern === viewName;
-    }
-    if (pattern instanceof RegExp) {
-        return pattern.test(viewName);
-    }
-    return false;
-}

package/src/emptyblock.js

@@ -1,146 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-const EMPTY_BLOCK_MODEL_ATTRIBUTE = 'htmlEmptyBlock';
-/**
- * This plugin allows for preserving empty block elements in the editor content
- * instead of automatically filling them with block fillers (` `).
- *
- * This is useful when you want to:
- *
- * * Preserve empty block elements exactly as they were in the source HTML.
- * * Allow for styling empty blocks with CSS (block fillers can interfere with height/margin).
- * * Maintain compatibility with external systems that expect empty blocks to remain empty.
- *
- * Known limitations:
- *
- * * Empty blocks may not work correctly with revision history features.
- * * Keyboard navigation through the document might behave unexpectedly, especially when
- *   navigating through structures like lists and tables.
- *
- * For example, this allows for HTML like:
- *
- * ```html
- * <p></p>
- * <p class="spacer"></p>
- * <td></td>
- * ```
- * to remain empty instead of being converted to:
- *
- * ```html
- * <p>&nbsp;</p>
- * <p class="spacer">&nbsp;</p>
- * <td>&nbsp;</td>
- * ```
- */
-export class EmptyBlock extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'EmptyBlock';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    afterInit() {
-        const { model, conversion, plugins, config } = this.editor;
-        const schema = model.schema;
-        const preserveEmptyBlocksInEditingView = config.get('htmlSupport.preserveEmptyBlocksInEditingView');
-        schema.extend('$block', { allowAttributes: [EMPTY_BLOCK_MODEL_ATTRIBUTE] });
-        schema.extend('$container', { allowAttributes: [EMPTY_BLOCK_MODEL_ATTRIBUTE] });
-        if (schema.isRegistered('tableCell')) {
-            schema.extend('tableCell', { allowAttributes: [EMPTY_BLOCK_MODEL_ATTRIBUTE] });
-        }
-        if (preserveEmptyBlocksInEditingView) {
-            conversion.for('downcast').add(createEmptyBlockDowncastConverter());
-        }
-        else {
-            conversion.for('dataDowncast').add(createEmptyBlockDowncastConverter());
-        }
-        conversion.for('upcast').add(createEmptyBlockUpcastConverter(schema));
-        if (plugins.has('ClipboardPipeline')) {
-            this._registerClipboardPastingHandler();
-        }
-    }
-    /**
-     * Handle clipboard paste events:
-     *
-     * * It does not affect *copying* content from the editor, only *pasting*.
-     * * When content is pasted from another editor instance with `<p></p>`,
-     *   the `&nbsp;` filler is added, so the getData result is `<p>&nbsp;</p>`.
-     * * When content is pasted from the same editor instance with `<p></p>`,
-     *   the `&nbsp;` filler is not added, so the getData result is `<p></p>`.
-     */
-    _registerClipboardPastingHandler() {
-        const clipboardPipeline = this.editor.plugins.get('ClipboardPipeline');
-        this.listenTo(clipboardPipeline, 'contentInsertion', (evt, data) => {
-            if (data.sourceEditorId === this.editor.id) {
-                return;
-            }
-            this.editor.model.change(writer => {
-                for (const { item } of writer.createRangeIn(data.content)) {
-                    if (item.is('element') && item.hasAttribute(EMPTY_BLOCK_MODEL_ATTRIBUTE)) {
-                        writer.removeAttribute(EMPTY_BLOCK_MODEL_ATTRIBUTE, item);
-                    }
-                }
-            });
-        });
-    }
-}
-/**
- * Creates a downcast converter for handling empty blocks.
- * This converter prevents filler elements from being added to elements marked as empty blocks.
- */
-function createEmptyBlockDowncastConverter() {
-    return (dispatcher) => {
-        dispatcher.on(`attribute:${EMPTY_BLOCK_MODEL_ATTRIBUTE}`, (evt, data, conversionApi) => {
-            const { mapper, consumable } = conversionApi;
-            const { item } = data;
-            if (!consumable.consume(item, evt.name)) {
-                return;
-            }
-            const viewElement = mapper.toViewElement(item);
-            if (viewElement && data.attributeNewValue) {
-                viewElement.getFillerOffset = () => null;
-            }
-        });
-    };
-}
-/**
- * Creates an upcast converter for handling empty blocks.
- * The converter detects empty elements and marks them with the empty block attribute.
- */
-function createEmptyBlockUpcastConverter(schema) {
-    return (dispatcher) => {
-        dispatcher.on('element', (evt, data, conversionApi) => {
-            const { viewItem, modelRange } = data;
-            if (!viewItem.is('element') || !viewItem.isEmpty || viewItem.getCustomProperty('$hasBlockFiller')) {
-                return;
-            }
-            // Handle element itself.
-            const modelElement = modelRange && modelRange.start.nodeAfter;
-            if (!modelElement || !schema.checkAttribute(modelElement, EMPTY_BLOCK_MODEL_ATTRIBUTE)) {
-                return;
-            }
-            conversionApi.writer.setAttribute(EMPTY_BLOCK_MODEL_ATTRIBUTE, true, modelElement);
-            // Handle an auto-paragraphed bogus paragraph inside empty element.
-            if (modelElement.childCount != 1) {
-                return;
-            }
-            const firstModelChild = modelElement.getChild(0);
-            if (firstModelChild.is('element', 'paragraph') &&
-                schema.checkAttribute(firstModelChild, EMPTY_BLOCK_MODEL_ATTRIBUTE)) {
-                conversionApi.writer.setAttribute(EMPTY_BLOCK_MODEL_ATTRIBUTE, true, firstModelChild);
-            }
-        }, { priority: 'lowest' });
-    };
-}

package/src/fullpage.js

@@ -1,184 +0,0 @@
-/**
- * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
- * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
- */
-/**
- * @module html-support/fullpage
- */
-import { Plugin } from 'ckeditor5/src/core.js';
-import { logWarning, global } from 'ckeditor5/src/utils.js';
-import { ViewUpcastWriter } from 'ckeditor5/src/engine.js';
-import { HtmlPageDataProcessor } from './htmlpagedataprocessor.js';
-/**
- * The full page editing feature. It preserves the whole HTML page in the editor data.
- */
-export class FullPage extends Plugin {
-    /**
-     * @inheritDoc
-     */
-    static get pluginName() {
-        return 'FullPage';
-    }
-    /**
-     * @inheritDoc
-     * @internal
-     */
-    static get licenseFeatureCode() {
-        return 'FPH';
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isOfficialPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    static get isPremiumPlugin() {
-        return true;
-    }
-    /**
-     * @inheritDoc
-     */
-    constructor(editor) {
-        super(editor);
-        editor.config.define('htmlSupport.fullPage', {
-            allowRenderStylesFromHead: false,
-            sanitizeCss: rawCss => {
-                /**
-                 * When using the Full page with the `config.htmlSupport.fullPage.allowRenderStylesFromHead` set to `true`,
-                 * it is strongly recommended to define a sanitize function that will clean up the CSS
-                 * which is present in the `<head>` in editors content in order to avoid XSS vulnerability.
-                 *
-                 * For a detailed overview, check the {@glink features/html/full-page-html Full page HTML feature} documentation.
-                 *
-                 * @error css-full-page-provide-sanitize-function
-                 */
-                logWarning('css-full-page-provide-sanitize-function');
-                return {
-                    css: rawCss,
-                    hasChanged: false
-                };
-            }
-        });
-        editor.data.processor = new HtmlPageDataProcessor(editor.data.viewDocument);
-    }
-    /**
-     * @inheritDoc
-     */
-    init() {
-        const editor = this.editor;
-        const properties = ['$fullPageDocument', '$fullPageDocType', '$fullPageXmlDeclaration', '$fullPageHeadStyles'];
-        editor.model.schema.extend('$root', {
-            allowAttributes: properties
-        });
-        // Apply custom properties from view document fragment to the model root attributes.
-        editor.data.on('toModel', (evt, [viewElementOrFragment]) => {
-            const root = editor.model.document.getRoot();
-            editor.model.change(writer => {
-                for (const name of properties) {
-                    const value = viewElementOrFragment.getCustomProperty(name);
-                    if (value) {
-                        writer.setAttribute(name, value, root);
-                    }
-                }
-            });
-            if (isAllowedRenderStylesFromHead(editor)) {
-                this._renderStylesFromHead(root);
-            }
-        }, { priority: 'low' });
-        // Apply root attributes to the view document fragment.
-        editor.data.on('toView', (evt, [modelElementOrFragment]) => {
-            if (!modelElementOrFragment.is('rootElement')) {
-                return;
-            }
-            const root = modelElementOrFragment;
-            const viewFragment = evt.return;
-            if (!root.hasAttribute('$fullPageDocument')) {
-                return;
-            }
-            const writer = new ViewUpcastWriter(viewFragment.document);
-            for (const name of properties) {
-                const value = root.getAttribute(name);
-                if (value) {
-                    writer.setCustomProperty(name, value, viewFragment);
-                }
-            }
-        }, { priority: 'low' });
-        // Clear root attributes related to full page editing on editor content reset.
-        editor.data.on('set', () => {
-            const root = editor.model.document.getRoot();
-            editor.model.change(writer => {
-                for (const name of properties) {
-                    if (root.hasAttribute(name)) {
-                        writer.removeAttribute(name, root);
-                    }
-                }
-            });
-        }, { priority: 'high' });
-        // Make sure that document is returned even if there is no content in the page body.
-        editor.data.on('get', (evt, args) => {
-            if (!args[0]) {
-                args[0] = {};
-            }
-            args[0].trim = false;
-        }, { priority: 'high' });
-    }
-    /**
-     * @inheritDoc
-     */
-    destroy() {
-        super.destroy();
-        if (isAllowedRenderStylesFromHead(this.editor)) {
-            this._removeStyleElementsFromDom();
-        }
-    }
-    /**
-     * Checks if in the document exists any `<style>` elements injected by the plugin and removes them,
-     * so these could be re-rendered later.
-     * There is used `data-full-page-style-id` attribute to recognize styles injected by the feature.
-     */
-    _removeStyleElementsFromDom() {
-        const existingStyleElements = Array.from(global.document.querySelectorAll(`[data-full-page-style-id="${this.editor.id}"]`));
-        for (const style of existingStyleElements) {
-            style.remove();
-        }
-    }
-    /**
-     * Extracts `<style>` elements from the full page data and renders them in the main document `<head>`.
-     * CSS content is sanitized before rendering.
-     */
-    _renderStyleElementsInDom(root) {
-        const editor = this.editor;
-        // Get `<style>` elements list from the `<head>` from the full page data.
-        const styleElements = root.getAttribute('$fullPageHeadStyles');
-        if (!styleElements) {
-            return;
-        }
-        const sanitizeCss = editor.config.get('htmlSupport.fullPage.sanitizeCss');
-        // Add `data-full-page-style-id` attribute to the `<style>` element and render it in `<head>` in the main document.
-        for (const style of styleElements) {
-            style.setAttribute('data-full-page-style-id', editor.id);
-            // Sanitize the CSS content before rendering it in the editor.
-            const sanitizedCss = sanitizeCss(style.innerText);
-            if (sanitizedCss.hasChanged) {
-                style.innerText = sanitizedCss.css;
-            }
-            global.document.head.append(style);
-        }
-    }
-    /**
-     * Removes existing `<style>` elements injected by the plugin and renders new ones from the full page data.
-     */
-    _renderStylesFromHead(root) {
-        this._removeStyleElementsFromDom();
-        this._renderStyleElementsInDom(root);
-    }
-}
-/**
- * Normalize the Full page configuration option `allowRenderStylesFromHead`.
- */
-function isAllowedRenderStylesFromHead(editor) {
-    return editor.config.get('htmlSupport.fullPage.allowRenderStylesFromHead');
-}