@jackuait/blok 0.4.3-beta.10 → 0.4.3-beta.2

package/src/tools/header/index.ts

@@ -16,7 +16,6 @@ import type {
   BlockToolData,
   PasteEvent,
   ToolboxConfig,
-  ToolboxConfigEntry,
   ConversionConfig,
   SanitizerConfig,
   PasteConfig,
@@ -61,11 +60,6 @@ export interface HeaderConfig {
   defaultLevel?: number;
   /** Level-specific overrides keyed by level number (1-6) */
   levelOverrides?: Record<number, HeaderLevelConfig>;
-  /**
-   * @internal Injected by BlockToolAdapter - merged toolbox entries.
-   * When present, renderSettings() will use these entries instead of the default levels.
-   */
-  _toolboxEntries?: ToolboxConfigEntry[];
 }
 
 /**
@@ -201,28 +195,6 @@ export class Header implements BlockTool {
    * @returns MenuConfig array
    */
   public renderSettings(): MenuConfig {
-    const toolboxEntries = this._settings._toolboxEntries;
-
-    /**
-     * If user provided custom toolbox entries, use them to build settings menu.
-     * This ensures block settings match the toolbox configuration.
-     * Entries without explicit level data will default to the configured defaultLevel.
-     *
-     * Only fall back to levels config when _toolboxEntries is not provided or empty,
-     * or when using the default single "Heading" toolbox entry (detected by having
-     * exactly one entry with no level data and no custom title or the default "Heading" title).
-     */
-    const isDefaultToolboxEntry = toolboxEntries?.length === 1 &&
-      toolboxEntries[0].data === undefined &&
-      (toolboxEntries[0].title === undefined || toolboxEntries[0].title === 'Heading');
-
-    if (toolboxEntries !== undefined && toolboxEntries.length > 0 && !isDefaultToolboxEntry) {
-      return this.buildSettingsFromToolboxEntries(toolboxEntries);
-    }
-
-    /**
-     * Fall back to existing behavior using levels config
-     */
     return this.levels.map(level => {
       const translated = this.api.i18n.t(level.nameKey);
       const title = translated !== level.nameKey ? translated : level.name;
@@ -240,60 +212,6 @@ export class Header implements BlockTool {
     });
   }
 
-  /**
-   * Build settings menu items from toolbox entries.
-   * This allows users to customize which levels appear in block settings
-   * by configuring the toolbox.
-   *
-   * @param entries - Merged toolbox entries from user config
-   * @returns MenuConfig array
-   */
-  private buildSettingsFromToolboxEntries(entries: ToolboxConfigEntry[]): MenuConfig {
-    return entries.map(entry => {
-      const entryData = entry.data as { level?: number } | undefined;
-      const level = entryData?.level ?? this.defaultLevel.number;
-      const defaultLevel = Header.DEFAULT_LEVELS.find(l => l.number === level);
-      const fallbackTitle = defaultLevel?.name ?? `Heading ${level}`;
-
-      const title = this.resolveToolboxEntryTitle(entry, fallbackTitle);
-      const icon = entry.icon ?? defaultLevel?.icon ?? IconHeading;
-
-      return {
-        icon,
-        title,
-        onActivate: (): void => this.setLevel(level),
-        closeOnActivate: true,
-        isActive: this.currentLevel.number === level,
-        dataset: {
-          'blok-header-level': String(level),
-        },
-      };
-    });
-  }
-
-  /**
-   * Resolves the title for a toolbox entry.
-   * Priority: custom title > i18n key translation > fallback
-   *
-   * @param entry - Toolbox entry
-   * @param fallback - Fallback title if no custom title or translation found
-   * @returns Resolved title string
-   */
-  private resolveToolboxEntryTitle(entry: ToolboxConfigEntry, fallback: string): string {
-    if (entry.title !== undefined) {
-      return entry.title;
-    }
-
-    if (entry.titleKey === undefined) {
-      return fallback;
-    }
-
-    const namespacedKey = `toolNames.${entry.titleKey}`;
-    const translated = this.api.i18n.t(namespacedKey);
-
-    return translated !== namespacedKey ? translated : fallback;
-  }
-
   /**
    * Callback for Block's settings buttons
    *

package/src/tools/index.ts

@@ -6,16 +6,10 @@
  * // Import specific tools
  * import { Paragraph, Header, List, Bold, Italic, Link } from '@jackuait/blok/tools';
  *
- * // Use in Blok configuration (flat config style)
+ * // Use in Blok configuration
  * new Blok({
- *   tools: {
- *     paragraph: Paragraph,
- *     header: { class: Header, levels: [1, 2, 3] },
- *     list: List,
- *     bold: Bold,
- *     italic: Italic,
- *     link: Link,
- *   }
+ *   tools: { paragraph: Paragraph, header: Header, list: List },
+ *   inlineTools: { bold: Bold, italic: Italic, link: Link }
  * });
  */
 
@@ -31,11 +25,10 @@ export { LinkInlineTool as Link } from '../components/inline-tools/inline-tool-l
 export { ConvertInlineTool as Convert } from '../components/inline-tools/inline-tool-convert';
 
 // Default tools configuration for convenience
-// Note: inlineToolbar defaults to true, so it doesn't need to be specified
 export const defaultBlockTools = {
-  paragraph: { preserveBlank: true },
-  header: {},
-  list: {},
+  paragraph: { inlineToolbar: true, config: { preserveBlank: true } },
+  header: { inlineToolbar: true },
+  list: { inlineToolbar: true },
 } as const;
 
 export const defaultInlineTools = {

package/src/tools/list/index.ts

@@ -226,10 +226,10 @@ export class ListItem implements BlockTool {
     return this._settings.itemSize;
   }
 
-  private static readonly PLACEHOLDER_KEY = 'tools.list.placeholder';
+  private static readonly DEFAULT_PLACEHOLDER = 'List';
 
   private get placeholder(): string {
-    return this.api.i18n.t(ListItem.PLACEHOLDER_KEY);
+    return this.api.i18n.t(ListItem.DEFAULT_PLACEHOLDER);
   }
 
   private applyItemStyles(element: HTMLElement): void {

package/src/types-internal/nanoid.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Type declarations for nanoid module
+ * This is needed because nanoid is a devDependency but is imported in source code
+ * The actual nanoid code is bundled into the dist, but consumers compiling
+ * against the source files need type declarations
+ */
+declare module 'nanoid' {
+  /**
+   * Generate a secure random unique ID
+   * @param size - Size of the ID. Default is 21
+   * @returns Random unique ID string
+   */
+  export function nanoid(size?: number): string;
+}

package/types/api/i18n.d.ts

@@ -10,12 +10,4 @@ export interface I18n {
    * @returns Translated string, or the key itself if translation is missing
    */
   t(dictKey: string): string;
-
-  /**
-   * Check if a translation exists for the given key.
-   *
-   * @param dictKey - Full translation key to check
-   * @returns True if translation exists, false otherwise
-   */
-  has(dictKey: string): boolean;
 }

package/types/tools/tool-settings.d.ts

@@ -1,12 +1,6 @@
 import { ToolConfig } from './tool-config';
 import { ToolConstructable, BlockToolData, MenuConfig, MenuConfigItem } from './index';
 
-/**
- * Permissive type for tool class - accepts any constructor.
- * Runtime validation ensures the tool has required methods.
- */
-export type ToolClass = new (...args: any[]) => any;
-
 /**
  * Tool may specify its toolbox configuration
  * It may include several entries as well
@@ -55,9 +49,9 @@ export interface ToolboxConfigEntry {
 export interface ExternalToolSettings<Config extends object = any> {
 
   /**
-   * Tool's class - accepts any constructor, validated at runtime
+   * Tool's class
    */
-  class: ToolConstructable | ToolClass;
+  class: ToolConstructable;
 
   /**
    * User configuration object that will be passed to the Tool's constructor
@@ -94,58 +88,6 @@ export interface ExternalToolSettings<Config extends object = any> {
 export type InternalToolSettings<Config extends object = any> = Omit<ExternalToolSettings<Config>, 'class'> & Partial<Pick<ExternalToolSettings<Config>, 'class'>>;
 
 /**
- * Keys that Blok extracts from tool settings (not passed to tool constructor)
- */
-export type BlokToolSettingsKeys = 'class' | 'inlineToolbar' | 'tunes' | 'shortcut' | 'toolbox' | 'config';
-
-/**
- * Flat tool settings - tool-specific options at top level.
- * Blok extracts known keys and passes the rest as `config` to the tool.
- */
-export interface FlatToolSettings<Config extends object = any> {
-  /**
-   * Tool's class
-   */
-  class: ToolConstructable | ToolClass;
-
-  /**
-   * Is need to show Inline Toolbar.
-   * Defaults to true for block tools.
-   */
-  inlineToolbar?: boolean | string[];
-
-  /**
-   * BlockTunes for Tool
-   */
-  tunes?: boolean | string[];
-
-  /**
-   * Define shortcut that will render Tool
-   */
-  shortcut?: string;
-
-  /**
-   * Tool's Toolbox settings
-   */
-  toolbox?: ToolboxConfig | false;
-
-  /**
-   * Legacy nested config - merged with top-level tool options
-   * @deprecated Use flat config instead
-   */
-  config?: ToolConfig<Config>;
-
-  /**
-   * Tool-specific options (placeholder, levels, etc.)
-   * These are passed to the tool constructor as `config`
-   */
-  [key: string]: unknown;
-}
-
-/**
- * Union of all tool settings formats
+ * Union of external and internal Tools settings
  */
-export type ToolSettings<Config extends object = any> =
-  | InternalToolSettings<Config>
-  | ExternalToolSettings<Config>
-  | FlatToolSettings<Config>;
+export type ToolSettings<Config extends object = any> = InternalToolSettings<Config> | ExternalToolSettings<Config>;