ckeditor5 1.35.1 → 1.82.3

data/lib/ckeditor5/rails/assets/webcomponents/components/ui-part.mjs

@@ -0,0 +1,26 @@
+class CKEditorUIPartComponent extends HTMLElement {
+  /**
+   * Lifecycle callback when element is added to DOM
+   * Adds the toolbar to the editor UI
+   */
+  connectedCallback() {
+    execIfDOMReady(async () => {
+      const uiPart = this.getAttribute('name');
+      const editor = await this.#queryEditorElement().instancePromise.promise;
+
+      this.appendChild(editor.ui.view[uiPart].element);
+    });
+  }
+
+  /**
+   * Finds the parent editor component
+   *
+   * @private
+   * @returns {CKEditorComponent|null} Parent editor component or null if not found
+   */
+  #queryEditorElement() {
+    return this.closest('ckeditor-component') || document.body.querySelector('ckeditor-component');
+  }
+}
+
+customElements.define('ckeditor-ui-part-component', CKEditorUIPartComponent);

data/lib/ckeditor5/rails/assets/webcomponents/utils.mjs

@@ -0,0 +1,235 @@
+/**
+ * Executes callback when DOM is ready
+ *
+ * @param {() => void} callback - Function to execute when DOM is ready
+ */
+function execIfDOMReady(callback) {
+  switch (document.readyState) {
+    case 'loading':
+      document.addEventListener('DOMContentLoaded', callback, { once: true });
+      break;
+
+    case 'interactive':
+    case 'complete':
+      setTimeout(callback, 0);
+      break;
+
+    default:
+      console.warn('Unexpected document.readyState:', document.readyState);
+      setTimeout(callback, 0);
+  }
+}
+
+/**
+ * Dynamically imports modules based on configuration
+ *
+ * @param {Array<Object>} imports - Array of import configurations
+ * @param {Object} imports[].name - Name of inline plugin (for inline type)
+ * @param {Object} imports[].code - Source code of inline plugin (for inline type)
+ * @param {Object} imports[].import_name - Module path to import (for external type)
+ * @param {Object} imports[].import_as - Name to import as (for external type)
+ * @param {Object} imports[].window_name - Global window object name (for external type)
+ * @param {('inline'|'external')} imports[].type - Type of import
+ * @returns {Promise<Array<any>>} Array of loaded modules
+ * @throws {Error} When plugin loading fails
+ */
+function loadAsyncImports(imports = []) {
+  const loadExternalPlugin = async ({ url, import_name, import_as, window_name, stylesheets }) => {
+    if (stylesheets?.length) {
+      await loadAsyncCSS(stylesheets);
+    }
+
+    if (window_name) {
+      function isScriptPresent() {
+        return Object.prototype.hasOwnProperty.call(window, window_name);
+      }
+
+      if (url && !isScriptPresent()) {
+        await injectScript(url);
+      }
+
+      if (!isScriptPresent()) {
+        window.dispatchEvent(
+          new CustomEvent(`ckeditor:request-cjs-plugin:${window_name}`)
+        );
+      }
+
+      if (!isScriptPresent()) {
+        throw new Error(
+          `Plugin window['${window_name}'] not found in global scope. ` +
+          'Please ensure the plugin is loaded before CKEditor initialization.'
+        );
+      }
+
+      return window[window_name];
+    }
+
+    const module = await import(import_name);
+    const imported = module[import_as || 'default'];
+
+    if (!imported) {
+      throw new Error(
+        `Plugin "${import_as || 'default'}" not found in the ESM module ` +
+        `"${import_name}"! Available imports: ${Object.keys(module).join(', ')}! ` +
+        'Consider changing "import_as" value.'
+      );
+    }
+
+    return imported;
+  };
+
+  function uncompressImport(pkg) {
+    if (typeof pkg === 'string') {
+      return loadExternalPlugin({ import_name: 'ckeditor5', import_as: pkg });
+    }
+
+    return loadExternalPlugin(pkg);
+  }
+
+  return Promise.all(imports.map(uncompressImport));
+}
+
+/**
+ * Checks if stylesheet with given href already exists in document
+ *
+ * @param {string} href - Stylesheet URL to check
+ * @returns {boolean} True if stylesheet already exists
+ */
+function stylesheetExists(href) {
+  return Array
+    .from(document.styleSheets)
+    .some(sheet =>
+      sheet.href === href || sheet.href === new URL(href, window.location.href).href
+    );
+}
+
+/**
+ * Dynamically loads CSS files based on configuration
+ *
+ * @param {Array<string>} imports - Array of CSS file URLs to load
+ * @returns {Promise<Array<void>>} Array of promises for each CSS file load
+ * @throws {Error} When CSS file loading fails
+ */
+function loadAsyncCSS(stylesheets = []) {
+  const promises = stylesheets.map(href =>
+    new Promise((resolve, reject) => {
+      if (stylesheetExists(href)) {
+        resolve();
+        return;
+      }
+
+      const link = document.createElement('link');
+      link.rel = 'stylesheet';
+      link.href = href;
+
+      link.onerror = reject;
+      link.onload = () => resolve();
+
+      document.head.appendChild(link);
+    })
+  );
+
+  return Promise.all(promises);
+}
+
+const SCRIPT_LOAD_PROMISES = new Map();
+
+/**
+ * Dynamically loads script files based on configuration.
+ * Uses caching to avoid loading the same script multiple times.
+ *
+ * @param {string} url - URL of the script to load
+ */
+function injectScript(url) {
+  if (SCRIPT_LOAD_PROMISES.has(url)) {
+    return SCRIPT_LOAD_PROMISES.get(url);
+  }
+
+  const promise = new Promise((resolve, reject) => {
+    const script = document.createElement('script');
+    script.src = url;
+    script.onload = resolve;
+    script.onerror = reject;
+
+    document.head.appendChild(script);
+  });
+
+  SCRIPT_LOAD_PROMISES.set(url, promise);
+  return promise;
+}
+
+/**
+ * Checks if a key is safe to use in configuration objects to prevent prototype pollution
+ *
+ * @param {string} key - Key name to check
+ * @returns {boolean} True if key is safe to use
+ */
+function isSafeKey(key) {
+  return typeof key === 'string' &&
+          key !== '__proto__' &&
+          key !== 'constructor' &&
+          key !== 'prototype';
+}
+
+/**
+ * Resolves element references in configuration object.
+ * Looks for objects with { $element: "selector" } format and replaces them with actual DOM elements.
+ *
+ * @param {Object} obj - Configuration object to process
+ * @returns {Object} Processed configuration object with resolved element references
+ * @throws {Error} When element reference is invalid
+ */
+function resolveElementReferences(obj) {
+  if (!obj || typeof obj !== 'object') {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(item => resolveElementReferences(item));
+  }
+
+  const result = Object.create(null);
+
+  for (const key of Object.getOwnPropertyNames(obj)) {
+    if (!isSafeKey(key)) {
+      console.warn(`Suspicious key "${key}" detected in config, skipping`);
+      continue;
+    }
+
+    const value = obj[key];
+
+    if (value && typeof value === 'object') {
+      if (value.$element) {
+        const selector = value.$element;
+
+        if (typeof selector !== 'string') {
+          console.warn(`Invalid selector type for "${key}", expected string`);
+          continue;
+        }
+
+        const element = document.querySelector(selector);
+
+        if (!element) {
+          console.warn(`Element not found for selector: ${selector}`);
+        }
+
+        result[key] = element || null;
+      } else {
+        result[key] = resolveElementReferences(value);
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Generates a unique identifier string
+ *
+ * @returns {string} Random string that can be used as unique identifier
+ */
+function uid() {
+  return Math.random().toString(36).substring(2);
+}

data/lib/ckeditor5/rails/cdn/ckeditor_bundle.rb

@@ -43,7 +43,7 @@ module CKEditor5::Rails
       end
 
       def translations_js_url_imports
-        translations.map do |lang|
+        translations.filter_map do |lang|
           next if lang == :en
 
           url = create_cdn_url(import_name, version, "translations/#{lang}.js")
@@ -53,7 +53,7 @@ module CKEditor5::Rails
             import_name: "#{import_name}/translations/#{lang}.js",
             translation: true
           )
-        end.compact
+        end
       end
     end
   end

data/lib/ckeditor5/rails/cdn/concerns/bundle_builder.rb

@@ -4,11 +4,13 @@ module CKEditor5::Rails
   module Cdn::Concerns
     module BundleBuilder
       def create_preset_bundle(preset)
-        cdn = preset.cdn
-        version = preset.version
-        translations = preset.translations
-        ckbox = preset.ckbox
-        premium = preset.premium
+        preset => {
+          cdn:,
+          version:,
+          translations:,
+          ckbox:,
+          premium:
+        }
 
         bundle = build_base_cdn_bundle(cdn, version, translations)
         bundle << build_premium_cdn_bundle(cdn, version, translations) if premium

data/lib/ckeditor5/rails/cdn/helpers.rb

@@ -55,7 +55,7 @@ module CKEditor5::Rails
     #
     # @example Using preset builder object
     #   <% @preset = ckeditor5_preset do
-    #     version '43.3.1'
+    #     version '44.3.0'
     #     toolbar :bold, :italic
     #     plugins :Bold, :Italic
     #   end %>
@@ -169,7 +169,7 @@ module CKEditor5::Rails
       if language.present?
         new_preset.language(language)
       elsif !new_preset.language?
-        new_preset.language(I18n.locale.downcase)
+        new_preset.language(I18n.locale)
       end
 
       validate_required_preset_params!(new_preset, preset)

data/lib/ckeditor5/rails/context/helpers.rb

@@ -31,12 +31,7 @@ module CKEditor5::Rails::Context
 
       tags = []
       tags << ckeditor5_inline_plugins_tags(preset)
-      tags << tag.public_send(
-        :'ckeditor-context-component',
-        'data-turbo-temporary': true,
-        **context_props.to_attributes,
-        &block
-      )
+      tags << tag.public_send(:'ckeditor-context-component', **context_props.to_attributes, &block)
 
       safe_join(tags)
     end

data/lib/ckeditor5/rails/context/preset_builder.rb

@@ -12,7 +12,7 @@ module CKEditor5::Rails
     #
     # @example Basic preset definition
     #   preset = PresetBuilder.new do
-    #     version '43.3.1'
+    #     version '44.3.0'
     #     gpl
     #     type :classic
     #     toolbar :bold, :italic
@@ -35,7 +35,7 @@ module CKEditor5::Rails
       # @param block [Proc] Optional configuration block
       # @example Initialize with block
       #   PresetBuilder.new do
-      #     version '43.3.1'
+      #     version '44.3.0'
       #     toolbar :bold, :italic
       #   end
       def initialize(&block)

data/lib/ckeditor5/rails/editor/helpers/config_helpers.rb

@@ -44,7 +44,7 @@ module CKEditor5::Rails::Editor::Helpers
     #
     # @example Creating a custom preset in controller
     #   @preset = ckeditor5_preset do
-    #     version '43.3.1'
+    #     version '44.3.0'
     #     toolbar :sourceEditing, :|, :bold, :italic
     #     plugins :Essentials, :Paragraph, :Bold, :Italic
     #   end

data/lib/ckeditor5/rails/editor/helpers/editor_helpers.rb

@@ -74,7 +74,7 @@ module CKEditor5::Rails
 
       # Add some fallbacks
       config[:licenseKey] ||= context[:license_key] || preset.license_key
-      config[:language] = { ui: language.downcase } if language
+      config[:language] = { ui: language } if language
 
       editor_props = Editor::Props.new(
         type, config,
@@ -85,7 +85,7 @@ module CKEditor5::Rails
 
       tag_attributes = html_attributes.merge(editor_props.to_attributes)
 
-      tag.public_send(:'ckeditor-component', 'data-turbo-temporary': true, **tag_attributes, &block)
+      tag.public_send(:'ckeditor-component', **tag_attributes, &block)
     end
 
     # Creates an editable area for multiroot or decoupled editors.
@@ -96,12 +96,7 @@ module CKEditor5::Rails
     # @example Creating a named editable area in multiroot editor
     #   <%= ckeditor5_editable 'content', style: 'border: 1px solid gray' %>
     def ckeditor5_editable(name = nil, **kwargs, &block)
-      tag.public_send(
-        :'ckeditor-editable-component',
-        'data-turbo-temporary': true,
-        name: name,
-        **kwargs, &block
-      )
+      tag.public_send(:'ckeditor-editable-component', name: name, **kwargs, &block)
     end
 
     # Creates a UI part component for the editor (toolbar, menubar).
@@ -112,12 +107,7 @@ module CKEditor5::Rails
     # @example Creating a toolbar component
     #   <%= ckeditor5_ui_part 'toolbar' %>
     def ckeditor5_ui_part(name, **kwargs, &block)
-      tag.public_send(
-        :'ckeditor-ui-part-component',
-        'data-turbo-temporary': true,
-        name: name,
-        **kwargs, &block
-      )
+      tag.public_send(:'ckeditor-ui-part-component', name: name, **kwargs, &block)
     end
 
     # Creates a toolbar component for decoupled editor.

data/lib/ckeditor5/rails/editor/props.rb

@@ -30,14 +30,9 @@ module CKEditor5::Rails::Editor
 
     def to_attributes
       {
-        bundle: bundle&.to_json,
-        plugins: serialize_plugins,
-        config: serialize_config,
-        watchdog: watchdog,
-        type: EDITOR_TYPES[@type]
+        type: EDITOR_TYPES[@type],
+        **serialized_attributes
       }
-        .merge(editable_height ? { 'editable-height': editable_height } : {})
-        .transform_keys(&:to_sym)
     end
 
     def self.valid_editor_type?(type)
@@ -48,6 +43,16 @@ module CKEditor5::Rails::Editor
 
     attr_reader :bundle, :watchdog, :type, :config, :editable_height
 
+    def serialized_attributes
+      {
+        bundle: bundle.to_json,
+        plugins: serialize_plugins,
+        config: serialize_config,
+        watchdog: watchdog
+      }
+        .merge(editable_height ? { 'editable-height' => editable_height } : {})
+    end
+
     def serialize_plugins
       (config[:plugins] || []).map { |plugin| PropsBasePlugin.normalize(plugin).to_h }.to_json
     end

data/lib/ckeditor5/rails/editor/props_inline_plugin.rb

@@ -4,20 +4,17 @@ require_relative 'props_base_plugin'
 
 module CKEditor5::Rails::Editor
   class PropsInlinePlugin < PropsBasePlugin
-    attr_reader :code, :compress
+    attr_reader :code
 
-    def initialize(name, code, compress: true)
+    def initialize(name, code)
       super(name)
 
       raise ArgumentError, 'Code must be a String' unless code.is_a?(String)
 
       @code = "(async () => { #{code} })()"
-      @compress = compress
     end
 
-    def try_compress!
-      return unless @compress
-
+    def compress!
       @code = Terser.new(compress: false, mangle: true).compile(@code)
     end
 

data/lib/ckeditor5/rails/editor/props_patch_plugin.rb

@@ -7,11 +7,13 @@ module CKEditor5::Rails::Editor
   class PropsPatchPlugin < PropsInlinePlugin
     attr_reader :min_version, :max_version
 
-    def initialize(name, code, min_version: nil, max_version: nil, compress: true)
-      super(name, code, compress: compress)
+    def initialize(name, code, min_version: nil, max_version: nil)
+      super(name, code)
 
       @min_version = min_version && CKEditor5::Rails::Semver.new(min_version)
       @max_version = max_version && CKEditor5::Rails::Semver.new(max_version)
+
+      compress!
     end
 
     def self.applicable_for_version?(editor_version, min_version: nil, max_version: nil)

data/lib/ckeditor5/rails/engine.rb

@@ -3,7 +3,10 @@
 require 'rails/engine'
 
 require_relative 'presets/manager'
-require_relative 'plugins'
+require_relative 'plugins/simple_upload_adapter'
+require_relative 'plugins/wproofreader'
+require_relative 'plugins/special_characters_bootstrap'
+require_relative 'plugins/custom_translations_loader'
 
 module CKEditor5::Rails
   class PresetNotFoundError < ArgumentError; end
@@ -54,10 +57,7 @@ module CKEditor5::Rails
 
       def configure(&block)
         proxy = ConfigurationProxy.new(config.ckeditor5)
-
-        config.after_initialize do
-          proxy.instance_eval(&block)
-        end
+        proxy.instance_eval(&block)
       end
 
       def find_preset(preset)
@@ -81,8 +81,7 @@ module CKEditor5::Rails
                :type, :menubar, :plugins, :plugin, :inline_plugin,
                :toolbar, :block_toolbar, :balloon_toolbar,
                :language, :ckbox, :configure, :automatic_upgrades, :simple_upload_adapter,
-               :editable_height, :wproofreader, :custom_translations, :apply_integration_patches,
-               :compression, :compression?, to: :default_preset
+               :editable_height, :wproofreader, :custom_translations, to: :default_preset
 
       def initialize(configuration)
         @configuration = configuration

data/lib/ckeditor5/rails/plugins/custom_translations_loader.rb

@@ -4,8 +4,8 @@ require_relative '../editor/props_inline_plugin'
 
 module CKEditor5::Rails::Plugins
   class CustomTranslationsLoader < CKEditor5::Rails::Editor::PropsInlinePlugin
-    def initialize(translations, **kwargs) # rubocop:disable Metrics/MethodLength
-      code = <<~JS
+    def initialize(translations) # rubocop:disable Metrics/MethodLength
+      code = <<~JS.freeze
         const { Plugin } = await import('ckeditor5');
 
         function resolveTranslationReferences(uiLanguage, config, visited = new WeakSet()) {
@@ -90,7 +90,8 @@ module CKEditor5::Rails::Plugins
         }
       JS
 
-      super(:CustomTranslationsLoader, code, **kwargs)
+      super(:CustomTranslationsLoader, code)
+      compress!
     end
   end
 end

data/lib/ckeditor5/rails/plugins/simple_upload_adapter.rb

@@ -82,8 +82,9 @@ module CKEditor5::Rails::Plugins
       }
     JS
 
-    def initialize(**kwargs)
-      super(:SimpleUploadAdapter, PLUGIN_CODE, **kwargs)
+    def initialize
+      super(:SimpleUploadAdapter, PLUGIN_CODE)
+      compress!
     end
   end
 end

data/lib/ckeditor5/rails/plugins/special_characters_bootstrap.rb

@@ -50,8 +50,9 @@ module CKEditor5::Rails::Plugins
       }
     JS
 
-    def initialize(**kwargs)
-      super(:SpecialCharactersBootstrap, PLUGIN_CODE, **kwargs)
+    def initialize
+      super(:SpecialCharactersBootstrap, PLUGIN_CODE)
+      compress!
     end
   end
 end

data/lib/ckeditor5/rails/plugins/wproofreader.rb

@@ -67,8 +67,9 @@ module CKEditor5::Rails::Plugins
       }
     JS
 
-    def initialize(**kwargs)
-      super(:WProofreaderSync, PLUGIN_CODE, **kwargs)
+    def initialize
+      super(:WProofreaderSync, PLUGIN_CODE)
+      compress!
     end
   end
 end

data/lib/ckeditor5/rails/presets/concerns/plugin_methods.rb

@@ -12,30 +12,11 @@ module CKEditor5::Rails
         class MissingInlinePluginError < StandardError; end
         class UnsupportedESModuleError < StandardError; end
         class InvalidPatchPluginError < ArgumentError; end
-        class CompressionDisabledError < StandardError; end
 
         included do
           attr_reader :disallow_inline_plugin_compression
         end
 
-        # Sets compression of inline plugin code. Make sure that it is called before setting the version
-        # or adding plugins.
-        # @example Disable compression
-        #   compression(enabled: false)
-        # @return [void]
-        # @note This method is useful for debugging purposes, as it allows you to see the uncompressed code.
-        def compression(enabled: false)
-          @disallow_inline_plugin_compression = !enabled
-        end
-
-        # Check if compression is enabled
-        # @return [Boolean] True if compression is enabled, false otherwise
-        # @example Check if compression is enabled
-        #  compression? # => true
-        def compression?
-          !@disallow_inline_plugin_compression
-        end
-
         # Registers an external plugin loaded from a URL
         #
         # @param name [Symbol] Plugin name
@@ -54,7 +35,6 @@ module CKEditor5::Rails
         #
         # @param name [Symbol] Plugin name
         # @param code [String] JavaScript code defining the plugin
-        # @param compress [Boolean] Whether to compress the code (default: true)
         # @example Define custom highlight plugin
         #   inline_plugin :MyCustomPlugin, <<~JS
         #     const { Plugin } = await import( 'ckeditor5' );
@@ -69,7 +49,7 @@ module CKEditor5::Rails
         #       }
         #     }
         #   JS
-        def inline_plugin(name, code, compress: !@disallow_inline_plugin_compression)
+        def inline_plugin(name, code)
           if code.match?(/export default/)
             raise UnsupportedESModuleError,
                   'Inline plugins must not use ES module syntax!' \
@@ -81,7 +61,8 @@ module CKEditor5::Rails
                   'Plugin code must return a class that extends Plugin!'
           end
 
-          plugin = Editor::PropsInlinePlugin.new(name, code, compress: compress)
+          plugin = Editor::PropsInlinePlugin.new(name, code)
+          plugin.compress! unless disallow_inline_plugin_compression
 
           register_plugin(plugin)
         end
@@ -140,23 +121,6 @@ module CKEditor5::Rails
           builder
         end
 
-        # Compresses inline plugins to reduce bundle size
-        #
-        # @raise [CompressionDisabledError] If inline plugin compression is disabled
-        # @example Compress inline plugins
-        #   try_compress_inline_plugins!
-        # @return [void]
-        # @note This method is called automatically when defining a preset
-        def try_compress_inline_plugins!
-          raise CompressionDisabledError if @disallow_inline_plugin_compression
-
-          config[:plugins].each do |plugin|
-            next unless plugin.is_a?(Editor::PropsInlinePlugin)
-
-            plugin.try_compress!
-          end
-        end
-
         private
 
         # Register a plugin in the editor configuration.