@notectl/angular 0.0.2

package/README.md

@@ -0,0 +1,141 @@
+# @notectl/angular
+
+Angular adapter for NotectlEditor - a framework-agnostic rich text editor built on Web Components.
+
+## Installation
+
+```bash
+npm install @notectl/angular @notectl/core
+```
+
+## Usage
+
+### Import Module
+
+```typescript
+import { NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { NotectlEditorModule } from '@notectl/angular';
+import { AppComponent } from './app.component';
+
+@NgModule({
+  declarations: [AppComponent],
+  imports: [
+    BrowserModule,
+    NotectlEditorModule
+  ],
+  providers: [],
+  bootstrap: [AppComponent]
+})
+export class AppModule { }
+```
+
+### Component Usage
+
+```typescript
+import { Component } from '@angular/core';
+import type { EditorAPI } from '@notectl/core';
+
+@Component({
+  selector: 'app-root',
+  template: `
+    <notectl-editor
+      [content]="content"
+      [placeholder]="'Start writing...'"
+      [readOnly]="false"
+      (contentChange)="onContentChange($event)"
+      (ready)="onReady($event)"
+    ></notectl-editor>
+  `
+})
+export class AppComponent {
+  content = { type: 'doc', content: [] };
+
+  onContentChange(content: unknown): void {
+    console.log('Content changed:', content);
+  }
+
+  onReady(editor: EditorAPI): void {
+    console.log('Editor ready:', editor);
+  }
+}
+```
+
+### Reactive Forms Integration
+
+```typescript
+import { Component } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+
+@Component({
+  selector: 'app-editor-form',
+  template: `
+    <form [formGroup]="form">
+      <notectl-editor formControlName="content"></notectl-editor>
+    </form>
+  `
+})
+export class EditorFormComponent {
+  form = new FormGroup({
+    content: new FormControl(null)
+  });
+}
+```
+
+### Directive Usage
+
+```typescript
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-editor',
+  template: `
+    <div
+      notectl-editor
+      [content]="content"
+      (contentChange)="onContentChange($event)"
+    ></div>
+  `
+})
+export class EditorComponent {
+  content = { type: 'doc', content: [] };
+
+  onContentChange(content: unknown): void {
+    console.log('Content changed:', content);
+  }
+}
+```
+
+## API
+
+### Component Props
+
+- `debug?: boolean` - Enable debug mode
+- `content?: string | object` - Initial editor content
+- `placeholder?: string` - Placeholder text
+- `readOnly?: boolean` - Read-only mode
+- `accessibility?: object` - Accessibility configuration
+- `i18n?: object` - Internationalization settings
+- `theme?: object` - Theme configuration
+
+### Component Events
+
+- `contentChange: EventEmitter<unknown>` - Emitted when content changes
+- `selectionChange: EventEmitter<unknown>` - Emitted when selection changes
+- `editorFocus: EventEmitter<void>` - Emitted when editor gains focus
+- `editorBlur: EventEmitter<void>` - Emitted when editor loses focus
+- `ready: EventEmitter<EditorAPI>` - Emitted when editor is ready
+- `error: EventEmitter<Error>` - Emitted when an error occurs
+
+### Component Methods
+
+- `getContent(): unknown` - Get current content
+- `setContent(content: unknown): void` - Set content
+- `getState(): unknown` - Get editor state
+- `executeCommand(command: string, ...args: unknown[]): void` - Execute command
+- `registerPlugin(plugin: unknown): void` - Register a plugin
+- `unregisterPlugin(pluginId: string): void` - Unregister a plugin
+
+## License
+
+MIT

package/dist/README.md

