Fixes after review

src/components/modules/blockManager.ts

@@ -222,7 +222,7 @@ export default class BlockManager extends Module {
    */
   public composeBlock({ tool: name, data = {} }: {tool: string; data?: BlockToolData}): Block {
     const readOnly = this.Editor.ReadOnly.isEnabled;
-    const tool = this.Editor.Tools.block.get(name);
+    const tool = this.Editor.Tools.blockTools.get(name);
     const block = new Block({
       name,
       data,

src/components/modules/paste.ts

@@ -3,7 +3,6 @@ import $ from '../dom';
 import * as _ from '../utils';
 import {
   BlockAPI,
-  PasteConfig,
   PasteEvent,
   PasteEventDetail
 } from '../../../types';
@@ -18,7 +17,6 @@ interface TagSubstitute {
   /**
    * Name of related Tool
    *
-   * @type {string}
    */
   tool: BlockTool;
 }
@@ -29,22 +27,16 @@ interface TagSubstitute {
 interface PatternSubstitute {
   /**
    * Pattern`s key
-   *
-   * @type {string}
    */
   key: string;
 
   /**
    * Pattern regexp
-   *
-   * @type {RegExp}
    */
   pattern: RegExp;
 
   /**
    * Name of related Tool
-   *
-   * @type {string}
    */
   tool: BlockTool;
 }
@@ -277,7 +269,7 @@ export default class Paste extends Module {
    * Get and process tool`s paste configs
    */
   private processTools(): void {
-    const tools = this.Editor.Tools.block;
+    const tools = this.Editor.Tools.blockTools;
 
     Array
       .from(tools.values())
@@ -648,7 +640,7 @@ export default class Paste extends Module {
    * @param {PasteData} dataToInsert - data of Block to insert
    */
   private async processInlinePaste(dataToInsert: PasteData): Promise<void> {
-    const { BlockManager, Caret, Sanitizer, Tools } = this.Editor;
+    const { BlockManager, Caret, Sanitizer } = this.Editor;
     const { content } = dataToInsert;
 
     const currentBlockIsDefault = BlockManager.currentBlock && BlockManager.currentBlock.tool.isDefault;

src/components/modules/readonly.ts

@@ -37,11 +37,11 @@ export default class ReadOnly extends Module {
    */
   public async prepare(): Promise<void> {
     const { Tools } = this.Editor;
-    const { block } = Tools;
+    const { blockTools } = Tools;
     const toolsDontSupportReadOnly: string[] = [];
 
     Array
-      .from(block.entries())
+      .from(blockTools.entries())
       .forEach(([name, tool]) => {
         if (tool.isReadOnlySupported) {
           toolsDontSupportReadOnly.push(name);

src/components/modules/sanitizer.ts

@@ -207,7 +207,7 @@ export default class Sanitizer extends Module {
       (enableInlineTools as string[]).map((inlineToolName) => {
         config = Object.assign(
           config,
-          Tools.inline.get(inlineToolName).sanitizeConfig
+          Tools.inlineTools.get(inlineToolName).sanitizeConfig
         ) as SanitizerConfig;
       });
     }
@@ -233,7 +233,7 @@ export default class Sanitizer extends Module {
 
     const config: SanitizerConfig = {} as SanitizerConfig;
 
-    Object.entries(Tools.inline)
+    Object.entries(Tools.inlineTools)
       .forEach(([, inlineTool]: [string, InlineTool]) => {
         Object.assign(config, inlineTool.sanitizeConfig);
       });

src/components/modules/toolbar/conversion.ts

@@ -200,7 +200,7 @@ export default class ConversionToolbar extends Module<ConversionToolbarNodes> {
      *
      * @type {BlockToolConstructable}
      */
-    const replacingTool = this.Editor.Tools.block.get(replacingToolName);
+    const replacingTool = this.Editor.Tools.blockTools.get(replacingToolName);
 
     /**
      * Export property can be:
@@ -269,7 +269,7 @@ export default class ConversionToolbar extends Module<ConversionToolbarNodes> {
    * if tools have ability to import
    */
   private addTools(): void {
-    const tools = this.Editor.Tools.block;
+    const tools = this.Editor.Tools.blockTools;
 
     Array
       .from(tools.entries())

src/components/modules/toolbar/inline.ts

@@ -338,7 +338,7 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
      * If common settings is 'true' or not specified (will be set as true at core.ts), get the default order
      */
     if (commonInlineToolbarSettings === true) {
-      return Array.from(this.Editor.Tools.inline.keys());
+      return Array.from(this.Editor.Tools.inlineTools.keys());
     }
 
     return false;
@@ -573,7 +573,7 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
     const inlineToolbarOrder = this.getInlineToolbarSettings(currentBlock.tool) as string[];
 
     inlineToolbarOrder.forEach((toolName) => {
-      const tool = this.Editor.Tools.inline.get(toolName);
+      const tool = this.Editor.Tools.inlineTools.get(toolName);
 
       this.addTool(tool);
     });
@@ -663,7 +663,7 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
      * Enable shortcuts
      * Ignore tool that doesn't have shortcut or empty string
      */
-    const tool = Tools.inline.get(toolName);
+    const tool = Tools.inlineTools.get(toolName);
 
     /**
      * 1) For internal tools, check public getter 'shortcut'
@@ -745,7 +745,7 @@ export default class InlineToolbar extends Module<InlineToolbarNodes> {
     const result = {};
 
     Array
-      .from(this.Editor.Tools.inline.entries())
+      .from(this.Editor.Tools.inlineTools.entries())
       .forEach(([name, tool]) => {
         result[name] = tool.instance();
       });

src/components/modules/toolbar/toolbox.ts

@@ -161,7 +161,7 @@ export default class Toolbox extends Module<ToolboxNodes> {
    * Iterates available tools and appends them to the Toolbox
    */
   private addTools(): void {
-    const tools = this.Editor.Tools.block;
+    const tools = this.Editor.Tools.blockTools;
 
     Array
       .from(tools.values())
@@ -284,7 +284,7 @@ export default class Toolbox extends Module<ToolboxNodes> {
    * Fired when the Read-Only mode is activated
    */
   private removeAllShortcuts(): void {
-    const tools = this.Editor.Tools.block;
+    const tools = this.Editor.Tools.blockTools;
 
     Array
       .from(tools.values())

src/components/modules/tools.ts

@@ -67,7 +67,7 @@ export default class Tools extends Module {
    *
    * @returns {object} - object of Inline Tool's classes
    */
-  public get inline(): Map<string, InlineTool> {
+  public get inlineTools(): Map<string, InlineTool> {
     if (this._inlineTools) {
       return this._inlineTools;
     }
@@ -108,7 +108,7 @@ export default class Tools extends Module {
   /**
    * Return editor block tools
    */
-  public get block(): Map<string, BlockTool> {
+  public get blockTools(): Map<string, BlockTool> {
     if (this._blockTools) {
       return this._blockTools;
     }
@@ -128,7 +128,7 @@ export default class Tools extends Module {
    * Returns default Tool object
    */
   public get defaultTool(): BlockTool {
-    return this.block.get(this.config.defaultBlock);
+    return this.blockTools.get(this.config.defaultBlock);
   }
 
   /**
@@ -215,9 +215,9 @@ export default class Tools extends Module {
      * to see how it works {@link '../utils.ts#sequence'}
      */
     return _.sequence(sequenceData, (data: { toolName: string }) => {
-      this.success(data);
+      this.toolPrepareMethodSuccess(data);
     }, (data: { toolName: string }) => {
-      this.fallback(data);
+      this.toolPrepareMethodFallback(data);
     });
   }
 
@@ -263,20 +263,20 @@ export default class Tools extends Module {
   }
 
   /**
-   * Success callback
+   * Tool prepare method success callback
    *
    * @param {object} data - append tool to available list
    */
-  private success(data: { toolName: string }): void {
+  private toolPrepareMethodSuccess(data: { toolName: string }): void {
     this.toolsAvailable.set(data.toolName, this.factory.get(data.toolName));
   }
 
   /**
-   * Fail callback
+   * Tool prepare method fail callback
    *
    * @param {object} data - append tool to unavailable list
    */
-  private fallback(data: { toolName: string }): void {
+  private toolPrepareMethodFallback(data: { toolName: string }): void {
     this.toolsUnavailable.set(data.toolName, this.factory.get(data.toolName));
   }
 

src/components/tools/base.ts

@@ -3,33 +3,90 @@ import { Tool, ToolConstructable, ToolSettings } from '../../../types/tools';
 import { API, SanitizerConfig } from '../../../types';
 import * as _ from '../utils';
 
+/**
+ * Enum of Tool options provided by user
+ */
 export enum UserSettings {
+  /**
+   * Shortcut for Tool
+   */
   Shortcut = 'shortcut',
+  /**
+   * Toolbox config for Tool
+   */
   Toolbox = 'toolbox',
+  /**
+   * Enabled Inline Tools for Block Tool
+   */
   EnabledInlineTools = 'inlineToolbar',
+  /**
+   * Tool configuration
+   */
   Config = 'config',
 }
 
+/**
+ * Enum of Tool options provided by Tool
+ */
 export enum CommonInternalSettings {
+  /**
+   * Shortcut for Tool
+   */
   Shortcut = 'shortcut',
+  /**
+   * Sanitize configuration for Tool
+   */
   SanitizeConfig = 'sanitize',
 
 }
 
+/**
+ * Enum of Tool optoins provided by Block Tool
+ */
 export enum InternalBlockToolSettings {
+  /**
+   * Is linebreaks enabled for Tool
+   */
   IsEnabledLineBreaks = 'enableLineBreaks',
+  /**
+   * Tool Toolbox config
+   */
   Toolbox = 'toolbox',
+  /**
+   * Tool conversion config
+   */
   ConversionConfig = 'conversionConfig',
+  /**
+   * Is readonly mode supported for Tool
+   */
   IsReadOnlySupported = 'isReadOnlySupported',
+  /**
+   * Tool paste config
+   */
   PasteConfig = 'pasteConfig'
 }
 
+/**
+ * Enum of Tool options provided by Inline Tool
+ */
 export enum InternalInlineToolSettings {
+  /**
+   * Flag specifies Tool is inline
+   */
   IsInline = 'isInline',
+  /**
+   * Inline Tool title for toolbar
+   */
   Title = 'title', // for Inline Tools. Block Tools can pass title along with icon through the 'toolbox' static prop.
 }
 
+/**
+ * Enum of Tool options provided by Block Tune
+ */
 export enum InternalTuneSettings {
+  /**
+   * Flag specifies Tool is Block Tune
+   */
   IsTune = 'isTune',
 }