@jackuait/blok 0.4.1-beta.1 → 0.4.1-beta.11

package/src/components/tools/factory.ts

@@ -0,0 +1,138 @@
+import type { ToolConstructable, ToolSettings } from '../../../types/tools';
+import { InternalInlineToolSettings, InternalTuneSettings } from './base';
+import { InlineToolAdapter } from './inline';
+import { BlockTuneAdapter } from './tune';
+import { BlockToolAdapter } from './block';
+import type { API as ApiModule } from '../modules/api';
+import type { BlokConfig } from '../../../types/configs';
+import type { API as ApiMethods, I18n } from '../../../types';
+
+type ToolConstructor = typeof InlineToolAdapter | typeof BlockToolAdapter | typeof BlockTuneAdapter;
+
+/**
+ * Factory to construct classes to work with tools
+ */
+export class ToolsFactory {
+  /**
+   * Tools configuration specified by user
+   */
+  private config: {[name: string]: ToolSettings & { isInternal?: boolean }};
+
+  /**
+   * Blok API Module
+   */
+  private api: ApiModule;
+
+  /**
+   * Blok configuration
+   */
+  private blokConfig: BlokConfig;
+
+  /**
+   * @class
+   * @param config - tools config
+   * @param blokConfig - Blok config
+   * @param api - Blok API module
+   */
+  constructor(
+    config: {[name: string]: ToolSettings & { isInternal?: boolean }},
+    blokConfig: BlokConfig,
+    api: ApiModule
+  ) {
+    this.api = api;
+    this.config = config;
+    this.blokConfig = blokConfig;
+  }
+
+  /**
+   * Returns Tool object based on it's type
+   * @param name - tool name
+   */
+  public get(name: string): InlineToolAdapter | BlockToolAdapter | BlockTuneAdapter {
+    const { class: constructableCandidate, isInternal = false, ...config } = this.config[name];
+    const constructable = constructableCandidate as ToolConstructable | undefined;
+
+    if (constructable === undefined) {
+      throw new Error(`Tool "${name}" does not provide a class.`);
+    }
+
+    const Constructor = this.getConstructor(constructable);
+    const toolApi = this.createToolApi(name);
+
+    return new Constructor({
+      name,
+      constructable,
+      config,
+      api: toolApi,
+      isDefault: name === this.blokConfig.defaultBlock,
+      defaultPlaceholder: this.blokConfig.placeholder,
+      isInternal,
+    });
+  }
+
+  /**
+   * Creates a tool-specific API with namespaced i18n.
+   *
+   * EditorJS tools expect `api.i18n.t('key')` to automatically look up
+   * `tools.{toolName}.key`. This wrapper provides that behavior while
+   * falling back to direct key lookup for Blok internal tools that use
+   * fully-qualified keys like `tools.stub.error`.
+   *
+   * @param toolName - Name of the tool
+   * @returns API object with tool-namespaced i18n
+   */
+  private createToolApi(toolName: string): ApiMethods {
+    const baseApi = this.api.methods;
+    const namespace = `tools.${toolName}`;
+
+    const namespacedI18n: I18n = {
+      t: (dictKey: string): string => {
+        /**
+         * Try namespaced key first for EditorJS compatibility.
+         * External tools call t('Add row') expecting lookup of 'tools.table.Add row'.
+         */
+        const namespacedKey = `${namespace}.${dictKey}`;
+
+        if (baseApi.i18n.has(namespacedKey)) {
+          return baseApi.i18n.t(namespacedKey);
+        }
+
+        /**
+         * Fall back to direct key lookup for Blok internal tools.
+         * Internal tools use fully-qualified keys like 'tools.stub.error'.
+         */
+        return baseApi.i18n.t(dictKey);
+      },
+
+      has: (dictKey: string): boolean => {
+        const namespacedKey = `${namespace}.${dictKey}`;
+
+        return baseApi.i18n.has(namespacedKey) || baseApi.i18n.has(dictKey);
+      },
+
+      getEnglishTranslation: (key: string): string => {
+        return baseApi.i18n.getEnglishTranslation(key);
+      },
+    };
+
+    return {
+      ...baseApi,
+      i18n: namespacedI18n,
+    };
+  }
+
+  /**
+   * Find appropriate Tool object constructor for Tool constructable
+   * @param constructable - Tools constructable
+   */
+  private getConstructor(constructable: ToolConstructable): ToolConstructor {
+    switch (true) {
+      case Boolean(Reflect.get(constructable, InternalInlineToolSettings.IsInline)):
+        return InlineToolAdapter;
+      case Boolean(Reflect.get(constructable, InternalTuneSettings.IsTune)):
+        return BlockTuneAdapter;
+      default:
+        return BlockToolAdapter;
+    }
+  }
+}