@@ -0,0 +1,141 @@
+# @notectl/angular
+
+Angular adapter for NotectlEditor - a framework-agnostic rich text editor built on Web Components.
+
+## Installation
+
+```bash
+npm install @notectl/angular @notectl/core
+```
+
+## Usage
+
+### Import Module
+
+```typescript
+import { NgModule } from '@angular/core';
+import { BrowserModule } from '@angular/platform-browser';
+import { NotectlEditorModule } from '@notectl/angular';
+import { AppComponent } from './app.component';
+
+@NgModule({
+  declarations: [AppComponent],
+  imports: [
+    BrowserModule,
+    NotectlEditorModule
+  ],
+  providers: [],
+  bootstrap: [AppComponent]
+})
+export class AppModule { }
+```
+
+### Component Usage
+
+```typescript
+import { Component } from '@angular/core';
+import type { EditorAPI } from '@notectl/core';
+
+@Component({
+  selector: 'app-root',
+  template: `
+    <notectl-editor
+      [content]="content"
+      [placeholder]="'Start writing...'"
+      [readOnly]="false"
+      (contentChange)="onContentChange($event)"
+      (ready)="onReady($event)"
+    ></notectl-editor>
+  `
+})
+export class AppComponent {
+  content = { type: 'doc', content: [] };
+
+  onContentChange(content: unknown): void {
+    console.log('Content changed:', content);
+  }
+
+  onReady(editor: EditorAPI): void {
+    console.log('Editor ready:', editor);
+  }
+}
+```
+
+### Reactive Forms Integration
+
+```typescript
+import { Component } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+
+@Component({
+  selector: 'app-editor-form',
+  template: `
+    <form [formGroup]="form">
+      <notectl-editor formControlName="content"></notectl-editor>
+    </form>
+  `
+})
+export class EditorFormComponent {
+  form = new FormGroup({
+    content: new FormControl(null)
+  });
+}
+```
+
+### Directive Usage
+
+```typescript
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-editor',
+  template: `
+    <div
+      notectl-editor
+      [content]="content"
+      (contentChange)="onContentChange($event)"
+    ></div>
+  `
+})
+export class EditorComponent {
+  content = { type: 'doc', content: [] };
+
+  onContentChange(content: unknown): void {
+    console.log('Content changed:', content);
+  }
+}
+```
+
+## API
+
+### Component Props
+
+- `debug?: boolean` - Enable debug mode
+- `content?: string | object` - Initial editor content
+- `placeholder?: string` - Placeholder text
+- `readOnly?: boolean` - Read-only mode
+- `accessibility?: object` - Accessibility configuration
+- `i18n?: object` - Internationalization settings
+- `theme?: object` - Theme configuration
+
+### Component Events
+
+- `contentChange: EventEmitter<unknown>` - Emitted when content changes
+- `selectionChange: EventEmitter<unknown>` - Emitted when selection changes
+- `editorFocus: EventEmitter<void>` - Emitted when editor gains focus
+- `editorBlur: EventEmitter<void>` - Emitted when editor loses focus
+- `ready: EventEmitter<EditorAPI>` - Emitted when editor is ready
+- `error: EventEmitter<Error>` - Emitted when an error occurs
+
+### Component Methods
+
+- `getContent(): unknown` - Get current content
+- `setContent(content: unknown): void` - Set content
+- `getState(): unknown` - Get editor state
+- `executeCommand(command: string, ...args: unknown[]): void` - Execute command
+- `registerPlugin(plugin: unknown): void` - Register a plugin
+- `unregisterPlugin(pluginId: string): void` - Unregister a plugin
+
+## License
+
+MIT

package/dist/esm2022/index.mjs

