ckeditor5-livewire 0.0.1

package/src/hooks/editor/utils/create-editor-in-context.ts

@@ -0,0 +1,90 @@
+import type { Context, ContextWatchdog, Editor, EditorConfig } from 'ckeditor5';
+
+import type { EditorCreator } from './wrap-with-watchdog';
+
+import { uid } from '../../../shared';
+
+/**
+ * Symbol used to store the context watchdog on the editor instance.
+ * Internal use only.
+ */
+const CONTEXT_EDITOR_WATCHDOG_SYMBOL = Symbol.for('context-editor-watchdog');
+
+/**
+ * Creates a CKEditor 5 editor instance within a given context watchdog.
+ *
+ * @param params Parameters for editor creation.
+ * @param params.element The DOM element or data for the editor.
+ * @param params.context The context watchdog instance.
+ * @param params.creator The editor creator utility.
+ * @param params.config The editor configuration object.
+ * @returns The created editor instance.
+ */
+export async function createEditorInContext({ element, context, creator, config }: Attrs) {
+  const editorContextId = uid();
+
+  await context.add({
+    creator: (_element, _config) => creator.create(_element, _config),
+    id: editorContextId,
+    sourceElementOrData: element,
+    type: 'editor',
+    config,
+  });
+
+  const editor = context.getItem(editorContextId) as Editor;
+  const contextDescriptor: EditorContextDescriptor = {
+    state: 'available',
+    editorContextId,
+    context,
+  };
+
+  (editor as any)[CONTEXT_EDITOR_WATCHDOG_SYMBOL] = contextDescriptor;
+
+  // Destroying of context is async. There can be situation when the destroy of the context
+  // and the destroy of the editor is called in parallel. It often happens during unmounting of
+  // phoenix hooks. Let's make sure that descriptor informs other components, that context is being
+  // destroyed.
+  const originalDestroy = context.destroy.bind(context);
+  context.destroy = async () => {
+    contextDescriptor.state = 'unavailable';
+    return originalDestroy();
+  };
+
+  return {
+    ...contextDescriptor,
+    editor,
+  };
+}
+
+/**
+ * Retrieves the context watchdog from an editor instance, if available.
+ *
+ * @param editor The editor instance.
+ * @returns The context watchdog or null if not found.
+ */
+export function unwrapEditorContext(editor: Editor): EditorContextDescriptor | null {
+  if (CONTEXT_EDITOR_WATCHDOG_SYMBOL in editor) {
+    return (editor as any)[CONTEXT_EDITOR_WATCHDOG_SYMBOL];
+  }
+
+  return null;
+}
+
+/**
+ * Parameters for creating an editor in a context.
+ */
+type Attrs = {
+  context: ContextWatchdog<Context>;
+  creator: EditorCreator;
+  element: HTMLElement;
+  config: EditorConfig;
+};
+
+/**
+ * Descriptor for an editor context.
+ */
+type EditorContextDescriptor = {
+  state: 'available' | 'unavailable';
+  editorContextId: string;
+  context: ContextWatchdog<Context>;
+};

package/src/hooks/editor/utils/get-editor-roots-values.ts

@@ -0,0 +1,16 @@
+import type { Editor } from 'ckeditor5';
+
+/**
+ * Gets the values of the editor's roots.
+ *
+ * @param editor The CKEditor instance.
+ * @returns An object mapping root names to their content.
+ */
+export function getEditorRootsValues(editor: Editor) {
+  const roots = editor.model.document.getRootNames();
+
+  return roots.reduce<Record<string, string>>((acc, rootName) => {
+    acc[rootName] = editor.getData({ rootName });
+    return acc;
+  }, Object.create({}));
+}

package/src/hooks/editor/utils/index.ts

@@ -0,0 +1,11 @@
+export * from './create-editor-in-context';
+export * from './get-editor-roots-values';
+export * from './is-single-editing-like-editor';
+export * from './load-editor-constructor';
+export * from './load-editor-plugins';
+export * from './load-editor-translations';
+export * from './normalize-custom-translations';
+export * from './query-editor-editables';
+export * from './resolve-editor-config-elements-references';
+export * from './set-editor-editable-height';
+export * from './wrap-with-watchdog';

