@shelamkoff/rector 1.0.0

package/dist/core/InlinePluginRegistry.js

@@ -0,0 +1,128 @@
+/**
+ * @typedef {import('./types').InlinePlugin} InlinePlugin
+ * @typedef {import('./types').InlinePluginContext} InlinePluginContext
+ */
+
+/** @typedef {import('./types').IInlinePluginRegistry} IInlinePluginRegistryContract */
+/**
+ * Registry for inline plugins (widgets inside text blocks).
+ * Inline plugins are different from block plugins (full blocks) and inline tools (text formatting).
+ * @implements {IInlinePluginRegistryContract}
+ */
+export class InlinePluginRegistry {
+  /** @type {Map<string, InlinePlugin>} */
+  #plugins = new Map()
+
+  /** @type {Map<string, InlinePlugin>} */
+  #triggers = new Map()
+
+  /**
+   * @param {InlinePlugin[]} plugins
+   */
+  constructor(plugins = []) {
+    for (const plugin of plugins) {
+      this.register(plugin)
+    }
+  }
+
+  /**
+   * @param {InlinePlugin} plugin
+   */
+  register(plugin) {
+    if (!plugin || typeof plugin.type !== 'string' || !plugin.type) {
+      throw new TypeError('Every inline plugin must have a non-empty string type')
+    }
+    for (const method of ['createWidget', 'hydrate', 'getData']) {
+      if (typeof plugin[method] !== 'function') {
+        throw new TypeError(`Inline plugin "${plugin.type}" must implement ${method}()`)
+      }
+    }
+    if (this.#plugins.has(plugin.type)) {
+      throw new Error(`Duplicate inline plugin type: "${plugin.type}"`)
+    }
+    if (plugin.trigger !== undefined) {
+      if (typeof plugin.trigger !== 'string' || Array.from(plugin.trigger).length !== 1) {
+        throw new TypeError(`Inline plugin "${plugin.type}" trigger must be exactly one Unicode code point`)
+      }
+      if (this.#triggers.has(plugin.trigger)) {
+        throw new Error(`Duplicate inline plugin trigger: "${plugin.trigger}"`)
+      }
+      this.#triggers.set(plugin.trigger, plugin)
+    }
+    this.#plugins.set(plugin.type, plugin)
+  }
+
+  /**
+   * @param {string} type
+   * @returns {InlinePlugin | undefined}
+   */
+  get(type) {
+    return this.#plugins.get(type)
+  }
+
+  /**
+   * @param {string} char
+   * @returns {InlinePlugin | undefined}
+   */
+  getByTrigger(char) {
+    return this.#triggers.get(char)
+  }
+
+  /** @returns {IterableIterator<InlinePlugin>} */
+  values() {
+    return this.#plugins.values()
+  }
+
+  /** @returns {number} */
+  get size() {
+    return this.#plugins.size
+  }
+
+  /** @returns {boolean} */
+  get hasTriggers() {
+    return this.#triggers.size > 0
+  }
+
+  /**
+   * Acquire resources that must be scoped to one live editor root.
+   * @param {HTMLElement} rootElement
+   * @param {import('./types').InlinePluginContext} ctx
+   */
+  mount(rootElement, ctx) {
+    const mounted = []
+    try {
+      for (const plugin of this.#plugins.values()) {
+        plugin.mount?.(rootElement, ctx)
+        mounted.push(plugin)
+      }
+    } catch (error) {
+      for (const plugin of mounted.reverse()) {
+        try { plugin.destroy?.() } catch { /* preserve the mount failure */ }
+      }
+      throw error
+    }
+  }
+
+  /**
+   * Get all registered trigger characters.
+   * @returns {string[]}
+   */
+  triggerKeys() {
+    return [...this.#triggers.keys()]
+  }
+
+  /**
+   * Release plugin-level resources such as global listeners and shared styles.
+   */
+  destroy() {
+    for (const plugin of this.#plugins.values()) {
+      try {
+        plugin.destroy?.()
+      } catch (err) {
+        console.warn('[InlinePluginRegistry] Failed to destroy plugin "' + plugin.type + '":', err)
+      }
+    }
+    this.#plugins.clear()
+    this.#triggers.clear()
+  }
+}

package/dist/core/KeyboardManager.d.ts

@@ -0,0 +1,17 @@
+export class KeyboardManager {
+    /**
+     * @param {HTMLElement} rootEl
+     * @param {import('./types.js').IBlockOperations} blockOps
+     * @param {import('./ShortcutRegistry.js').ShortcutRegistry} shortcuts
+     * @param {import('./types.js').IBlockManager} blocks
+     * @param {import('./types.js').IEventBus} events
+     * @param {string} defaultBlockType
+     * @param {(() => boolean)} [uiActivePredicate]
+     */
+    constructor(rootEl: HTMLElement, blockOps: import("./types.js").IBlockOperations, shortcuts: import("./ShortcutRegistry.js").ShortcutRegistry, blocks: import("./types.js").IBlockManager, events: import("./types.js").IEventBus, defaultBlockType: string, uiActivePredicate?: (() => boolean));
+    /**
+     * Clean up.
+     */
+    destroy(): void;
+    #private;
+}

package/dist/core/KeyboardManager.js

@@ -0,0 +1,231 @@
+import { BLOCK_SELECTOR } from './constants.js'
+import { EditorEvent } from './editorEvents.js'
+
+export class KeyboardManager {
+  /** @type {HTMLElement} */
+  #rootEl
+
+  /** @type {import('./types').IBlockOperations} */
+  #blockOps
+
+  /** @type {import('./ShortcutRegistry').ShortcutRegistry} */
+  #shortcuts
+
+  /** @type {import('./types').IBlockManager} */
+  #blocks
+
+  /** @type {import('./types').IEventBus} */
+  #events
+
+  /** @type {string} */
+  #defaultBlockType
+
+  /**
+   * Predicate that returns true when an interactive UI overlay is open
+   * (dropdown, actions panel, etc.). While true, KeyboardManager yields
+   * control — keys go to the overlay, not to block editing.
+   * @type {(() => boolean) | null}
+   */
+  #isUIActive = null
+
+  /**
+   * @param {HTMLElement} rootEl
+   * @param {import('./types').IBlockOperations} blockOps
+   * @param {import('./ShortcutRegistry').ShortcutRegistry} shortcuts
+   * @param {import('./types').IBlockManager} blocks
+   * @param {import('./types').IEventBus} events
+   * @param {string} defaultBlockType
+   * @param {(() => boolean)} [uiActivePredicate]
+   */
+  constructor(rootEl, blockOps, shortcuts, blocks, events, defaultBlockType, uiActivePredicate) {
+    this.#rootEl = rootEl
+    this.#blockOps = blockOps
+    this.#shortcuts = shortcuts
+    this.#blocks = blocks
+    this.#events = events
+    this.#defaultBlockType = defaultBlockType
+    this.#isUIActive = uiActivePredicate ?? null
+
+    rootEl.addEventListener('keydown', this.#onKeyDown)
+  }
+
+  /**
+   * Clean up.
+   */
+  destroy() {
+    this.#rootEl.removeEventListener('keydown', this.#onKeyDown)
+  }
+
+  /**
+   * @param {KeyboardEvent} e
+   */
+  #onKeyDown = (e) => {
+    const target = /** @type {HTMLElement} */ (e.target)
+    const isBlockTarget = target === this.#rootEl || !!target.closest?.(BLOCK_SELECTOR)
+
+    // Editor-scoped history must run before overlay routing. Otherwise an open
+    // actions panel/dropdown lets the browser execute its own contenteditable
+    // DOM history, whose order is unrelated to the editor's block history.
+    if (isBlockTarget && this.#shortcuts.handle(e, 'editor')) return
+
+    // Document-level shortcuts (currently undo/redo) remain available while a
+    // non-text editor control owns focus. Native history in inputs, textareas,
+    // selects, and auxiliary contenteditables must never be intercepted.
+    if (!isBlockTarget) {
+      const isEditorControl = this.#rootEl.contains(target)
+      const ownsNativeHistory = !!target.closest?.('input, textarea, select, [contenteditable="true"]')
+      if (isEditorControl && !ownsNativeHistory) this.#shortcuts.handle(e, 'editor')
+      return
+    }
+
+    // Skip block commands when interactive UI overlay is active. The overlay
+    // handles its own keyboard events.
+    if (this.#isUIActive?.()) return
+
+    // 0. If blocks are selected, handle delete/backspace to remove them
+    if (this.#blocks.hasSelectedBlocks()) {
+      if (e.key === 'Backspace' || e.key === 'Delete') {
+        e.preventDefault()
+        this.#deleteSelectedBlocks()
+        return
+      }
+      // Any other non-modifier key clears selection
+      if (!e.ctrlKey && !e.metaKey && !e.altKey && e.key.length === 1) {
+        this.#blocks.clearSelection()
+      }
+    }
+
+    // 1. Try content-scoped shortcuts (Mod+B, plugin shortcuts...). Editor-
+    // scoped history was already offered above and will not match again here
+    // because a handled event returned immediately.
+    if (this.#shortcuts.handle(e)) return
+
+    // 2. Structural keys
+    switch (e.key) {
+      case 'Enter':
+        if (!e.shiftKey && !e.metaKey && !e.ctrlKey) {
+          e.preventDefault()
+          this.#blockOps.splitBlock()
+        }
+        return
+
+      case 'Backspace':
+        if (!e.metaKey && !e.ctrlKey) {
+          if (this.#blockOps.mergeWithPrevious()) {
+            e.preventDefault()
+          } else {
+            // Convert empty non-default block to default type (e.g. empty list → paragraph)
+            if (this.#blockOps.exitEmptyBlock()) e.preventDefault()
+          }
+        }
+        return
+
+      case 'Delete':
+        if (!e.metaKey && !e.ctrlKey) {
+          if (this.#blockOps.mergeWithNext()) {
+            e.preventDefault()
+          }
+        }
+        return
+
+      case 'ArrowUp':
+        if (!e.metaKey && !e.ctrlKey && !e.shiftKey) {
+          if (this.#blockOps.navigateToPrevious()) {
+            e.preventDefault()
+          }
+        }
+        return
+
+      case 'ArrowDown':
+        if (!e.metaKey && !e.ctrlKey && !e.shiftKey) {
+          if (this.#blockOps.navigateToNext()) {
+            e.preventDefault()
+          }
+        }
+        return
+
+    }
+
+    // 3. Cmd+A — select all in block, then all blocks
+    // Use e.code for layout independence (e.key is 'ф' on Russian layout)
+    if ((e.metaKey || e.ctrlKey) && e.code === 'KeyA') {
+      this.#handleSelectAll(e)
+    }
+  }
+
+  /**
+   * Ctrl+A logic based on selection state (no timer):
+   * - If blocks are already selected → clear selection, let browser select text
+   * - If no text is selected (collapsed caret) → let browser select all in current block
+   * - If text is already selected (second press) → select all blocks
+   * @param {KeyboardEvent} e
+   */
+  #handleSelectAll(e) {
+    // If blocks are already in selected state, clear and let browser re-select text
+    if (this.#blocks.hasSelectedBlocks()) {
+      this.#blocks.clearSelection()
+      // Don't preventDefault — browser's native Ctrl+A will select text in the
+      // focused contenteditable (user-select:none is removed synchronously above)
+      return
+    }
+
+    const sel = window.getSelection()
+    const current = this.#blocks.getCurrentBlock()
+
+    // If current block is empty (collapsed caret, nothing to select),
+    // skip browser's native selectAll and go directly to block selection
+    const isEmptyBlock = current && current.isEmpty()
+
+    if ((sel && !sel.isCollapsed) || isEmptyBlock) {
+      // Text is already selected (second Ctrl+A) or block is empty → select all blocks
+      e.preventDefault()
+
+      const ids = []
+      let firstBlock = null
+      let lastBlock = null
+      const lastIdx = this.#blocks.getBlockCount() - 1
+
+      for (let i = 0; i <= lastIdx; i++) {
+        const block = this.#blocks.getBlockByIndex(i)
+        if (!block) continue
+        // Skip the last block if it's empty
+        if (i === lastIdx && block.isEmpty()) continue
+        block.selected = true
+        ids.push(block.id)
+        if (!firstBlock) firstBlock = block
+        lastBlock = block
+      }
+
+      // Create native selection spanning all selected blocks
+      if (firstBlock && lastBlock && sel) {
+        const firstCe = firstBlock.contentElement
+        const lastCe = lastBlock.contentElement
+        const range = document.createRange()
+        range.setStart(firstCe, 0)
+        range.setEnd(lastCe, lastCe.childNodes.length)
+        sel.removeAllRanges()
+        sel.addRange(range)
+      }
+
+      this.#events.emit(EditorEvent.BLOCK_SELECTED, { blockIds: ids })
+    }
+    // else: collapsed caret in non-empty block → let browser handle (selects text)
+  }
+
+  /**
+   * Delete all selected blocks, leave one empty block.
+   */
+  #deleteSelectedBlocks() {
+    this.#events.emit(EditorEvent.UNDO_BATCH_START)
+    try {
+      const result = this.#blocks.removeSelected(this.#defaultBlockType)
+      if (result) {
+        this.#blocks.setCurrentIndex(result.focusIndex)
+        const focusBlock = this.#blocks.getBlockByIndex(result.focusIndex)
+        if (focusBlock) focusBlock.focus()
+      }
+    } finally {
+      this.#events.emit(EditorEvent.UNDO_BATCH_END)
+    }
+  }
+}

package/dist/core/LifecycleScope.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Owns a replaceable group of editor modules.
+ *
+ * Dynamic editor modes use a child scope so all listeners and UI managers
+ * created for that mode are released together without touching resources
+ * owned by the editor instance itself.
+ */
+export class LifecycleScope {
+    /**
+     * @template T
+     * @param {T & { destroy(): void }} resource
+     * @returns {T}
+     */
+    register<T>(resource: T & {
+        destroy(): void;
+    }): T;
+    destroy(): void;
+    #private;
+}

package/dist/core/LifecycleScope.js

@@ -0,0 +1,41 @@
+/**
+ * Owns a replaceable group of editor modules.
+ *
+ * Dynamic editor modes use a child scope so all listeners and UI managers
+ * created for that mode are released together without touching resources
+ * owned by the editor instance itself.
+ */
+export class LifecycleScope {
+  /** @type {Array<{ destroy(): void }>} */
+  #resources = []
+
+  /** @type {boolean} */
+  #destroyed = false
+
+  /**
+   * @template T
+   * @param {T & { destroy(): void }} resource
+   * @returns {T}
+   */
+  register(resource) {
+    if (this.#destroyed) {
+      resource.destroy()
+      throw new Error('Cannot register a resource in a destroyed lifecycle scope')
+    }
+    this.#resources.push(resource)
+    return resource
+  }
+
+  destroy() {
+    if (this.#destroyed) return
+    this.#destroyed = true
+    for (let index = this.#resources.length - 1; index >= 0; index--) {
+      try {
+        this.#resources[index]?.destroy()
+      } catch (error) {
+        console.warn('[LifecycleScope] Failed to destroy a resource:', error)
+      }
+    }
+    this.#resources = []
+  }
+}

package/dist/core/MouseSelectionManager.d.ts

@@ -0,0 +1,30 @@
+export class MouseSelectionManager {
+    /**
+     * @typedef {Object} MouseSelectionConfig
+     * @property {HTMLElement} blocksEl
+     * @property {HTMLElement} clickArea
+     * @property {import('./types.js').IBlockManager} blocks
+     * @property {import('./types.js').ISelectionManager} selection
+     * @property {import('./types.js').IEventBus} events
+     * @property {import('./types.js').ICrossBlockSelection} crossBlockSelection
+     * @property {string} defaultBlockType
+     */
+    /**
+     * @param {HTMLElement} rootEl
+     * @param {MouseSelectionConfig} config
+     */
+    constructor(rootEl: HTMLElement, config: {
+        blocksEl: HTMLElement;
+        clickArea: HTMLElement;
+        blocks: import("./types.js").IBlockManager;
+        selection: import("./types.js").ISelectionManager;
+        events: import("./types.js").IEventBus;
+        crossBlockSelection: import("./types.js").ICrossBlockSelection;
+        defaultBlockType: string;
+    });
+    /**
+     * Clean up all event listeners.
+     */
+    destroy(): void;
+    #private;
+}