@@ -0,0 +1,6 @@
+/**
+ * @notectl/angular - Angular adapter for NotectlEditor
+ * @packageDocumentation
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBub3RlY3RsL2FuZ3VsYXIgLSBBbmd1bGFyIGFkYXB0ZXIgZm9yIE5vdGVjdGxFZGl0b3JcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/dist/esm2022/lib/notectl-editor.component.mjs

@@ -0,0 +1,244 @@
+/**
+ * Angular component wrapper for NotectlEditor
+ */
+import { Component, EventEmitter, Input, Output, ViewChild, ViewEncapsulation, forwardRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * NotectlEditor Angular component
+ */
+export class NotectlEditorComponent {
+    containerRef;
+    /** Debug mode */
+    debug;
+    /** Initial content */
+    content;
+    /** Placeholder text */
+    placeholder;
+    /** Read-only mode */
+    readOnly;
+    /** Accessibility configuration */
+    accessibility;
+    /** Internationalization configuration */
+    i18n;
+    /** Theme configuration */
+    theme;
+    /** Custom class name */
+    className;
+    /** Emitted when content changes */
+    contentChange = new EventEmitter();
+    /** Emitted when selection changes */
+    selectionChange = new EventEmitter();
+    /** Emitted when editor gains focus */
+    editorFocus = new EventEmitter();
+    /** Emitted when editor loses focus */
+    editorBlur = new EventEmitter();
+    /** Emitted when editor is ready */
+    ready = new EventEmitter();
+    /** Emitted when an error occurs */
+    error = new EventEmitter();
+    editor = null;
+    onChange = () => { };
+    onTouched = () => { };
+    ngOnInit() {
+        this.initEditor();
+    }
+    ngOnDestroy() {
+        this.destroyEditor();
+    }
+    /**
+     * Initialize the editor instance
+     */
+    initEditor() {
+        if (!this.containerRef?.nativeElement) {
+            console.error('NotectlEditor: Container element not found');
+            return;
+        }
+        // Create editor instance
+        this.editor = document.createElement('notectl-editor');
+        // Configure editor
+        const config = {
+            debug: this.debug,
+            content: this.content,
+            placeholder: this.placeholder,
+            readOnly: this.readOnly,
+            accessibility: this.accessibility,
+            i18n: this.i18n,
+            theme: this.theme,
+        };
+        this.editor.configure(config);
+        // Attach event listeners
+        this.editor.on('content-change', (data) => {
+            const eventData = data;
+            const content = eventData.content;
+            this.contentChange.emit(content);
+            this.onChange(content);
+        });
+        this.editor.on('selection-change', (data) => {
+            const eventData = data;
+            this.selectionChange.emit(eventData.selection);
+        });
+        this.editor.on('focus', () => {
+            this.editorFocus.emit();
+            this.onTouched();
+        });
+        this.editor.on('blur', () => {
+            this.editorBlur.emit();
+        });
+        this.editor.on('ready', () => {
+            this.ready.emit(this.getEditorAPI());
+        });
+        this.editor.on('error', (data) => {
+            const eventData = data;
+            if (eventData.error) {
+                this.error.emit(eventData.error);
+            }
+        });
+        // Mount editor
+        this.containerRef.nativeElement.appendChild(this.editor);
+    }
+    /**
+     * Destroy the editor instance
+     */
+    destroyEditor() {
+        if (this.editor) {
+            this.editor.destroy();
+            if (this.containerRef?.nativeElement?.contains(this.editor)) {
+                this.containerRef.nativeElement.removeChild(this.editor);
+            }
+            this.editor = null;
+        }
+    }
+    /**
+     * Update editor configuration
+     */
+    updateConfig() {
+        if (!this.editor)
+            return;
+        const config = {
+            debug: this.debug,
+            content: this.content,
+            placeholder: this.placeholder,
+            readOnly: this.readOnly,
+            accessibility: this.accessibility,
+            i18n: this.i18n,
+            theme: this.theme,
+        };
+        this.editor.configure(config);
+    }
+    /**
+     * Get editor API
+     */
+    getEditorAPI() {
+        if (!this.editor) {
+            throw new Error('Editor not initialized');
+        }
+        return this.editor;
+    }
+    // ControlValueAccessor implementation
+    writeValue(value) {
+        if (this.editor && typeof value === 'string') {
+            this.editor.setContent(value);
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        if (this.editor) {
+            this.editor.configure({ readOnly: isDisabled });
+        }
+    }
+    // Public API methods
+    /**
+     * Get current editor content
+     */
+    getContent() {
+        return this.editor?.getContent();
+    }
+    /**
+     * Set editor content
+     */
+    setContent(content) {
+        if (this.editor && typeof content === 'string') {
+            this.editor.setContent(content);
+        }
+    }
+    /**
+     * Get current editor state
+     */
+    getState() {
+        return this.editor?.getState();
+    }
+    /**
+     * Execute an editor command
+     */
+    executeCommand(command, ...args) {
+        this.editor?.executeCommand(command, ...args);
+    }
+    /**
+     * Register a plugin
+     */
+    registerPlugin(plugin) {
+        this.editor?.registerPlugin(plugin);
+    }
+    /**
+     * Unregister a plugin
+     */
+    unregisterPlugin(pluginId) {
+        this.editor?.unregisterPlugin(pluginId);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotectlEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: NotectlEditorComponent, selector: "notectl-editor", inputs: { debug: "debug", content: "content", placeholder: "placeholder", readOnly: "readOnly", accessibility: "accessibility", i18n: "i18n", theme: "theme", className: "className" }, outputs: { contentChange: "contentChange", selectionChange: "selectionChange", editorFocus: "editorFocus", editorBlur: "editorBlur", ready: "ready", error: "error" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => NotectlEditorComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["container"], descendants: true, static: true }], ngImport: i0, template: '<div #container [attr.data-notectl-angular-wrapper]="true"></div>', isInline: true, styles: [":host{display:block}\n"], encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NotectlEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'notectl-editor', template: '<div #container [attr.data-notectl-angular-wrapper]="true"></div>', encapsulation: ViewEncapsulation.None, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => NotectlEditorComponent),
+                            multi: true,
+                        },
+                    ], styles: [":host{display:block}\n"] }]
+        }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['container', { static: true }]
+            }], debug: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], accessibility: [{
+                type: Input
+            }], i18n: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], contentChange: [{
+                type: Output
+            }], selectionChange: [{
+                type: Output
+            }], editorFocus: [{
+                type: Output
+            }], editorBlur: [{
+                type: Output
+            }], ready: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notectl-editor.component.js","sourceRoot":"","sources":["../../../src/lib/notectl-editor.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Angular component wrapper for NotectlEditor\n */\n\nimport {\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  ViewChild,\n  ViewEncapsulation,\n  forwardRef,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { NotectlEditor as NotectlEditorCore } from '@notectl/core';\nimport type { EditorConfig, EditorAPI } from '@notectl/core';\n\n/**\n * NotectlEditor Angular component\n */\n@Component({\n  selector: 'notectl-editor',\n  template: '<div #container [attr.data-notectl-angular-wrapper]=\"true\"></div>',\n  styles: [':host { display: block; }'],\n  encapsulation: ViewEncapsulation.None,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => NotectlEditorComponent),\n      multi: true,\n    },\n  ],\n})\nexport class NotectlEditorComponent implements OnInit, OnDestroy, ControlValueAccessor {\n  @ViewChild('container', { static: true }) containerRef!: ElementRef<HTMLDivElement>;\n\n  /** Debug mode */\n  @Input() debug?: boolean;\n\n  /** Initial content */\n  @Input() content?: string | object;\n\n  /** Placeholder text */\n  @Input() placeholder?: string;\n\n  /** Read-only mode */\n  @Input() readOnly?: boolean;\n\n  /** Accessibility configuration */\n  @Input() accessibility?: EditorConfig['accessibility'];\n\n  /** Internationalization configuration */\n  @Input() i18n?: EditorConfig['i18n'];\n\n  /** Theme configuration */\n  @Input() theme?: EditorConfig['theme'];\n\n  /** Custom class name */\n  @Input() className?: string;\n\n  /** Emitted when content changes */\n  @Output() contentChange = new EventEmitter<unknown>();\n\n  /** Emitted when selection changes */\n  @Output() selectionChange = new EventEmitter<unknown>();\n\n  /** Emitted when editor gains focus */\n  @Output() editorFocus = new EventEmitter<void>();\n\n  /** Emitted when editor loses focus */\n  @Output() editorBlur = new EventEmitter<void>();\n\n  /** Emitted when editor is ready */\n  @Output() ready = new EventEmitter<EditorAPI>();\n\n  /** Emitted when an error occurs */\n  @Output() error = new EventEmitter<Error>();\n\n  private editor: NotectlEditorCore | null = null;\n  private onChange: (value: unknown) => void = () => {};\n  private onTouched: () => void = () => {};\n\n  ngOnInit(): void {\n    this.initEditor();\n  }\n\n  ngOnDestroy(): void {\n    this.destroyEditor();\n  }\n\n  /**\n   * Initialize the editor instance\n   */\n  private initEditor(): void {\n    if (!this.containerRef?.nativeElement) {\n      console.error('NotectlEditor: Container element not found');\n      return;\n    }\n\n    // Create editor instance\n    this.editor = document.createElement('notectl-editor') as NotectlEditorCore;\n\n    // Configure editor\n    const config: EditorConfig = {\n      debug: this.debug,\n      content: this.content,\n      placeholder: this.placeholder,\n      readOnly: this.readOnly,\n      accessibility: this.accessibility,\n      i18n: this.i18n,\n      theme: this.theme,\n    };\n    this.editor.configure(config);\n\n    // Attach event listeners\n    this.editor.on('content-change', (data) => {\n      const eventData = data as { content?: unknown };\n      const content = eventData.content;\n      this.contentChange.emit(content);\n      this.onChange(content);\n    });\n\n    this.editor.on('selection-change', (data) => {\n      const eventData = data as { selection?: unknown };\n      this.selectionChange.emit(eventData.selection);\n    });\n\n    this.editor.on('focus', () => {\n      this.editorFocus.emit();\n      this.onTouched();\n    });\n\n    this.editor.on('blur', () => {\n      this.editorBlur.emit();\n    });\n\n    this.editor.on('ready', () => {\n      this.ready.emit(this.getEditorAPI());\n    });\n\n    this.editor.on('error', (data) => {\n      const eventData = data as { error?: Error };\n      if (eventData.error) {\n        this.error.emit(eventData.error);\n      }\n    });\n\n    // Mount editor\n    this.containerRef.nativeElement.appendChild(this.editor);\n  }\n\n  /**\n   * Destroy the editor instance\n   */\n  private destroyEditor(): void {\n    if (this.editor) {\n      this.editor.destroy();\n      if (this.containerRef?.nativeElement?.contains(this.editor)) {\n        this.containerRef.nativeElement.removeChild(this.editor);\n      }\n      this.editor = null;\n    }\n  }\n\n  /**\n   * Update editor configuration\n   */\n  private updateConfig(): void {\n    if (!this.editor) return;\n\n    const config: EditorConfig = {\n      debug: this.debug,\n      content: this.content,\n      placeholder: this.placeholder,\n      readOnly: this.readOnly,\n      accessibility: this.accessibility,\n      i18n: this.i18n,\n      theme: this.theme,\n    };\n    this.editor.configure(config);\n  }\n\n  /**\n   * Get editor API\n   */\n  private getEditorAPI(): EditorAPI {\n    if (!this.editor) {\n      throw new Error('Editor not initialized');\n    }\n    return this.editor as EditorAPI;\n  }\n\n  // ControlValueAccessor implementation\n  writeValue(value: unknown): void {\n    if (this.editor && typeof value === 'string') {\n      this.editor.setContent(value);\n    }\n  }\n\n  registerOnChange(fn: (value: unknown) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    if (this.editor) {\n      this.editor.configure({ readOnly: isDisabled });\n    }\n  }\n\n  // Public API methods\n  /**\n   * Get current editor content\n   */\n  public getContent(): unknown {\n    return this.editor?.getContent();\n  }\n\n  /**\n   * Set editor content\n   */\n  public setContent(content: unknown): void {\n    if (this.editor && typeof content === 'string') {\n      this.editor.setContent(content);\n    }\n  }\n\n  /**\n   * Get current editor state\n   */\n  public getState(): unknown {\n    return this.editor?.getState();\n  }\n\n  /**\n   * Execute an editor command\n   */\n  public executeCommand(command: string, ...args: unknown[]): void {\n    this.editor?.executeCommand(command, ...args);\n  }\n\n  /**\n   * Register a plugin\n   */\n  public registerPlugin(plugin: unknown): void {\n    this.editor?.registerPlugin(plugin as any);\n  }\n\n  /**\n   * Unregister a plugin\n   */\n  public unregisterPlugin(pluginId: string): void {\n    this.editor?.unregisterPlugin(pluginId);\n  }\n}\n"]}