package/src/hooks/editor/utils/is-single-editing-like-editor.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+
+import type { EditorType } from '../typings';
+
+import { isSingleEditingLikeEditor } from './is-single-editing-like-editor';
+
+describe('isSingleEditingLikeEditor', () => {
+  it('should return true for inline editor', () => {
+    expect(isSingleEditingLikeEditor('inline')).toBe(true);
+  });
+
+  it('should return true for classic editor', () => {
+    expect(isSingleEditingLikeEditor('classic')).toBe(true);
+  });
+
+  it('should return true for balloon editor', () => {
+    expect(isSingleEditingLikeEditor('balloon')).toBe(true);
+  });
+
+  it('should return false for decoupled editor', () => {
+    expect(isSingleEditingLikeEditor('decoupled')).toBe(true);
+  });
+
+  it('should return false for multiroot editor', () => {
+    expect(isSingleEditingLikeEditor('multiroot')).toBe(false);
+  });
+
+  it('should handle all valid editor types', () => {
+    const singleEditingTypes: EditorType[] = ['inline', 'classic', 'balloon', 'decoupled'];
+    const multiEditingTypes: EditorType[] = ['multiroot'];
+
+    singleEditingTypes.forEach((type) => {
+      expect(isSingleEditingLikeEditor(type)).toBe(true);
+    });
+
+    multiEditingTypes.forEach((type) => {
+      expect(isSingleEditingLikeEditor(type)).toBe(false);
+    });
+  });
+});

package/src/hooks/editor/utils/is-single-editing-like-editor.ts

@@ -0,0 +1,11 @@
+import type { EditorType } from '../typings';
+
+/**
+ * Checks if the given editor type is one of the single editing-like editors.
+ *
+ * @param editorType - The type of the editor to check.
+ * @returns `true` if the editor type is 'inline', 'classic', or 'balloon', otherwise `false`.
+ */
+export function isSingleEditingLikeEditor(editorType: EditorType): boolean {
+  return ['inline', 'classic', 'balloon', 'decoupled'].includes(editorType);
+}

package/src/hooks/editor/utils/load-editor-constructor.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import type { EditorType } from '../typings';
+
+import { loadEditorConstructor } from './load-editor-constructor';
+
+// Mock the ckeditor5 package
+vi.mock('ckeditor5', async () => {
+  const mockEditorConstructor = vi.fn();
+
+  return {
+    InlineEditor: mockEditorConstructor,
+    BalloonEditor: mockEditorConstructor,
+    ClassicEditor: mockEditorConstructor,
+    DecoupledEditor: mockEditorConstructor,
+    MultiRootEditor: mockEditorConstructor,
+  };
+});
+
+describe('loadEditorConstructor', () => {
+  it('should load InlineEditor for inline type', async () => {
+    const constructor = await loadEditorConstructor('inline');
+    expect(constructor).toBeDefined();
+  });
+
+  it('should load BalloonEditor for balloon type', async () => {
+    const constructor = await loadEditorConstructor('balloon');
+    expect(constructor).toBeDefined();
+  });
+
+  it('should load ClassicEditor for classic type', async () => {
+    const constructor = await loadEditorConstructor('classic');
+    expect(constructor).toBeDefined();
+  });
+
+  it('should load DecoupledEditor for decoupled type', async () => {
+    const constructor = await loadEditorConstructor('decoupled');
+    expect(constructor).toBeDefined();
+  });
+
+  it('should load MultiRootEditor for multiroot type', async () => {
+    const constructor = await loadEditorConstructor('multiroot');
+    expect(constructor).toBeDefined();
+  });
+
+  it('should throw error for unsupported editor type', async () => {
+    const invalidType = 'invalid' as EditorType;
+
+    await expect(loadEditorConstructor(invalidType)).rejects.toThrow(
+      'Unsupported editor type: invalid',
+    );
+  });
+
+  it('should return the correct constructor for each editor type', async () => {
+    const editorTypes: EditorType[] = ['inline', 'balloon', 'classic', 'decoupled', 'multiroot'];
+
+    for (const type of editorTypes) {
+      const constructor = await loadEditorConstructor(type);
+      expect(constructor).toBeDefined();
+    }
+  });
+});

package/src/hooks/editor/utils/load-editor-constructor.ts