package/src/components/tools/inline.ts

@@ -0,0 +1,71 @@
+import { BaseToolAdapter } from './base';
+import type { InlineTool as IInlineTool, InlineToolConstructable } from '@/types';
+import type { InlineToolAdapter as InlineToolAdapterInterface } from '@/types/tools/adapters/inline-tool-adapter';
+import { ToolType } from '@/types/tools/adapters/tool-type';
+
+/**
+ * InlineTool object to work with Inline Tools constructables
+ */
+export class InlineToolAdapter extends BaseToolAdapter<ToolType.Inline, IInlineTool> implements InlineToolAdapterInterface {
+  /**
+   * Tool type — Inline
+   */
+  public type: ToolType.Inline = ToolType.Inline;
+
+  /**
+   * Returns list of required methods that are missing on the inline tool prototype
+   * @param requiredMethods - method names that must be implemented
+   */
+  public getMissingMethods(requiredMethods: string[]): string[] {
+    const constructable = this.constructable as InlineToolConstructable | undefined;
+    const prototype = constructable?.prototype as Record<string, unknown> | undefined;
+
+    if (!prototype) {
+      return [ ...requiredMethods ];
+    }
+
+    return requiredMethods.filter((methodName) => typeof prototype[methodName] !== 'function');
+  }
+
+  /**
+   * Constructs new InlineTool instance from constructable
+   */
+  public create(): IInlineTool {
+
+    const InlineToolClass = this.constructable as InlineToolConstructable;
+
+    return new InlineToolClass({
+      api: this.api,
+      config: this.settings,
+    }) as IInlineTool;
+  }
+
+  /**
+   * Allows inline tool to be available in read-only mode
+   * Can be used, for example, by comments tool
+   */
+  public get isReadOnlySupported(): boolean {
+    const constructable = this.constructable as InlineToolConstructable | undefined;
+
+    return constructable?.isReadOnlySupported ?? false;
+  }
+
+  /**
+   * Returns title of the tool
+   */
+  public get title(): string {
+    const constructable = this.constructable as InlineToolConstructable;
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated -- Backward compatibility: title is deprecated but still needs to be supported
+    return constructable['title'] || '';
+  }
+
+  /**
+   * Returns the translation key for the tool title
+   */
+  public get titleKey(): string | undefined {
+    const constructable = this.constructable as InlineToolConstructable;
+
+    return constructable['titleKey'];
+  }
+}

package/src/components/tools/tune.ts

@@ -0,0 +1,33 @@
+import { BaseToolAdapter } from './base';
+import type { BlockAPI, BlockTune as IBlockTune, BlockTuneConstructable } from '@/types';
+import type { BlockTuneData } from '@/types/block-tunes/block-tune-data';
+import type { BlockTuneAdapter as BlockTuneAdapterInterface } from '@/types/tools/adapters/block-tune-adapter';
+import { ToolType } from '@/types/tools/adapters/tool-type';
+
+/**
+ * Stub class for BlockTunes
+ * @todo Implement
+ */
+export class BlockTuneAdapter extends BaseToolAdapter<ToolType.Tune, IBlockTune> implements BlockTuneAdapterInterface {
+  /**
+   * Tool type — Tune
+   */
+  public type: ToolType.Tune = ToolType.Tune;
+
+  /**
+   * Constructs new BlockTune instance from constructable
+   * @param data - Tune data
+   * @param block - Block API object
+   */
+  public create(data: BlockTuneData, block: BlockAPI): IBlockTune {
+     
+    const BlockTuneClass = this.constructable as BlockTuneConstructable;
+
+    return new BlockTuneClass({
+      api: this.api,
+      config: this.settings,
+      block,
+      data,
+    });
+  }
+}