@hubstr/kit 0.1.5 → 0.1.6

package/editor/src/editor-kernel/__tests__/plugin.test.ts

@@ -1,280 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { KernelPlugin } from '../plugin';
-
-describe('KernelPlugin', () => {
-  let plugin: KernelPlugin;
-  let clearMock1: ReturnType<typeof vi.fn>;
-  let clearMock2: ReturnType<typeof vi.fn>;
-  let clearMock3: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    // Create a concrete implementation for testing
-    class TestPlugin extends KernelPlugin {
-      public registerCleanup(clear: () => void) {
-        this.register(clear);
-      }
-
-      public registerMultipleCleanups(...clears: Array<() => void>) {
-        this.registerClears(...clears);
-      }
-    }
-
-    plugin = new TestPlugin();
-    clearMock1 = vi.fn();
-    clearMock2 = vi.fn();
-    clearMock3 = vi.fn();
-  });
-
-  describe('Constructor', () => {
-    it('should create a plugin instance', () => {
-      expect(plugin).toBeInstanceOf(KernelPlugin);
-    });
-
-    it('should inherit from EventEmitter', () => {
-      expect(plugin.on).toBeDefined();
-      expect(plugin.emit).toBeDefined();
-      expect(plugin.off).toBeDefined();
-    });
-
-    it('should initialize with empty clears array', () => {
-      // Test that destroy doesn't throw when no cleanups are registered
-      expect(() => plugin.destroy()).not.toThrow();
-    });
-  });
-
-  describe('register method', () => {
-    it('should register cleanup functions', () => {
-      (plugin as any).registerCleanup(clearMock1);
-
-      plugin.destroy();
-      expect(clearMock1).toHaveBeenCalledTimes(1);
-    });
-
-    it('should register multiple cleanup functions', () => {
-      (plugin as any).registerCleanup(clearMock1);
-      (plugin as any).registerCleanup(clearMock2);
-
-      plugin.destroy();
-      expect(clearMock1).toHaveBeenCalledTimes(1);
-      expect(clearMock2).toHaveBeenCalledTimes(1);
-    });
-
-    it('should call cleanup functions in registration order', () => {
-      const callOrder: number[] = [];
-
-      const clearFunc1 = vi.fn(() => callOrder.push(1));
-      const clearFunc2 = vi.fn(() => callOrder.push(2));
-      const clearFunc3 = vi.fn(() => callOrder.push(3));
-
-      (plugin as any).registerCleanup(clearFunc1);
-      (plugin as any).registerCleanup(clearFunc2);
-      (plugin as any).registerCleanup(clearFunc3);
-
-      plugin.destroy();
-
-      expect(callOrder).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('registerClears method', () => {
-    it('should register multiple cleanup functions at once', () => {
-      (plugin as any).registerMultipleCleanups(clearMock1, clearMock2, clearMock3);
-
-      plugin.destroy();
-
-      expect(clearMock1).toHaveBeenCalledTimes(1);
-      expect(clearMock2).toHaveBeenCalledTimes(1);
-      expect(clearMock3).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle empty array', () => {
-      expect(() => (plugin as any).registerMultipleCleanups()).not.toThrow();
-      expect(() => plugin.destroy()).not.toThrow();
-    });
-
-    it('should maintain order when registering multiple at once', () => {
-      const callOrder: number[] = [];
-
-      const clearFunc1 = vi.fn(() => callOrder.push(1));
-      const clearFunc2 = vi.fn(() => callOrder.push(2));
-      const clearFunc3 = vi.fn(() => callOrder.push(3));
-
-      (plugin as any).registerMultipleCleanups(clearFunc1, clearFunc2, clearFunc3);
-
-      plugin.destroy();
-
-      expect(callOrder).toEqual([1, 2, 3]);
-    });
-  });
-
-  describe('destroy method', () => {
-    it('should call all registered cleanup functions', () => {
-      (plugin as any).registerCleanup(clearMock1);
-      (plugin as any).registerCleanup(clearMock2);
-
-      plugin.destroy();
-
-      expect(clearMock1).toHaveBeenCalledTimes(1);
-      expect(clearMock2).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle cleanup functions that throw errors gracefully', () => {
-      const errorCleanup = vi.fn(() => {
-        throw new Error('Cleanup error');
-      });
-
-      (plugin as any).registerCleanup(errorCleanup);
-      (plugin as any).registerCleanup(clearMock1);
-
-      // Should not throw even if one cleanup throws
-      expect(() => plugin.destroy()).toThrow('Cleanup error');
-
-      // But should still call subsequent cleanups
-      expect(errorCleanup).toHaveBeenCalledTimes(1);
-      // Note: clearMock1 might not be called due to the error, which is expected behavior
-    });
-
-    it('should be safe to call multiple times', () => {
-      (plugin as any).registerCleanup(clearMock1);
-
-      plugin.destroy();
-      plugin.destroy(); // Second call
-
-      // Should only be called once
-      expect(clearMock1).toHaveBeenCalledTimes(2);
-    });
-
-    it('should work with no registered cleanups', () => {
-      expect(() => plugin.destroy()).not.toThrow();
-    });
-  });
-
-  describe('EventEmitter functionality', () => {
-    it('should support event emission and listening', () => {
-      const eventHandler = vi.fn();
-
-      plugin.on('test-event', eventHandler);
-      plugin.emit('test-event', 'test data');
-
-      expect(eventHandler).toHaveBeenCalledWith('test data');
-    });
-
-    it('should support event removal', () => {
-      const eventHandler = vi.fn();
-
-      plugin.on('test-event', eventHandler);
-      plugin.off('test-event', eventHandler);
-      plugin.emit('test-event', 'test data');
-
-      expect(eventHandler).not.toHaveBeenCalled();
-    });
-
-    it('should support once listeners', () => {
-      const eventHandler = vi.fn();
-
-      plugin.once('test-event', eventHandler);
-      plugin.emit('test-event', 'test data');
-      plugin.emit('test-event', 'test data 2');
-
-      expect(eventHandler).toHaveBeenCalledTimes(1);
-      expect(eventHandler).toHaveBeenCalledWith('test data');
-    });
-  });
-
-  describe('Real-world usage patterns', () => {
-    class RealWorldPlugin extends KernelPlugin {
-      private intervalId?: NodeJS.Timeout;
-      private eventListeners: Array<() => void> = [];
-
-      public startPolling() {
-        this.intervalId = setInterval(() => {
-          this.emit('poll', Date.now());
-        }, 100);
-
-        this.register(() => {
-          if (this.intervalId) {
-            clearInterval(this.intervalId);
-            this.intervalId = undefined;
-          }
-        });
-      }
-
-      public addEventListener(element: HTMLElement, event: string, handler: EventListener) {
-        element.addEventListener(event, handler);
-
-        const cleanup = () => element.removeEventListener(event, handler);
-        this.eventListeners.push(cleanup);
-        this.register(cleanup);
-      }
-
-      public registerMultipleResources() {
-        // Simulate registering multiple resources
-        const resource1 = vi.fn();
-        const resource2 = vi.fn();
-        const resource3 = vi.fn();
-
-        this.registerClears(resource1, resource2, resource3);
-      }
-    }
-
-    it('should properly clean up intervals', () => {
-      const realPlugin = new RealWorldPlugin();
-      const pollHandler = vi.fn();
-
-      realPlugin.on('poll', pollHandler);
-      realPlugin.startPolling();
-
-      // Let it run for a bit
-      return new Promise((resolve) => {
-        setTimeout(() => {
-          realPlugin.destroy();
-
-          // Give it time to ensure no more events
-          setTimeout(() => {
-            const callCount = pollHandler.mock.calls.length;
-
-            // Wait a bit more to ensure no additional calls
-            setTimeout(() => {
-              expect(pollHandler.mock.calls.length).toBe(callCount);
-              resolve(undefined);
-            }, 150);
-          }, 50);
-        }, 150);
-      });
-    });
-
-    it('should properly clean up event listeners', () => {
-      const realPlugin = new RealWorldPlugin();
-      const element = document.createElement('div');
-      const handler = vi.fn();
-
-      realPlugin.addEventListener(element, 'click', handler);
-
-      // Trigger event before cleanup
-      element.click();
-      expect(handler).toHaveBeenCalledTimes(1);
-
-      // Cleanup
-      realPlugin.destroy();
-
-      // Event should not trigger after cleanup
-      element.click();
-      expect(handler).toHaveBeenCalledTimes(1);
-    });
-
-    it('should handle complex cleanup scenarios', () => {
-      const realPlugin = new RealWorldPlugin();
-      const mockCleanups = [vi.fn(), vi.fn(), vi.fn()];
-
-      realPlugin.registerMultipleResources();
-
-      realPlugin.destroy();
-
-      // All cleanup functions should have been called
-      // Note: We can't directly test the mocked cleanups from registerMultipleResources
-      // but we can verify the pattern works
-      expect(() => realPlugin.destroy()).not.toThrow();
-    });
-  });
-});

package/editor/src/editor-kernel/__tests__/utils.test.ts

@@ -1,197 +0,0 @@
-import { describe, expect, it, beforeEach, vi } from 'vitest';
-import type { Mock } from 'vitest';
-
-vi.mock('lexical', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('lexical')>();
-  return {
-    ...actual,
-    $getNodeByKey: vi.fn(),
-  };
-});
-
-import {
-  $getNearestNodeFromDOMNode,
-  $getNodeFromDOMNode,
-  DOM_DOCUMENT_FRAGMENT_TYPE,
-  DOM_DOCUMENT_TYPE,
-  DOM_ELEMENT_TYPE,
-  DOM_TEXT_TYPE,
-  assert,
-  compareNodeOrder,
-  createEmptyEditorState,
-  genServiceId,
-  getKernelFromEditor,
-  getNodeKeyFromDOMNode,
-  getParentElement,
-  isDOMNode,
-  isDocumentFragment,
-  noop,
-} from '../utils';
-import { $getNodeByKey, createEditor } from 'lexical';
-
-const getNodeByKeyMock = $getNodeByKey as unknown as Mock;
-
-class MockNode {
-  parent: MockNode | null = null;
-  children: MockNode[] = [];
-  constructor(public readonly key: string) {}
-  addChild(child: MockNode) {
-    child.parent = this;
-    this.children.push(child);
-  }
-  getParent() {
-    return this.parent as unknown as import('lexical').LexicalNode | null;
-  }
-  getChildren() {
-    return this.children as unknown as import('lexical').LexicalNode[];
-  }
-}
-
-describe('editor kernel utils', () => {
-  beforeEach(() => {
-    getNodeByKeyMock.mockReset();
-  });
-
-  it('should expose DOM type constants', () => {
-    expect(DOM_ELEMENT_TYPE).toBe(1);
-    expect(DOM_TEXT_TYPE).toBe(3);
-    expect(DOM_DOCUMENT_TYPE).toBe(9);
-    expect(DOM_DOCUMENT_FRAGMENT_TYPE).toBe(11);
-  });
-
-  it('genServiceId should wrap value with service id marker', () => {
-    const service = genServiceId<'test'>('demo');
-    expect(service).toEqual({ __serviceId: 'demo' });
-  });
-
-  it('noop should do nothing', () => {
-    expect(noop()).toBeUndefined();
-  });
-
-  it('createEmptyEditorState should create an empty lexical state', () => {
-    const editorState = createEmptyEditorState();
-    expect(typeof editorState.read).toBe('function');
-    expect(editorState.isEmpty()).toBe(true);
-  });
-
-  it('assert should throw when condition is false', () => {
-    expect(() => assert(true, 'ok')).not.toThrow();
-    expect(() => assert(false, 'boom')).toThrowError('boom');
-  });
-
-  it('getNodeKeyFromDOMNode should read lexical key metadata', () => {
-    const editor = createEditor();
-    const dom = document.createElement('div');
-    const key = `__lexicalKey_${editor._key}`;
-    (dom as unknown as Record<string, unknown>)[key] = 'node-key';
-
-    expect(getNodeKeyFromDOMNode(dom, editor)).toBe('node-key');
-  });
-
-  it('getNodeKeyFromDOMNode should return undefined when key missing', () => {
-    const editor = createEditor();
-    const dom = document.createElement('div');
-
-    expect(getNodeKeyFromDOMNode(dom, editor)).toBeUndefined();
-  });
-
-  it('$getNodeFromDOMNode should return node when key is registered', () => {
-    const editor = createEditor();
-    const dom = document.createElement('div');
-    const key = `__lexicalKey_${editor._key}`;
-    const lexicalNode = { key: 'resolved' } as unknown as import('lexical').LexicalNode;
-
-    (dom as unknown as Record<string, unknown>)[key] = 'registered';
-    getNodeByKeyMock.mockReturnValueOnce(lexicalNode);
-
-    expect($getNodeFromDOMNode(dom, editor)).toBe(lexicalNode);
-    expect(getNodeByKeyMock).toHaveBeenCalledWith('registered', undefined);
-  });
-
-  it('$getNodeFromDOMNode should return null when key is missing', () => {
-    const editor = createEditor();
-    const dom = document.createElement('div');
-
-    expect($getNodeFromDOMNode(dom, editor)).toBeNull();
-    expect(getNodeByKeyMock).not.toHaveBeenCalled();
-  });
-
-  it('isDOMNode should detect DOM nodes correctly', () => {
-    expect(isDOMNode(document.createElement('div'))).toBe(true);
-    expect(isDOMNode('not-node')).toBe(false);
-  });
-
-  it('isDocumentFragment should detect fragments', () => {
-    const fragment = document.createDocumentFragment();
-    expect(isDocumentFragment(fragment)).toBe(true);
-    expect(isDocumentFragment(document.createElement('span'))).toBe(false);
-  });
-
-  it('getParentElement should unwrap document fragment host', () => {
-    const node = document.createElement('span');
-    const fragment = document.createDocumentFragment();
-    const host = document.createElement('div');
-
-    Object.defineProperty(node, 'parentElement', { value: fragment });
-    Object.defineProperty(fragment, 'host', { value: host, configurable: true });
-
-    expect(getParentElement(node)).toBe(host);
-  });
-
-  it('getParentElement should prefer assigned slot when available', () => {
-    const node = document.createElement('span');
-    const slot = document.createElement('div');
-
-    Object.defineProperty(node, 'assignedSlot', { value: slot, configurable: true });
-
-    expect(getParentElement(node)).toBe(slot);
-  });
-
-  it('$getNearestNodeFromDOMNode should find nearest registered node', () => {
-    const editor = createEditor();
-    const parent = document.createElement('div');
-    const child = document.createElement('span');
-    parent.appendChild(child);
-
-    const parentKey = `__lexicalKey_${editor._key}`;
-    (parent as unknown as Record<string, unknown>)[parentKey] = 'parent';
-
-    const lexicalNode = { key: 'parent' } as unknown as import('lexical').LexicalNode;
-    getNodeByKeyMock.mockImplementation((key) => (key === 'parent' ? lexicalNode : null));
-
-    expect($getNearestNodeFromDOMNode(child, editor)).toBe(lexicalNode);
-    expect(getNodeByKeyMock).toHaveBeenCalledTimes(1);
-    expect(getNodeByKeyMock).toHaveBeenCalledWith('parent', undefined);
-  });
-
-  it('getKernelFromEditor should read injected kernel', () => {
-    const kernel = { id: 'kernel' } as unknown as import('../../types').IEditorKernel;
-    const editorWithKernel = { _kernel: kernel } as unknown as import('lexical').LexicalEditor;
-    expect(getKernelFromEditor(editorWithKernel)).toBe(kernel);
-
-    const editorWithArgs = {
-      _createEditorArgs: { __kernel: kernel },
-    } as unknown as import('lexical').LexicalEditor;
-    expect(getKernelFromEditor(editorWithArgs)).toBe(kernel);
-  });
-
-  it('compareNodeOrder should handle identical nodes and hierarchy', () => {
-    const root = new MockNode('root');
-    const childA = new MockNode('a');
-    const childB = new MockNode('b');
-    const grandChild = new MockNode('c');
-
-    root.addChild(childA);
-    root.addChild(childB);
-    childA.addChild(grandChild);
-
-    const lexicalChildA = childA as unknown as import('lexical').LexicalNode;
-    const lexicalChildB = childB as unknown as import('lexical').LexicalNode;
-    const lexicalGrandChild = grandChild as unknown as import('lexical').LexicalNode;
-
-    expect(compareNodeOrder(lexicalChildA, lexicalChildA)).toBe(0);
-    expect(compareNodeOrder(lexicalChildA, lexicalChildB)).toBeLessThan(0);
-    expect(compareNodeOrder(lexicalChildB, lexicalChildA)).toBeGreaterThan(0);
-    expect(compareNodeOrder(lexicalGrandChild, lexicalChildA)).toBeGreaterThan(0);
-  });
-});

package/editor/src/editor-kernel/data-source.ts

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable unused-imports/no-unused-vars */
-import { LexicalEditor } from 'lexical';
-
-export interface IWriteOptions {
-  // get selection data
-  selection?: boolean;
-}
-
-export default class DataSource {
-  constructor(protected dataType: string) {}
-
-  public get type() {
-    return this.dataType;
-  }
-
-  read(editor: LexicalEditor, data: any, options?: Record<string, unknown>) {}
-
-  write(editor: LexicalEditor, options?: IWriteOptions): any {
-    return null;
-  }
-}

package/editor/src/editor-kernel/event.ts

@@ -1,14 +0,0 @@
-import { LexicalEditor, createCommand } from 'lexical';
-
-export const HOVER_COMMAND = createCommand<MouseEvent>();
-
-export function registerEvent(editor: LexicalEditor, dom: HTMLElement) {
-  const hoverHandler = (event: MouseEvent) => {
-    editor.dispatchCommand(HOVER_COMMAND, event);
-  };
-  dom.addEventListener('mouseenter', hoverHandler);
-
-  return () => {
-    dom.removeEventListener('mouseenter', hoverHandler);
-  };
-}

package/editor/src/editor-kernel/index.ts

@@ -1,22 +0,0 @@
-import '../lexical-shim';
-import type { IEditor } from '../types';
-
-import { Kernel } from './kernel';
-
-export { default as DataSource } from './data-source';
-export * from './utils';
-
-/**
- * Editor object to create an instance of the editor
- */
-const Editor = {
-  createEditor(): IEditor {
-    return new Kernel();
-  },
-};
-
-export default Editor;
-
-export { HOVER_COMMAND } from './event';
-// export other utils from lexical
-export { resetRandomKey } from 'lexical';

package/editor/src/editor-kernel/inode/helper.ts

@@ -1,97 +0,0 @@
-import type { IElementNode } from './i-element-node';
-import type { INode } from './i-node';
-import type { IParagraphNode } from './paragraph-node';
-import type { IRootNode } from './root-node';
-import type { ITextNode } from './text-node';
-
-const BaseContent = {
-  direction: 'ltr',
-  format: '',
-  indent: 0,
-  type: '',
-  version: 1,
-};
-
-export const INodeHelper = {
-  appendChild(parent: IElementNode, ...child: INode[]): void {
-    if (!parent.children) {
-      parent.children = [];
-    }
-    parent.children.push(...child);
-  },
-
-  createElementNode(type: string, attrs: Record<string, unknown> = {}): IElementNode {
-    return {
-      ...BaseContent,
-      children: [],
-      ...attrs,
-      type,
-    } as IElementNode;
-  },
-
-  createLikeTextNode(type: string, text: string, attrs: Record<string, unknown> = {}): ITextNode {
-    return {
-      ...BaseContent,
-      detail: 0,
-      format: 0,
-      mode: 'normal',
-      style: '',
-      ...attrs,
-      text,
-      type: type,
-    };
-  },
-
-  createParagraph(attrs: Record<string, unknown> = {}): IParagraphNode {
-    return {
-      ...BaseContent,
-      children: [],
-      textFormat: 0,
-      textStyle: '',
-      ...attrs,
-      type: 'paragraph',
-    } as IParagraphNode;
-  },
-
-  createRootNode(attrs: Record<string, unknown> = {}): IRootNode {
-    return {
-      ...BaseContent,
-      ...attrs,
-      children: [],
-      type: 'root',
-    } as IRootNode;
-  },
-
-  createTextNode(text: string, attrs: Record<string, unknown> = {}): ITextNode {
-    return {
-      ...BaseContent,
-      detail: 0,
-      format: 0,
-      mode: 'normal',
-      style: '',
-      ...attrs,
-      text,
-      type: 'text',
-    };
-  },
-
-  createTypeNode(type: string, attrs: Record<string, unknown> = {}): INode {
-    return {
-      ...BaseContent,
-      ...attrs,
-      type,
-    } as INode;
-  },
-
-  isParagraphNode(node: INode): node is IParagraphNode {
-    return node.type === 'paragraph';
-  },
-
-  isRootNode(node: INode): node is IRootNode {
-    return node.type === 'root';
-  },
-
-  isTextNode(node: INode): node is ITextNode {
-    return node.type === 'text';
-  },
-};

package/editor/src/editor-kernel/inode/i-element-node.ts

@@ -1,3 +0,0 @@
-import { SerializedElementNode } from 'lexical';
-
-export type IElementNode = SerializedElementNode;

package/editor/src/editor-kernel/inode/i-node.ts

@@ -1,3 +0,0 @@
-import type { SerializedLexicalNode } from 'lexical';
-
-export type INode = SerializedLexicalNode;

package/editor/src/editor-kernel/inode/index.ts

@@ -1,5 +0,0 @@
-export * from './i-element-node';
-export * from './i-node';
-export * from './paragraph-node';
-export * from './root-node';
-export * from './text-node';

package/editor/src/editor-kernel/inode/paragraph-node.ts

@@ -1,7 +0,0 @@
-import { IElementNode } from './i-element-node';
-
-export interface IParagraphNode extends IElementNode {
-  textFormat: number;
-  textStyle: string;
-  type: 'paragraph';
-}

package/editor/src/editor-kernel/inode/root-node.ts

@@ -1,6 +0,0 @@
-import { SerializedRootNode } from 'lexical';
-
-/**
- * Root node
- */
-export type IRootNode = SerializedRootNode;

package/editor/src/editor-kernel/inode/text-node.ts

@@ -1,6 +0,0 @@
-import type { SerializedTextNode } from 'lexical';
-
-/**
- * Text node
- */
-export type ITextNode = SerializedTextNode;