@@ -0,0 +1,27 @@
+import type { EditorType } from '../typings';
+
+/**
+ * Returns the constructor for the specified CKEditor5 editor type.
+ *
+ * @param type - The type of the editor to load.
+ * @returns A promise that resolves to the editor constructor.
+ */
+export async function loadEditorConstructor(type: EditorType) {
+  const PKG = await import('ckeditor5');
+
+  const editorMap = {
+    inline: PKG.InlineEditor,
+    balloon: PKG.BalloonEditor,
+    classic: PKG.ClassicEditor,
+    decoupled: PKG.DecoupledEditor,
+    multiroot: PKG.MultiRootEditor,
+  } as const;
+
+  const EditorConstructor = editorMap[type];
+
+  if (!EditorConstructor) {
+    throw new Error(`Unsupported editor type: ${type}`);
+  }
+
+  return EditorConstructor;
+}

package/src/hooks/editor/utils/load-editor-plugins.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, describe, expect, it } from 'vitest';
+
+import type { EditorPlugin } from '../typings';
+
+import { CustomEditorPluginsRegistry } from '../custom-editor-plugins';
+import { loadEditorPlugins } from './load-editor-plugins';
+
+class CustomPlugin {
+  static get pluginName() {
+    return 'CustomPlugin';
+  }
+}
+
+describe('loadEditorPlugins', () => {
+  it('should load plugins from base package', async () => {
+    const plugins: EditorPlugin[] = ['Bold', 'Italic'];
+    const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+    expect(loadedPlugins).toHaveLength(2);
+    expect(loadedPlugins[0]).toBeDefined();
+    expect(loadedPlugins[1]).toBeDefined();
+  });
+
+  it('should load plugins from premium package', async () => {
+    const plugins: EditorPlugin[] = ['ExportInlineStyles', 'Comments'];
+    const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+    expect(loadedPlugins).toHaveLength(2);
+    expect(loadedPlugins[0]).toBeDefined();
+    expect(loadedPlugins[1]).toBeDefined();
+  });
+
+  it('should handle empty plugin array', async () => {
+    const plugins: EditorPlugin[] = [];
+    const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+    expect(loadedPlugins).toHaveLength(0);
+  });
+
+  it('should prioritize base package over premium package', async () => {
+    const plugins: EditorPlugin[] = ['Bold'];
+    const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+    expect(loadedPlugins).toHaveLength(1);
+    expect(loadedPlugins[0]).toBeDefined();
+  });
+
+  it('should return plugin constructors', async () => {
+    const plugins: EditorPlugin[] = ['Bold'];
+    const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+    expect(loadedPlugins).toHaveLength(1);
+    expect(typeof loadedPlugins[0]).toBe('function');
+  });
+
+  it('should throw an error for unknown plugins', async () => {
+    const plugins: EditorPlugin[] = ['UnknownPlugin'];
+    await expect(loadEditorPlugins(plugins)).rejects.toThrowError(/not found/);
+  });
+
+  describe('custom plugins', () => {
+    afterEach(() => {
+      CustomEditorPluginsRegistry.the.unregisterAll();
+    });
+
+    it('should load custom plugins', async () => {
+      CustomEditorPluginsRegistry.the.register('CustomPlugin', () => CustomPlugin);
+
+      const plugins: EditorPlugin[] = ['CustomPlugin'];
+      const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+      expect(loadedPlugins).toHaveLength(1);
+      expect(loadedPlugins[0]).toEqual(CustomPlugin);
+    });
+
+    it('should prefer loading custom plugins over base package', async () => {
+      CustomEditorPluginsRegistry.the.register('Bold', () => CustomPlugin);
+
+      const plugins: EditorPlugin[] = ['Bold'];
+      const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+      expect(loadedPlugins).toHaveLength(1);
+      expect(loadedPlugins[0]).toEqual(CustomPlugin);
+    });
+
+    it('should be possible to load async custom plugins', async () => {
+      CustomEditorPluginsRegistry.the.register('AsyncPlugin', async () => {
+        return new Promise((resolve) => {
+          setTimeout(() => resolve(CustomPlugin), 20);
+        });
+      });
+
+      const plugins: EditorPlugin[] = ['AsyncPlugin'];
+      const { loadedPlugins } = await loadEditorPlugins(plugins);
+
+      expect(loadedPlugins).toHaveLength(1);
+      expect(loadedPlugins[0]).toEqual(CustomPlugin);
+    });
+  });
+});

package/src/hooks/editor/utils/load-editor-plugins.ts

@@ -0,0 +1,71 @@
+import type { PluginConstructor } from 'ckeditor5';
+
+import type { EditorPlugin } from '../typings';
+
+import { CustomEditorPluginsRegistry } from '../custom-editor-plugins';
+
+/**
+ * Loads CKEditor plugins from base and premium packages.
+ * First tries to load from the base 'ckeditor5' package, then falls back to 'ckeditor5-premium-features'.
+ *
+ * @param plugins - Array of plugin names to load
+ * @returns Promise that resolves to an array of loaded Plugin instances
+ * @throws Error if a plugin is not found in either package
+ */
+export async function loadEditorPlugins(plugins: EditorPlugin[]): Promise<LoadedPlugins> {
+  const basePackage = await import('ckeditor5');
+  let premiumPackage: Record<string, any> | null = null;
+
+  const loaders = plugins.map(async (plugin) => {
+    // Let's first try to load the plugin from the base package.
+    // Coverage is disabled due to Vitest issues with mocking dynamic imports.
+
+    // If the plugin is not found in the base package, try custom plugins.
+    const customPlugin = await CustomEditorPluginsRegistry.the.get(plugin);
+
+    if (customPlugin) {
+      return customPlugin;
+    }
+
+    // If not found, try to load from the base package.
+    const { [plugin]: basePkgImport } = basePackage as Record<string, unknown>;
+
+    if (basePkgImport) {
+      return basePkgImport as PluginConstructor;
+    }
+
+    // Plugin not found in base package, try premium package.
+    if (!premiumPackage) {
+      try {
+        premiumPackage = await import('ckeditor5-premium-features');
+        /* v8 ignore next 6 */
+      }
+      catch (error) {
+        console.error(`Failed to load premium package: ${error}`);
+      }
+    }
+
+    /* v8 ignore next */
+    const { [plugin]: premiumPkgImport } = premiumPackage || {};
+
+    if (premiumPkgImport) {
+      return premiumPkgImport as PluginConstructor;
+    }
+
+    // Plugin not found in either package, throw an error.
+    throw new Error(`Plugin "${plugin}" not found in base or premium packages.`);
+  });
+
+  return {
+    loadedPlugins: await Promise.all(loaders),
+    hasPremium: !!premiumPackage,
+  };
+}
+
+/**
+ * Type representing the loaded plugins and whether premium features are available.
+ */
+type LoadedPlugins = {
+  loadedPlugins: PluginConstructor<any>[];
+  hasPremium: boolean;
+};

package/src/hooks/editor/utils/load-editor-translations.ts

@@ -0,0 +1,233 @@
+/**
+ * Loads all required translations for the editor based on the language configuration.
+ *
+ * @param language - The language configuration object containing UI and content language codes.
+ * @param language.ui - The UI language code.
+ * @param language.content - The content language code.
+ * @param hasPremium - Whether premium features are enabled and premium translations should be loaded.
+ * @returns A promise that resolves to an array of loaded translation objects.
+ */
+export async function loadAllEditorTranslations(
+  language: { ui: string; content: string; },
+  hasPremium: boolean,
+) {
+  const translations = [language.ui, language.content];
+  const loadedTranslations = await Promise.all(
+    [
+      loadEditorPkgTranslations('ckeditor5', translations),
+      /* v8 ignore next */
+      hasPremium && loadEditorPkgTranslations('ckeditor5-premium-features', translations),
+    ].filter(pkg => !!pkg),
+  )
+    .then(translations => translations.flat());
+
+  return loadedTranslations;
+}
+
+/**
+ * Loads the editor translations for the given languages.
+ *
+ * Make sure this function is properly compiled and bundled in self hosted environments!
+ *
+ * @param pkg - The package to load translations from ('ckeditor5' or 'ckeditor5-premium-features').
+ * @param translations - The list of language codes to load translations for.
+ * @returns A promise that resolves to an array of loaded translation packs.
+ */
+async function loadEditorPkgTranslations(
+  pkg: EditorPkgName,
+  translations: string[],
+) {
+  /* v8 ignore next */
+  return await Promise.all(
+    translations
+      .filter(lang => lang !== 'en') // 'en' is the default language, no need to load it.
+      .map(async (lang) => {
+        const pack = await loadEditorTranslation(pkg, lang);
+
+        /* v8 ignore next */
+        return pack?.default ?? pack;
+      })
+      .filter(Boolean),
+  );
+}
+
+/**
+ * Type representing the package name for CKEditor 5.
+ */
+type EditorPkgName = 'ckeditor5' | 'ckeditor5-premium-features';
+
+/**
+ * Load translation for CKEditor 5
+ * @param pkg - Package type: 'ckeditor5' or 'premium'
+ * @param lang - Language code (e.g., 'pl', 'en', 'de')
+ * @returns Translation object or null if failed
+ */
+async function loadEditorTranslation(pkg: EditorPkgName, lang: string): Promise<any> {
+  try {
+    /* v8 ignore next 2 */
+    if (pkg === 'ckeditor5') {
+      /* v8 ignore next 79 */
+      switch (lang) {
+        case 'af': return await import('ckeditor5/translations/af.js');
+        case 'ar': return await import('ckeditor5/translations/ar.js');
+        case 'ast': return await import('ckeditor5/translations/ast.js');
+        case 'az': return await import('ckeditor5/translations/az.js');
+        case 'bg': return await import('ckeditor5/translations/bg.js');
+        case 'bn': return await import('ckeditor5/translations/bn.js');
+        case 'bs': return await import('ckeditor5/translations/bs.js');
+        case 'ca': return await import('ckeditor5/translations/ca.js');
+        case 'cs': return await import('ckeditor5/translations/cs.js');
+        case 'da': return await import('ckeditor5/translations/da.js');
+        case 'de': return await import('ckeditor5/translations/de.js');
+        case 'de-ch': return await import('ckeditor5/translations/de-ch.js');
+        case 'el': return await import('ckeditor5/translations/el.js');
+        case 'en': return await import('ckeditor5/translations/en.js');
+        case 'en-au': return await import('ckeditor5/translations/en-au.js');
+        case 'en-gb': return await import('ckeditor5/translations/en-gb.js');
+        case 'eo': return await import('ckeditor5/translations/eo.js');
+        case 'es': return await import('ckeditor5/translations/es.js');
+        case 'es-co': return await import('ckeditor5/translations/es-co.js');
+        case 'et': return await import('ckeditor5/translations/et.js');
+        case 'eu': return await import('ckeditor5/translations/eu.js');
+        case 'fa': return await import('ckeditor5/translations/fa.js');
+        case 'fi': return await import('ckeditor5/translations/fi.js');
+        case 'fr': return await import('ckeditor5/translations/fr.js');
+        case 'gl': return await import('ckeditor5/translations/gl.js');
+        case 'gu': return await import('ckeditor5/translations/gu.js');
+        case 'he': return await import('ckeditor5/translations/he.js');
+        case 'hi': return await import('ckeditor5/translations/hi.js');
+        case 'hr': return await import('ckeditor5/translations/hr.js');
+        case 'hu': return await import('ckeditor5/translations/hu.js');
+        case 'hy': return await import('ckeditor5/translations/hy.js');
+        case 'id': return await import('ckeditor5/translations/id.js');
+        case 'it': return await import('ckeditor5/translations/it.js');
+        case 'ja': return await import('ckeditor5/translations/ja.js');
+        case 'jv': return await import('ckeditor5/translations/jv.js');
+        case 'kk': return await import('ckeditor5/translations/kk.js');
+        case 'km': return await import('ckeditor5/translations/km.js');
+        case 'kn': return await import('ckeditor5/translations/kn.js');
+        case 'ko': return await import('ckeditor5/translations/ko.js');
+        case 'ku': return await import('ckeditor5/translations/ku.js');
+        case 'lt': return await import('ckeditor5/translations/lt.js');
+        case 'lv': return await import('ckeditor5/translations/lv.js');
+        case 'ms': return await import('ckeditor5/translations/ms.js');
+        case 'nb': return await import('ckeditor5/translations/nb.js');
+        case 'ne': return await import('ckeditor5/translations/ne.js');
+        case 'nl': return await import('ckeditor5/translations/nl.js');
+        case 'no': return await import('ckeditor5/translations/no.js');
+        case 'oc': return await import('ckeditor5/translations/oc.js');
+        case 'pl': return await import('ckeditor5/translations/pl.js');
+        case 'pt': return await import('ckeditor5/translations/pt.js');
+        case 'pt-br': return await import('ckeditor5/translations/pt-br.js');
+        case 'ro': return await import('ckeditor5/translations/ro.js');
+        case 'ru': return await import('ckeditor5/translations/ru.js');
+        case 'si': return await import('ckeditor5/translations/si.js');
+        case 'sk': return await import('ckeditor5/translations/sk.js');
+        case 'sl': return await import('ckeditor5/translations/sl.js');
+        case 'sq': return await import('ckeditor5/translations/sq.js');
+        case 'sr': return await import('ckeditor5/translations/sr.js');
+        case 'sr-latn': return await import('ckeditor5/translations/sr-latn.js');
+        case 'sv': return await import('ckeditor5/translations/sv.js');
+        case 'th': return await import('ckeditor5/translations/th.js');
+        case 'tk': return await import('ckeditor5/translations/tk.js');
+        case 'tr': return await import('ckeditor5/translations/tr.js');
+        case 'tt': return await import('ckeditor5/translations/tt.js');
+        case 'ug': return await import('ckeditor5/translations/ug.js');
+        case 'uk': return await import('ckeditor5/translations/uk.js');
+        case 'ur': return await import('ckeditor5/translations/ur.js');
+        case 'uz': return await import('ckeditor5/translations/uz.js');
+        case 'vi': return await import('ckeditor5/translations/vi.js');
+        case 'zh': return await import('ckeditor5/translations/zh.js');
+        case 'zh-cn': return await import('ckeditor5/translations/zh-cn.js');
+        default:
+          console.warn(`Language ${lang} not found in ckeditor5 translations`);
+          return null;
+      }
+    }
+    /* v8 ignore next 79 */
+    else {
+      // Premium features translations
+      switch (lang) {
+        case 'af': return await import('ckeditor5-premium-features/translations/af.js');
+        case 'ar': return await import('ckeditor5-premium-features/translations/ar.js');
+        case 'ast': return await import('ckeditor5-premium-features/translations/ast.js');
+        case 'az': return await import('ckeditor5-premium-features/translations/az.js');
+        case 'bg': return await import('ckeditor5-premium-features/translations/bg.js');
+        case 'bn': return await import('ckeditor5-premium-features/translations/bn.js');
+        case 'bs': return await import('ckeditor5-premium-features/translations/bs.js');
+        case 'ca': return await import('ckeditor5-premium-features/translations/ca.js');
+        case 'cs': return await import('ckeditor5-premium-features/translations/cs.js');
+        case 'da': return await import('ckeditor5-premium-features/translations/da.js');
+        case 'de': return await import('ckeditor5-premium-features/translations/de.js');
+        case 'de-ch': return await import('ckeditor5-premium-features/translations/de-ch.js');
+        case 'el': return await import('ckeditor5-premium-features/translations/el.js');
+        case 'en': return await import('ckeditor5-premium-features/translations/en.js');
+        case 'en-au': return await import('ckeditor5-premium-features/translations/en-au.js');
+        case 'en-gb': return await import('ckeditor5-premium-features/translations/en-gb.js');
+        case 'eo': return await import('ckeditor5-premium-features/translations/eo.js');
+        case 'es': return await import('ckeditor5-premium-features/translations/es.js');
+        case 'es-co': return await import('ckeditor5-premium-features/translations/es-co.js');
+        case 'et': return await import('ckeditor5-premium-features/translations/et.js');
+        case 'eu': return await import('ckeditor5-premium-features/translations/eu.js');
+        case 'fa': return await import('ckeditor5-premium-features/translations/fa.js');
+        case 'fi': return await import('ckeditor5-premium-features/translations/fi.js');
+        case 'fr': return await import('ckeditor5-premium-features/translations/fr.js');
+        case 'gl': return await import('ckeditor5-premium-features/translations/gl.js');
+        case 'gu': return await import('ckeditor5-premium-features/translations/gu.js');
+        case 'he': return await import('ckeditor5-premium-features/translations/he.js');
+        case 'hi': return await import('ckeditor5-premium-features/translations/hi.js');
+        case 'hr': return await import('ckeditor5-premium-features/translations/hr.js');
+        case 'hu': return await import('ckeditor5-premium-features/translations/hu.js');
+        case 'hy': return await import('ckeditor5-premium-features/translations/hy.js');
+        case 'id': return await import('ckeditor5-premium-features/translations/id.js');
+        case 'it': return await import('ckeditor5-premium-features/translations/it.js');
+        case 'ja': return await import('ckeditor5-premium-features/translations/ja.js');
+        case 'jv': return await import('ckeditor5-premium-features/translations/jv.js');
+        case 'kk': return await import('ckeditor5-premium-features/translations/kk.js');
+        case 'km': return await import('ckeditor5-premium-features/translations/km.js');
+        case 'kn': return await import('ckeditor5-premium-features/translations/kn.js');
+        case 'ko': return await import('ckeditor5-premium-features/translations/ko.js');
+        case 'ku': return await import('ckeditor5-premium-features/translations/ku.js');
+        case 'lt': return await import('ckeditor5-premium-features/translations/lt.js');
+        case 'lv': return await import('ckeditor5-premium-features/translations/lv.js');
+        case 'ms': return await import('ckeditor5-premium-features/translations/ms.js');
+        case 'nb': return await import('ckeditor5-premium-features/translations/nb.js');
+        case 'ne': return await import('ckeditor5-premium-features/translations/ne.js');
+        case 'nl': return await import('ckeditor5-premium-features/translations/nl.js');
+        case 'no': return await import('ckeditor5-premium-features/translations/no.js');
+        case 'oc': return await import('ckeditor5-premium-features/translations/oc.js');
+        case 'pl': return await import('ckeditor5-premium-features/translations/pl.js');
+        case 'pt': return await import('ckeditor5-premium-features/translations/pt.js');
+        case 'pt-br': return await import('ckeditor5-premium-features/translations/pt-br.js');
+        case 'ro': return await import('ckeditor5-premium-features/translations/ro.js');
+        case 'ru': return await import('ckeditor5-premium-features/translations/ru.js');
+        case 'si': return await import('ckeditor5-premium-features/translations/si.js');
+        case 'sk': return await import('ckeditor5-premium-features/translations/sk.js');
+        case 'sl': return await import('ckeditor5-premium-features/translations/sl.js');
+        case 'sq': return await import('ckeditor5-premium-features/translations/sq.js');
+        case 'sr': return await import('ckeditor5-premium-features/translations/sr.js');
+        case 'sr-latn': return await import('ckeditor5-premium-features/translations/sr-latn.js');
+        case 'sv': return await import('ckeditor5-premium-features/translations/sv.js');
+        case 'th': return await import('ckeditor5-premium-features/translations/th.js');
+        case 'tk': return await import('ckeditor5-premium-features/translations/tk.js');
+        case 'tr': return await import('ckeditor5-premium-features/translations/tr.js');
+        case 'tt': return await import('ckeditor5-premium-features/translations/tt.js');
+        case 'ug': return await import('ckeditor5-premium-features/translations/ug.js');
+        case 'uk': return await import('ckeditor5-premium-features/translations/uk.js');
+        case 'ur': return await import('ckeditor5-premium-features/translations/ur.js');
+        case 'uz': return await import('ckeditor5-premium-features/translations/uz.js');
+        case 'vi': return await import('ckeditor5-premium-features/translations/vi.js');
+        case 'zh': return await import('ckeditor5-premium-features/translations/zh.js');
+        case 'zh-cn': return await import('ckeditor5-premium-features/translations/zh-cn.js');
+        default:
+          console.warn(`Language ${lang} not found in premium translations`);
+          return await import('ckeditor5-premium-features/translations/en.js'); // fallback to English
+      }
+    }
+    /* v8 ignore next 7 */
+  }
+  catch (error) {
+    console.error(`Failed to load translation for ${pkg}/${lang}:`, error);
+    return null;
+  }
+}