@flogeez/angular-tiptap-editor 3.1.2 → 3.1.4

package/esm2022/lib/models/ate-editor-state.model.mjs

@@ -0,0 +1,90 @@
+export const ATE_INITIAL_EDITOR_STATE = {
+    isFocused: false,
+    isEditable: true,
+    selection: {
+        type: "none",
+        from: 0,
+        to: 0,
+        empty: true,
+        isSingleCell: false,
+    },
+    marks: {
+        bold: false,
+        italic: false,
+        underline: false,
+        strike: false,
+        code: false,
+        superscript: false,
+        subscript: false,
+        highlight: false,
+        link: false,
+        linkHref: null,
+        color: null,
+        computedColor: null,
+        background: null,
+        computedBackground: null,
+        linkOpenOnClick: false,
+    },
+    can: {
+        toggleBold: false,
+        toggleItalic: false,
+        toggleUnderline: false,
+        toggleStrike: false,
+        toggleCode: false,
+        toggleHighlight: false,
+        toggleLink: false,
+        toggleSuperscript: false,
+        toggleSubscript: false,
+        setColor: false,
+        setHighlight: false,
+        undo: false,
+        redo: false,
+        addRowBefore: false,
+        addRowAfter: false,
+        deleteRow: false,
+        addColumnBefore: false,
+        addColumnAfter: false,
+        deleteColumn: false,
+        deleteTable: false,
+        mergeCells: false,
+        splitCell: false,
+        toggleHeaderRow: false,
+        toggleHeaderColumn: false,
+        toggleHeading1: false,
+        toggleHeading2: false,
+        toggleHeading3: false,
+        toggleBulletList: false,
+        toggleOrderedList: false,
+        toggleBlockquote: false,
+        toggleCodeBlock: false,
+        setTextAlignLeft: false,
+        setTextAlignCenter: false,
+        setTextAlignRight: false,
+        setTextAlignJustify: false,
+        insertHorizontalRule: false,
+        insertTable: false,
+        insertImage: false,
+    },
+    nodes: {
+        isTable: false,
+        isTableNodeSelected: false,
+        isTableCell: false,
+        isImage: false,
+        isBlockquote: false,
+        isCodeBlock: false,
+        isBulletList: false,
+        isOrderedList: false,
+        h1: false,
+        h2: false,
+        h3: false,
+        alignLeft: false,
+        alignCenter: false,
+        alignRight: false,
+        alignJustify: false,
+        isTableHeaderRow: false,
+        isTableHeaderColumn: false,
+        activeNodeName: null,
+    },
+    custom: {},
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-editor-state.model.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/models/ate-editor-state.model.ts"],"names":[],"mappings":"AA4HA,MAAM,CAAC,MAAM,wBAAwB,GAA2B;IAC9D,SAAS,EAAE,KAAK;IAChB,UAAU,EAAE,IAAI;IAChB,SAAS,EAAE;QACT,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,CAAC;QACP,EAAE,EAAE,CAAC;QACL,KAAK,EAAE,IAAI;QACX,YAAY,EAAE,KAAK;KACpB;IACD,KAAK,EAAE;QACL,IAAI,EAAE,KAAK;QACX,MAAM,EAAE,KAAK;QACb,SAAS,EAAE,KAAK;QAChB,MAAM,EAAE,KAAK;QACb,IAAI,EAAE,KAAK;QACX,WAAW,EAAE,KAAK;QAClB,SAAS,EAAE,KAAK;QAChB,SAAS,EAAE,KAAK;QAChB,IAAI,EAAE,KAAK;QACX,QAAQ,EAAE,IAAI;QACd,KAAK,EAAE,IAAI;QACX,aAAa,EAAE,IAAI;QACnB,UAAU,EAAE,IAAI;QAChB,kBAAkB,EAAE,IAAI;QACxB,eAAe,EAAE,KAAK;KACvB;IACD,GAAG,EAAE;QACH,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,KAAK;QACnB,eAAe,EAAE,KAAK;QACtB,YAAY,EAAE,KAAK;QACnB,UAAU,EAAE,KAAK;QACjB,eAAe,EAAE,KAAK;QACtB,UAAU,EAAE,KAAK;QACjB,iBAAiB,EAAE,KAAK;QACxB,eAAe,EAAE,KAAK;QACtB,QAAQ,EAAE,KAAK;QACf,YAAY,EAAE,KAAK;QACnB,IAAI,EAAE,KAAK;QACX,IAAI,EAAE,KAAK;QACX,YAAY,EAAE,KAAK;QACnB,WAAW,EAAE,KAAK;QAClB,SAAS,EAAE,KAAK;QAChB,eAAe,EAAE,KAAK;QACtB,cAAc,EAAE,KAAK;QACrB,YAAY,EAAE,KAAK;QACnB,WAAW,EAAE,KAAK;QAClB,UAAU,EAAE,KAAK;QACjB,SAAS,EAAE,KAAK;QAChB,eAAe,EAAE,KAAK;QACtB,kBAAkB,EAAE,KAAK;QACzB,cAAc,EAAE,KAAK;QACrB,cAAc,EAAE,KAAK;QACrB,cAAc,EAAE,KAAK;QACrB,gBAAgB,EAAE,KAAK;QACvB,iBAAiB,EAAE,KAAK;QACxB,gBAAgB,EAAE,KAAK;QACvB,eAAe,EAAE,KAAK;QACtB,gBAAgB,EAAE,KAAK;QACvB,kBAAkB,EAAE,KAAK;QACzB,iBAAiB,EAAE,KAAK;QACxB,mBAAmB,EAAE,KAAK;QAC1B,oBAAoB,EAAE,KAAK;QAC3B,WAAW,EAAE,KAAK;QAClB,WAAW,EAAE,KAAK;KACnB;IACD,KAAK,EAAE;QACL,OAAO,EAAE,KAAK;QACd,mBAAmB,EAAE,KAAK;QAC1B,WAAW,EAAE,KAAK;QAClB,OAAO,EAAE,KAAK;QACd,YAAY,EAAE,KAAK;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,KAAK;QACnB,aAAa,EAAE,KAAK;QACpB,EAAE,EAAE,KAAK;QACT,EAAE,EAAE,KAAK;QACT,EAAE,EAAE,KAAK;QACT,SAAS,EAAE,KAAK;QAChB,WAAW,EAAE,KAAK;QAClB,UAAU,EAAE,KAAK;QACjB,YAAY,EAAE,KAAK;QACnB,gBAAgB,EAAE,KAAK;QACvB,mBAAmB,EAAE,KAAK;QAC1B,cAAc,EAAE,IAAI;KACrB;IACD,MAAM,EAAE,EAAE;CACX,CAAC","sourcesContent":["import { Editor } from \"@tiptap/core\";\n\nexport type AteStateCalculator = (editor: Editor) => Partial<{\n  [K in keyof AteEditorStateSnapshot]: AteEditorStateSnapshot[K] extends object\n    ? Partial<AteEditorStateSnapshot[K]>\n    : AteEditorStateSnapshot[K];\n}>;\n\nexport interface AteEditorStateSnapshot {\n  /** Global editor states */\n  isFocused: boolean;\n  isEditable: boolean;\n\n  /**\n   * Detailed selection information to avoid overlap between menus\n   */\n  selection: {\n    type: \"text\" | \"node\" | \"cell\" | \"none\";\n    from: number;\n    to: number;\n    empty: boolean;\n    /** Specific for CellSelection */\n    isSingleCell: boolean;\n  };\n\n  /** Text formatting states (Marks) */\n  marks: {\n    bold: boolean;\n    italic: boolean;\n    underline: boolean;\n    strike: boolean;\n    code: boolean;\n    superscript: boolean;\n    subscript: boolean;\n    highlight: boolean;\n    link: boolean;\n    linkHref: string | null;\n    color: string | null;\n    computedColor: string | null;\n    background: string | null;\n    computedBackground: string | null;\n    linkOpenOnClick: boolean;\n  };\n\n  /** Capability states (canExecute) */\n  can: {\n    toggleBold: boolean;\n    toggleItalic: boolean;\n    toggleUnderline: boolean;\n    toggleStrike: boolean;\n    toggleCode: boolean;\n    toggleHighlight: boolean;\n    toggleLink: boolean;\n    toggleSuperscript: boolean;\n    toggleSubscript: boolean;\n    setColor: boolean;\n    setHighlight: boolean;\n    undo: boolean;\n    redo: boolean;\n\n    /** Table specific capabilities */\n    addRowBefore: boolean;\n    addRowAfter: boolean;\n    deleteRow: boolean;\n    addColumnBefore: boolean;\n    addColumnAfter: boolean;\n    deleteColumn: boolean;\n    deleteTable: boolean;\n    mergeCells: boolean;\n    splitCell: boolean;\n    toggleHeaderRow: boolean;\n    toggleHeaderColumn: boolean;\n\n    /** Structure/Node capabilities */\n    toggleHeading1: boolean;\n    toggleHeading2: boolean;\n    toggleHeading3: boolean;\n    toggleBulletList: boolean;\n    toggleOrderedList: boolean;\n    toggleBlockquote: boolean;\n    toggleCodeBlock: boolean;\n    setTextAlignLeft: boolean;\n    setTextAlignCenter: boolean;\n    setTextAlignRight: boolean;\n    setTextAlignJustify: boolean;\n    insertHorizontalRule: boolean;\n    insertTable: boolean;\n    insertImage: boolean;\n  };\n\n  /** Current node context */\n  nodes: {\n    isTable: boolean;\n    isTableNodeSelected: boolean;\n    isTableCell: boolean;\n    isImage: boolean;\n    isBlockquote: boolean;\n    isCodeBlock: boolean;\n    isBulletList: boolean;\n    isOrderedList: boolean;\n\n    /** Headings */\n    h1: boolean;\n    h2: boolean;\n    h3: boolean;\n\n    /** Alignment */\n    alignLeft: boolean;\n    alignCenter: boolean;\n    alignRight: boolean;\n    alignJustify: boolean;\n\n    /** Table specific */\n    isTableHeaderRow: boolean;\n    isTableHeaderColumn: boolean;\n\n    /** Name of the active node at selection head */\n    activeNodeName: string | null;\n  };\n\n  /** Placeholder for custom extension states */\n  custom: Record<string, unknown>;\n}\n\nexport const ATE_INITIAL_EDITOR_STATE: AteEditorStateSnapshot = {\n  isFocused: false,\n  isEditable: true,\n  selection: {\n    type: \"none\",\n    from: 0,\n    to: 0,\n    empty: true,\n    isSingleCell: false,\n  },\n  marks: {\n    bold: false,\n    italic: false,\n    underline: false,\n    strike: false,\n    code: false,\n    superscript: false,\n    subscript: false,\n    highlight: false,\n    link: false,\n    linkHref: null,\n    color: null,\n    computedColor: null,\n    background: null,\n    computedBackground: null,\n    linkOpenOnClick: false,\n  },\n  can: {\n    toggleBold: false,\n    toggleItalic: false,\n    toggleUnderline: false,\n    toggleStrike: false,\n    toggleCode: false,\n    toggleHighlight: false,\n    toggleLink: false,\n    toggleSuperscript: false,\n    toggleSubscript: false,\n    setColor: false,\n    setHighlight: false,\n    undo: false,\n    redo: false,\n    addRowBefore: false,\n    addRowAfter: false,\n    deleteRow: false,\n    addColumnBefore: false,\n    addColumnAfter: false,\n    deleteColumn: false,\n    deleteTable: false,\n    mergeCells: false,\n    splitCell: false,\n    toggleHeaderRow: false,\n    toggleHeaderColumn: false,\n    toggleHeading1: false,\n    toggleHeading2: false,\n    toggleHeading3: false,\n    toggleBulletList: false,\n    toggleOrderedList: false,\n    toggleBlockquote: false,\n    toggleCodeBlock: false,\n    setTextAlignLeft: false,\n    setTextAlignCenter: false,\n    setTextAlignRight: false,\n    setTextAlignJustify: false,\n    insertHorizontalRule: false,\n    insertTable: false,\n    insertImage: false,\n  },\n  nodes: {\n    isTable: false,\n    isTableNodeSelected: false,\n    isTableCell: false,\n    isImage: false,\n    isBlockquote: false,\n    isCodeBlock: false,\n    isBulletList: false,\n    isOrderedList: false,\n    h1: false,\n    h2: false,\n    h3: false,\n    alignLeft: false,\n    alignCenter: false,\n    alignRight: false,\n    alignJustify: false,\n    isTableHeaderRow: false,\n    isTableHeaderColumn: false,\n    activeNodeName: null,\n  },\n  custom: {},\n};\n"]}

package/esm2022/lib/models/ate-image.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/models/ate-slash-command.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRlLXNsYXNoLWNvbW1hbmQubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRpcHRhcC1lZGl0b3Ivc3JjL2xpYi9tb2RlbHMvYXRlLXNsYXNoLWNvbW1hbmQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVkaXRvciB9IGZyb20gXCJAdGlwdGFwL2NvcmVcIjtcblxuLyoqXG4gKiBJbnRlcmZhY2UgcmVwcmVzZW50aW5nIGEgc2luZ2xlIGl0ZW0gaW4gdGhlIHNsYXNoIGNvbW1hbmRzIG1lbnUuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQXRlU2xhc2hDb21tYW5kSXRlbSB7XG4gIHRpdGxlOiBzdHJpbmc7XG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XG4gIGljb246IHN0cmluZztcbiAga2V5d29yZHM6IHN0cmluZ1tdO1xuICBjb21tYW5kOiAoZWRpdG9yOiBFZGl0b3IpID0+IHZvaWQ7XG59XG5cbi8qKlxuICogQ3VzdG9tIHNsYXNoIGNvbW1hbmRzIGNvbmZpZ3VyYXRpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQXRlQ3VzdG9tU2xhc2hDb21tYW5kcyB7XG4gIGNvbW1hbmRzPzogQXRlU2xhc2hDb21tYW5kSXRlbVtdO1xufVxuIl19

package/esm2022/lib/models/ate-toolbar.model.mjs

@@ -0,0 +1,35 @@
+/**
+ * Clés des boutons de la barre d'outils native
+ */
+export const ATE_TOOLBAR_KEYS = [
+    "bold",
+    "italic",
+    "underline",
+    "strike",
+    "code",
+    "codeBlock",
+    "superscript",
+    "subscript",
+    "highlight",
+    "highlightPicker",
+    "heading1",
+    "heading2",
+    "heading3",
+    "bulletList",
+    "orderedList",
+    "blockquote",
+    "alignLeft",
+    "alignCenter",
+    "alignRight",
+    "alignJustify",
+    "link",
+    "image",
+    "horizontalRule",
+    "table",
+    "undo",
+    "redo",
+    "clear",
+    "textColor",
+    "separator",
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/node-view/ate-angular-node-view.mjs

@@ -0,0 +1,97 @@
+import { Directive, signal } from "@angular/core";
+import * as i0 from "@angular/core";
+/**
+ * Base abstract class for custom 'Angular Nodes'.
+ *
+ * Extend this class in your custom components to automatically receive TipTap editor
+ * properties (node attributes, selection state, etc.) as reactive Signals.
+ *
+ * @example
+ * ```typescript
+ * @Component({
+ *   selector: 'app-counter',
+ *   template: `
+ *     <div>
+ *       <button (click)="increment()">Count: {{ node().attrs['count'] }}</button>
+ *     </div>
+ *   `
+ * })
+ * export class CounterComponent extends AteAngularNodeView {
+ *   increment() {
+ *     const count = this.node().attrs['count'] || 0;
+ *     this.updateAttributes({ count: count + 1 });
+ *   }
+ * }
+ * ```
+ */
+export class AteAngularNodeView {
+    /**
+     * Internal method to initialize the component with NodeView props.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _initNodeView(props) {
+        // Create signals from the props
+        const editorSignal = signal(props.editor);
+        const nodeSignal = signal(props.node);
+        const decorationsSignal = signal(props.decorations);
+        const selectedSignal = signal(props.selected);
+        const extensionSignal = signal(props.extension);
+        // Assign to the component
+        this.editor = editorSignal.asReadonly();
+        this.node = nodeSignal.asReadonly();
+        this.decorations = decorationsSignal.asReadonly();
+        this.selected = selectedSignal.asReadonly();
+        this.extension = extensionSignal.asReadonly();
+        this.getPos = props.getPos;
+        this.updateAttributes = props.updateAttributes;
+        this.deleteNode = props.deleteNode;
+        // Store writable signals for updates
+        this._writableSignals = {
+            node: nodeSignal,
+            decorations: decorationsSignal,
+            selected: selectedSignal,
+        };
+    }
+    /**
+     * Internal method to update the component when the node changes.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _updateNodeView(node, decorations) {
+        if (this._writableSignals) {
+            this._writableSignals.node.set(node);
+            this._writableSignals.decorations.set(decorations);
+        }
+    }
+    /**
+     * Internal method to update the selection state.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _selectNodeView() {
+        if (this._writableSignals) {
+            this._writableSignals.selected.set(true);
+        }
+    }
+    /**
+     * Internal method to update the deselection state.
+     * This is called by the AngularNodeViewRenderer.
+     *
+     * @internal
+     */
+    _deselectNodeView() {
+        if (this._writableSignals) {
+            this._writableSignals.selected.set(false);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteAngularNodeView, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: AteAngularNodeView, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: AteAngularNodeView, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-angular-node-view.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/node-view/ate-angular-node-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAA0B,MAAM,eAAe,CAAC;;AAmB1E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,OAAgB,kBAAkB;IAuDtC;;;;;OAKG;IACH,aAAa,CAAC,KAA8B;QAC1C,gCAAgC;QAChC,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC1C,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACtC,MAAM,iBAAiB,GAAG,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACpD,MAAM,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC9C,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAEhD,0BAA0B;QAC1B,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,UAAU,EAAE,CAAC;QACxC,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,UAAU,EAAE,CAAC;QACpC,IAAI,CAAC,WAAW,GAAG,iBAAiB,CAAC,UAAU,EAAE,CAAC;QAClD,IAAI,CAAC,QAAQ,GAAG,cAAc,CAAC,UAAU,EAAE,CAAC;QAC5C,IAAI,CAAC,SAAS,GAAG,eAAe,CAAC,UAAU,EAAE,CAAC;QAC9C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC;QAC/C,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAEnC,qCAAqC;QACrC,IAAI,CAAC,gBAAgB,GAAG;YACtB,IAAI,EAAE,UAAU;YAChB,WAAW,EAAE,iBAAiB;YAC9B,QAAQ,EAAE,cAAc;SACzB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,IAAqB,EAAE,WAAkC;QACvE,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACrC,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,eAAe;QACb,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,iBAAiB;QACf,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAC5C,CAAC;IACH,CAAC;+GA1HmB,kBAAkB;mGAAlB,kBAAkB;;4FAAlB,kBAAkB;kBADvC,SAAS","sourcesContent":["import { Directive, signal, Signal, WritableSignal } from \"@angular/core\";\nimport { Node as ProseMirrorNode } from \"@tiptap/pm/model\";\nimport { Decoration } from \"@tiptap/pm/view\";\nimport { Editor } from \"@tiptap/core\";\n\n/**\n * Props that are injected into Angular NodeView components\n */\nexport interface AteAngularNodeViewProps {\n  editor: Editor;\n  node: ProseMirrorNode;\n  decorations: readonly Decoration[];\n  selected: boolean;\n  extension: unknown;\n  getPos: () => number | undefined;\n  updateAttributes: (attrs: Record<string, unknown>) => void;\n  deleteNode: () => void;\n}\n\n/**\n * Base abstract class for custom 'Angular Nodes'.\n *\n * Extend this class in your custom components to automatically receive TipTap editor\n * properties (node attributes, selection state, etc.) as reactive Signals.\n *\n * @example\n * ```typescript\n * @Component({\n *   selector: 'app-counter',\n *   template: `\n *     <div>\n *       <button (click)=\"increment()\">Count: {{ node().attrs['count'] }}</button>\n *     </div>\n *   `\n * })\n * export class CounterComponent extends AteAngularNodeView {\n *   increment() {\n *     const count = this.node().attrs['count'] || 0;\n *     this.updateAttributes({ count: count + 1 });\n *   }\n * }\n * ```\n */\n@Directive()\nexport abstract class AteAngularNodeView {\n  /**\n   * The TipTap editor instance\n   */\n  public editor!: Signal<Editor>;\n\n  /**\n   * The ProseMirror node\n   */\n  public node!: Signal<ProseMirrorNode>;\n\n  /**\n   * Decorations applied to this node\n   */\n  public decorations!: Signal<readonly Decoration[]>;\n\n  /**\n   * Whether the node is currently selected\n   */\n  public selected!: Signal<boolean>;\n\n  /**\n   * The extension instance that created this node\n   */\n  public extension!: Signal<unknown>;\n\n  /**\n   * Function to get the current position of this node in the document\n   */\n  public getPos!: () => number | undefined;\n\n  /**\n   * Update the attributes of this node\n   *\n   * @param attrs - Partial attributes to update\n   *\n   * @example\n   * ```typescript\n   * this.updateAttributes({ count: 5, color: 'blue' });\n   * ```\n   */\n  public updateAttributes!: (attrs: Record<string, unknown>) => void;\n\n  /**\n   * Delete this node from the document\n   */\n  public deleteNode!: () => void;\n\n  /** @internal */\n  private _writableSignals?: {\n    node: WritableSignal<ProseMirrorNode>;\n    decorations: WritableSignal<readonly Decoration[]>;\n    selected: WritableSignal<boolean>;\n  };\n\n  /**\n   * Internal method to initialize the component with NodeView props.\n   * This is called by the AngularNodeViewRenderer.\n   *\n   * @internal\n   */\n  _initNodeView(props: AteAngularNodeViewProps): void {\n    // Create signals from the props\n    const editorSignal = signal(props.editor);\n    const nodeSignal = signal(props.node);\n    const decorationsSignal = signal(props.decorations);\n    const selectedSignal = signal(props.selected);\n    const extensionSignal = signal(props.extension);\n\n    // Assign to the component\n    this.editor = editorSignal.asReadonly();\n    this.node = nodeSignal.asReadonly();\n    this.decorations = decorationsSignal.asReadonly();\n    this.selected = selectedSignal.asReadonly();\n    this.extension = extensionSignal.asReadonly();\n    this.getPos = props.getPos;\n    this.updateAttributes = props.updateAttributes;\n    this.deleteNode = props.deleteNode;\n\n    // Store writable signals for updates\n    this._writableSignals = {\n      node: nodeSignal,\n      decorations: decorationsSignal,\n      selected: selectedSignal,\n    };\n  }\n\n  /**\n   * Internal method to update the component when the node changes.\n   * This is called by the AngularNodeViewRenderer.\n   *\n   * @internal\n   */\n  _updateNodeView(node: ProseMirrorNode, decorations: readonly Decoration[]): void {\n    if (this._writableSignals) {\n      this._writableSignals.node.set(node);\n      this._writableSignals.decorations.set(decorations);\n    }\n  }\n\n  /**\n   * Internal method to update the selection state.\n   * This is called by the AngularNodeViewRenderer.\n   *\n   * @internal\n   */\n  _selectNodeView(): void {\n    if (this._writableSignals) {\n      this._writableSignals.selected.set(true);\n    }\n  }\n\n  /**\n   * Internal method to update the deselection state.\n   * This is called by the AngularNodeViewRenderer.\n   *\n   * @internal\n   */\n  _deselectNodeView(): void {\n    if (this._writableSignals) {\n      this._writableSignals.selected.set(false);\n    }\n  }\n}\n"]}

package/esm2022/lib/node-view/ate-injector.registry.mjs

@@ -0,0 +1,16 @@
+/**
+ * Internal registry to store the root injector for the editor.
+ * This allows registerAngularComponent to work without explicitly passing the injector.
+ * @internal
+ */
+let globalInjector = null;
+export function setGlobalInjector(injector) {
+    globalInjector = injector;
+}
+export function getGlobalInjector() {
+    if (!globalInjector) {
+        throw new Error("[ATE] Global Injector not found. Make sure to call provideAteEditor() in your app.config.ts or main.ts.");
+    }
+    return globalInjector;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXRlLWluamVjdG9yLnJlZ2lzdHJ5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci10aXB0YXAtZWRpdG9yL3NyYy9saWIvbm9kZS12aWV3L2F0ZS1pbmplY3Rvci5yZWdpc3RyeS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQTs7OztHQUlHO0FBQ0gsSUFBSSxjQUFjLEdBQW9CLElBQUksQ0FBQztBQUUzQyxNQUFNLFVBQVUsaUJBQWlCLENBQUMsUUFBa0I7SUFDbEQsY0FBYyxHQUFHLFFBQVEsQ0FBQztBQUM1QixDQUFDO0FBRUQsTUFBTSxVQUFVLGlCQUFpQjtJQUMvQixJQUFJLENBQUMsY0FBYyxFQUFFLENBQUM7UUFDcEIsTUFBTSxJQUFJLEtBQUssQ0FDYix5R0FBeUcsQ0FDMUcsQ0FBQztJQUNKLENBQUM7SUFDRCxPQUFPLGNBQWMsQ0FBQztBQUN4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0b3IgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuXG4vKipcbiAqIEludGVybmFsIHJlZ2lzdHJ5IHRvIHN0b3JlIHRoZSByb290IGluamVjdG9yIGZvciB0aGUgZWRpdG9yLlxuICogVGhpcyBhbGxvd3MgcmVnaXN0ZXJBbmd1bGFyQ29tcG9uZW50IHRvIHdvcmsgd2l0aG91dCBleHBsaWNpdGx5IHBhc3NpbmcgdGhlIGluamVjdG9yLlxuICogQGludGVybmFsXG4gKi9cbmxldCBnbG9iYWxJbmplY3RvcjogSW5qZWN0b3IgfCBudWxsID0gbnVsbDtcblxuZXhwb3J0IGZ1bmN0aW9uIHNldEdsb2JhbEluamVjdG9yKGluamVjdG9yOiBJbmplY3Rvcik6IHZvaWQge1xuICBnbG9iYWxJbmplY3RvciA9IGluamVjdG9yO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0R2xvYmFsSW5qZWN0b3IoKTogSW5qZWN0b3Ige1xuICBpZiAoIWdsb2JhbEluamVjdG9yKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKFxuICAgICAgXCJbQVRFXSBHbG9iYWwgSW5qZWN0b3Igbm90IGZvdW5kLiBNYWtlIHN1cmUgdG8gY2FsbCBwcm92aWRlQXRlRWRpdG9yKCkgaW4geW91ciBhcHAuY29uZmlnLnRzIG9yIG1haW4udHMuXCJcbiAgICApO1xuICB9XG4gIHJldHVybiBnbG9iYWxJbmplY3Rvcjtcbn1cbiJdfQ==

package/esm2022/lib/node-view/ate-node-view.factory.mjs

@@ -0,0 +1,125 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { AteAngularNodeView } from "./ate-angular-node-view";
+import { AteNodeViewRenderer } from "./ate-node-view.renderer";
+const RESERVED_NAMES = [
+    "doc",
+    "paragraph",
+    "text",
+    "hardBreak",
+    "bulletList",
+    "orderedList",
+    "listItem",
+    "blockquote",
+    "codeBlock",
+    "heading",
+    "horizontalRule",
+];
+/**
+ * Derives the TipTap node name and HTML tag from a component class.
+ */
+function deriveMetadata(component, customName) {
+    let nodeName = customName;
+    if (!nodeName) {
+        nodeName = component.name
+            .replace(/Component$/, "")
+            .replace(/Node$/, "")
+            .replace(/^([A-Z])/, m => m.toLowerCase());
+        console.warn(`[ATE] Auto-deriving node name '${nodeName}' for component ${component.name}. ` +
+            `Provide an explicit 'name' in options to avoid potential naming collisions.`);
+    }
+    if (RESERVED_NAMES.includes(nodeName)) {
+        throw new Error(`[ATE] The name '${nodeName}' is a reserved TipTap node name. ` +
+            `Please provide a unique name for your custom component.`);
+    }
+    const tag = nodeName.toLowerCase().replace(/([A-Z])/g, "-$1");
+    return { nodeName, tag };
+}
+/**
+ * Creates TipTap attributes from component inputs (Standard Mode).
+ */
+function createStandardAttributes(defaultInputs = {}) {
+    const tiptapAttributes = {};
+    Object.entries(defaultInputs).forEach(([key, defaultValue]) => {
+        tiptapAttributes[key] = {
+            default: defaultValue,
+            parseHTML: (element) => {
+                const attr = element.getAttribute(`data-${key}`);
+                if (attr === null) {
+                    return defaultValue;
+                }
+                try {
+                    return JSON.parse(attr);
+                }
+                catch {
+                    return attr;
+                }
+            },
+            renderHTML: (attrs) => {
+                const value = attrs[key];
+                if (value === undefined || value === null) {
+                    return {};
+                }
+                const serialized = typeof value === "object" ? JSON.stringify(value) : String(value);
+                return { [`data-${key}`]: serialized };
+            },
+        };
+    });
+    return tiptapAttributes;
+}
+/**
+ * Factory to transform an Angular component into a TipTap Node extension.
+ * Supports both "TipTap-Aware" and "Standard" modes.
+ *
+ * @internal
+ */
+export function createAngularComponentExtension(injector, options) {
+    const { component, name: customName, attributes, defaultInputs, contentSelector, contentMode = "block", editableContent = false, group = "block", draggable = true, ignoreMutation = true, onOutput, HTMLAttributes = {}, parseHTML: customParseHTML, renderHTML: customRenderHTML, } = options;
+    const { nodeName, tag } = deriveMetadata(component, customName);
+    const isTipTapAware = Object.prototype.isPrototypeOf.call(AteAngularNodeView, component);
+    const atom = !editableContent;
+    // 1. Prepare Attributes
+    const tiptapAttributes = isTipTapAware
+        ? attributes || {}
+        : createStandardAttributes(defaultInputs);
+    // 2. Create Node Extension
+    return Node.create({
+        name: nodeName,
+        group,
+        inline: group === "inline",
+        atom,
+        draggable,
+        content: editableContent ? (contentMode === "inline" ? "inline*" : "block*") : undefined,
+        addAttributes() {
+            return tiptapAttributes;
+        },
+        parseHTML() {
+            if (customParseHTML) {
+                return customParseHTML.call(this);
+            }
+            return [{ tag }, { tag: `div[data-component="${nodeName}"]` }];
+        },
+        renderHTML({ node, HTMLAttributes: attrs }) {
+            if (customRenderHTML) {
+                return customRenderHTML.call(this, { node, HTMLAttributes: attrs });
+            }
+            return [tag, mergeAttributes(HTMLAttributes, attrs, { "data-component": nodeName })];
+        },
+        addNodeView() {
+            return AteNodeViewRenderer(component, {
+                injector,
+                inputs: defaultInputs,
+                wrapperTag: group === "inline" ? "span" : "div",
+                wrapperClass: isTipTapAware
+                    ? `ate-node-${nodeName}`
+                    : `embedded-component embedded-${nodeName}`,
+                atom,
+                editableContent,
+                contentSelector,
+                contentMode,
+                onOutput,
+                ignoreMutation,
+            });
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-node-view.factory.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/node-view/ate-node-view.factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injector, Type } from \"@angular/core\";\nimport { Node, mergeAttributes } from \"@tiptap/core\";\nimport { AteAngularNodeView } from \"./ate-angular-node-view\";\nimport { RegisterAngularComponentOptions } from \"./ate-node-view.models\";\nimport { AteNodeViewRenderer } from \"./ate-node-view.renderer\";\n\nconst RESERVED_NAMES = [\n  \"doc\",\n  \"paragraph\",\n  \"text\",\n  \"hardBreak\",\n  \"bulletList\",\n  \"orderedList\",\n  \"listItem\",\n  \"blockquote\",\n  \"codeBlock\",\n  \"heading\",\n  \"horizontalRule\",\n];\n\n/**\n * Derives the TipTap node name and HTML tag from a component class.\n */\nfunction deriveMetadata(component: Type<unknown>, customName?: string) {\n  let nodeName = customName;\n\n  if (!nodeName) {\n    nodeName = component.name\n      .replace(/Component$/, \"\")\n      .replace(/Node$/, \"\")\n      .replace(/^([A-Z])/, m => m.toLowerCase());\n\n    console.warn(\n      `[ATE] Auto-deriving node name '${nodeName}' for component ${component.name}. ` +\n        `Provide an explicit 'name' in options to avoid potential naming collisions.`\n    );\n  }\n\n  if (RESERVED_NAMES.includes(nodeName)) {\n    throw new Error(\n      `[ATE] The name '${nodeName}' is a reserved TipTap node name. ` +\n        `Please provide a unique name for your custom component.`\n    );\n  }\n\n  const tag = nodeName.toLowerCase().replace(/([A-Z])/g, \"-$1\");\n  return { nodeName, tag };\n}\n\n/**\n * Creates TipTap attributes from component inputs (Standard Mode).\n */\nfunction createStandardAttributes(defaultInputs: Record<string, unknown> = {}) {\n  const tiptapAttributes: Record<string, unknown> = {};\n\n  Object.entries(defaultInputs).forEach(([key, defaultValue]) => {\n    tiptapAttributes[key] = {\n      default: defaultValue,\n      parseHTML: (element: HTMLElement) => {\n        const attr = element.getAttribute(`data-${key}`);\n        if (attr === null) {\n          return defaultValue;\n        }\n        try {\n          return JSON.parse(attr);\n        } catch {\n          return attr;\n        }\n      },\n      renderHTML: (attrs: Record<string, unknown>) => {\n        const value = attrs[key];\n        if (value === undefined || value === null) {\n          return {};\n        }\n        const serialized = typeof value === \"object\" ? JSON.stringify(value) : String(value);\n        return { [`data-${key}`]: serialized };\n      },\n    };\n  });\n\n  return tiptapAttributes;\n}\n\n/**\n * Factory to transform an Angular component into a TipTap Node extension.\n * Supports both \"TipTap-Aware\" and \"Standard\" modes.\n *\n * @internal\n */\nexport function createAngularComponentExtension<T = unknown>(\n  injector: Injector,\n  options: RegisterAngularComponentOptions<T>\n): Node {\n  const {\n    component,\n    name: customName,\n    attributes,\n    defaultInputs,\n    contentSelector,\n    contentMode = \"block\",\n    editableContent = false,\n    group = \"block\",\n    draggable = true,\n    ignoreMutation = true,\n    onOutput,\n    HTMLAttributes = {},\n    parseHTML: customParseHTML,\n    renderHTML: customRenderHTML,\n  } = options;\n\n  const { nodeName, tag } = deriveMetadata(component, customName);\n  const isTipTapAware = Object.prototype.isPrototypeOf.call(AteAngularNodeView, component);\n  const atom = !editableContent;\n\n  // 1. Prepare Attributes\n  const tiptapAttributes = isTipTapAware\n    ? attributes || {}\n    : createStandardAttributes(defaultInputs);\n\n  // 2. Create Node Extension\n  return Node.create({\n    name: nodeName,\n    group,\n    inline: group === \"inline\",\n    atom,\n    draggable,\n    content: editableContent ? (contentMode === \"inline\" ? \"inline*\" : \"block*\") : undefined,\n\n    addAttributes() {\n      return tiptapAttributes;\n    },\n\n    parseHTML() {\n      if (customParseHTML) {\n        return customParseHTML.call(this);\n      }\n      return [{ tag }, { tag: `div[data-component=\"${nodeName}\"]` }];\n    },\n\n    renderHTML({ node, HTMLAttributes: attrs }) {\n      if (customRenderHTML) {\n        return customRenderHTML.call(this, { node, HTMLAttributes: attrs });\n      }\n      return [tag, mergeAttributes(HTMLAttributes, attrs, { \"data-component\": nodeName })];\n    },\n\n    addNodeView() {\n      return AteNodeViewRenderer(component, {\n        injector,\n        inputs: defaultInputs,\n        wrapperTag: group === \"inline\" ? \"span\" : \"div\",\n        wrapperClass: isTipTapAware\n          ? `ate-node-${nodeName}`\n          : `embedded-component embedded-${nodeName}`,\n        atom,\n        editableContent,\n        contentSelector,\n        contentMode,\n        onOutput,\n        ignoreMutation,\n      });\n    },\n  });\n}\n"]}

package/esm2022/lib/node-view/ate-node-view.models.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/node-view/ate-node-view.renderer.mjs

@@ -0,0 +1,154 @@
+import { ApplicationRef, createComponent, EnvironmentInjector, } from "@angular/core";
+import { AteAngularNodeView } from "./ate-angular-node-view";
+import { Subscription } from "rxjs";
+/**
+ * Universal Renderer for Angular Components as TipTap NodeViews.
+ *
+ * Supports:
+ * - TipTap-Aware components (extending AteAngularNodeView)
+ * - Standard library components (automatic @Input() sync)
+ * - Signal-based inputs and outputs (Angular 18+)
+ * - Content projection (editableContent)
+ * - Unified lifecycle and event management
+ */
+export function AteNodeViewRenderer(component, options) {
+    return props => {
+        const { node, view: _view, getPos, decorations, editor, extension } = props;
+        const { injector, inputs = {}, wrapperTag = "div", wrapperClass, editableContent = false, contentSelector, onOutput, ignoreMutation = true, } = options;
+        const dom = document.createElement(wrapperTag);
+        if (wrapperClass) {
+            dom.className = wrapperClass;
+        }
+        const applicationRef = injector.get(ApplicationRef);
+        const environmentInjector = injector.get(EnvironmentInjector);
+        // 1. Setup Content Projection (ng-content)
+        let initialNodes = [];
+        let contentDOM = null;
+        if (editableContent && !contentSelector) {
+            contentDOM = document.createElement("div");
+            contentDOM.setAttribute("data-node-view-content", "");
+            initialNodes = [[contentDOM]];
+        }
+        // 2. Create the Angular Component
+        const componentRef = createComponent(component, {
+            environmentInjector,
+            elementInjector: injector,
+            projectableNodes: initialNodes,
+        });
+        const instance = componentRef.instance;
+        const subscriptions = [];
+        // 3. Initialize TipTap-Aware instances
+        if (instance instanceof AteAngularNodeView) {
+            instance._initNodeView({
+                editor,
+                node,
+                decorations,
+                selected: false,
+                extension,
+                getPos,
+                updateAttributes: attrs => editor.commands.updateAttributes(node.type.name, attrs),
+                deleteNode: () => {
+                    const pos = getPos();
+                    if (pos !== undefined) {
+                        editor.commands.deleteRange({ from: pos, to: pos + node.nodeSize });
+                    }
+                },
+            });
+        }
+        // 4. Synchronize Inputs (Handles standard @Input and Signal-based inputs)
+        const syncInputs = (nodeToSync) => {
+            // Combine base inputs from options with dynamic node attributes
+            const mergedInputs = { ...inputs, ...nodeToSync.attrs };
+            Object.entries(mergedInputs).forEach(([key, value]) => {
+                if (key !== "id" && value !== null && value !== undefined) {
+                    try {
+                        componentRef.setInput(key, value);
+                    }
+                    catch {
+                        // Silently ignore inputs that don't exist on the component
+                    }
+                }
+            });
+        };
+        syncInputs(node);
+        // 5. Setup Outputs (Handles EventEmitter and OutputRef)
+        if (onOutput) {
+            Object.entries(instance).forEach(([key, potentialOutput]) => {
+                if (potentialOutput &&
+                    typeof potentialOutput
+                        .subscribe === "function") {
+                    const sub = potentialOutput.subscribe((value) => {
+                        onOutput(key, value);
+                    });
+                    if (sub instanceof Subscription) {
+                        subscriptions.push(sub);
+                    }
+                }
+            });
+        }
+        // 6. Attach to DOM and ApplicationRef
+        applicationRef.attachView(componentRef.hostView);
+        const componentElement = componentRef.location.nativeElement;
+        // Target specific element for content if selector provided
+        if (editableContent && contentSelector) {
+            contentDOM = componentElement.querySelector(contentSelector);
+        }
+        dom.appendChild(componentElement);
+        // Initial detection to ensure the component is rendered
+        componentRef.changeDetectorRef.detectChanges();
+        // 7. Return the TipTap NodeView Interface
+        return {
+            dom,
+            contentDOM,
+            update: (updatedNode, updatedDecorations) => {
+                if (updatedNode.type !== node.type) {
+                    return false;
+                }
+                // Update Aware component signals
+                if (instance instanceof AteAngularNodeView) {
+                    instance._updateNodeView(updatedNode, updatedDecorations);
+                }
+                // Update inputs
+                syncInputs(updatedNode);
+                // Notify and Detect changes
+                componentRef.changeDetectorRef.detectChanges();
+                if (options.onUpdate) {
+                    options.onUpdate(updatedNode);
+                }
+                return true;
+            },
+            selectNode: () => {
+                if (instance instanceof AteAngularNodeView) {
+                    instance._selectNodeView();
+                }
+                dom.classList.add("ProseMirror-selectednode");
+            },
+            deselectNode: () => {
+                if (instance instanceof AteAngularNodeView) {
+                    instance._deselectNodeView();
+                }
+                dom.classList.remove("ProseMirror-selectednode");
+            },
+            destroy: () => {
+                if (options.onDestroy) {
+                    options.onDestroy();
+                }
+                subscriptions.forEach(s => s.unsubscribe());
+                applicationRef.detachView(componentRef.hostView);
+                componentRef.destroy();
+            },
+            stopEvent: event => {
+                const target = event.target;
+                const isEditable = target.tagName === "INPUT" || target.tagName === "TEXTAREA" || target.isContentEditable;
+                return isEditable;
+            },
+            ignoreMutation: mutation => {
+                if (typeof ignoreMutation === "function") {
+                    return ignoreMutation(mutation);
+                }
+                return ignoreMutation;
+            },
+        };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ate-node-view.renderer.js","sourceRoot":"","sources":["../../../../../projects/angular-tiptap-editor/src/lib/node-view/ate-node-view.renderer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef,\n  createComponent,\n  EnvironmentInjector,\n  Type,\n  ComponentRef,\n} from \"@angular/core\";\nimport { NodeView, Decoration, EditorView } from \"@tiptap/pm/view\";\nimport { Node as ProseMirrorNode } from \"@tiptap/pm/model\";\nimport { Editor } from \"@tiptap/core\";\nimport { AteAngularNodeView } from \"./ate-angular-node-view\";\nimport { AteComponentRenderOptions } from \"./ate-node-view.models\";\nimport { Subscription } from \"rxjs\";\n\n/**\n * Universal Renderer for Angular Components as TipTap NodeViews.\n *\n * Supports:\n * - TipTap-Aware components (extending AteAngularNodeView)\n * - Standard library components (automatic @Input() sync)\n * - Signal-based inputs and outputs (Angular 18+)\n * - Content projection (editableContent)\n * - Unified lifecycle and event management\n */\nexport function AteNodeViewRenderer<T>(\n  component: Type<T>,\n  options: AteComponentRenderOptions\n): (props: {\n  node: ProseMirrorNode;\n  view: EditorView;\n  getPos: () => number | undefined;\n  decorations: readonly Decoration[];\n  editor: Editor;\n  extension: unknown;\n}) => NodeView {\n  return props => {\n    const { node, view: _view, getPos, decorations, editor, extension } = props;\n    const {\n      injector,\n      inputs = {},\n      wrapperTag = \"div\",\n      wrapperClass,\n      editableContent = false,\n      contentSelector,\n      onOutput,\n      ignoreMutation = true,\n    } = options;\n\n    const dom = document.createElement(wrapperTag);\n    if (wrapperClass) {\n      dom.className = wrapperClass;\n    }\n\n    const applicationRef = injector.get(ApplicationRef);\n    const environmentInjector = injector.get(EnvironmentInjector);\n\n    // 1. Setup Content Projection (ng-content)\n    let initialNodes: Node[][] = [];\n    let contentDOM: HTMLElement | null = null;\n\n    if (editableContent && !contentSelector) {\n      contentDOM = document.createElement(\"div\");\n      contentDOM.setAttribute(\"data-node-view-content\", \"\");\n      initialNodes = [[contentDOM]];\n    }\n\n    // 2. Create the Angular Component\n    const componentRef: ComponentRef<T> = createComponent(component, {\n      environmentInjector,\n      elementInjector: injector,\n      projectableNodes: initialNodes,\n    });\n\n    const instance = componentRef.instance;\n    const subscriptions: Subscription[] = [];\n\n    // 3. Initialize TipTap-Aware instances\n    if (instance instanceof AteAngularNodeView) {\n      instance._initNodeView({\n        editor,\n        node,\n        decorations,\n        selected: false,\n        extension,\n        getPos,\n        updateAttributes: attrs => editor.commands.updateAttributes(node.type.name, attrs),\n        deleteNode: () => {\n          const pos = getPos();\n          if (pos !== undefined) {\n            editor.commands.deleteRange({ from: pos, to: pos + node.nodeSize });\n          }\n        },\n      });\n    }\n\n    // 4. Synchronize Inputs (Handles standard @Input and Signal-based inputs)\n    const syncInputs = (nodeToSync: ProseMirrorNode) => {\n      // Combine base inputs from options with dynamic node attributes\n      const mergedInputs = { ...inputs, ...nodeToSync.attrs };\n      Object.entries(mergedInputs).forEach(([key, value]) => {\n        if (key !== \"id\" && value !== null && value !== undefined) {\n          try {\n            componentRef.setInput(key, value);\n          } catch {\n            // Silently ignore inputs that don't exist on the component\n          }\n        }\n      });\n    };\n\n    syncInputs(node);\n\n    // 5. Setup Outputs (Handles EventEmitter and OutputRef)\n    if (onOutput) {\n      Object.entries(instance as Record<string, unknown>).forEach(([key, potentialOutput]) => {\n        if (\n          potentialOutput &&\n          typeof (potentialOutput as { subscribe?: (cb: (val: unknown) => void) => void })\n            .subscribe === \"function\"\n        ) {\n          const sub = (\n            potentialOutput as { subscribe: (cb: (val: unknown) => void) => Subscription }\n          ).subscribe((value: unknown) => {\n            onOutput(key, value);\n          });\n          if (sub instanceof Subscription) {\n            subscriptions.push(sub);\n          }\n        }\n      });\n    }\n\n    // 6. Attach to DOM and ApplicationRef\n    applicationRef.attachView(componentRef.hostView);\n    const componentElement = componentRef.location.nativeElement;\n\n    // Target specific element for content if selector provided\n    if (editableContent && contentSelector) {\n      contentDOM = componentElement.querySelector(contentSelector);\n    }\n\n    dom.appendChild(componentElement);\n\n    // Initial detection to ensure the component is rendered\n    componentRef.changeDetectorRef.detectChanges();\n\n    // 7. Return the TipTap NodeView Interface\n    return {\n      dom,\n      contentDOM,\n\n      update: (updatedNode, updatedDecorations) => {\n        if (updatedNode.type !== node.type) {\n          return false;\n        }\n\n        // Update Aware component signals\n        if (instance instanceof AteAngularNodeView) {\n          instance._updateNodeView(updatedNode, updatedDecorations);\n        }\n\n        // Update inputs\n        syncInputs(updatedNode);\n\n        // Notify and Detect changes\n        componentRef.changeDetectorRef.detectChanges();\n        if (options.onUpdate) {\n          options.onUpdate(updatedNode);\n        }\n\n        return true;\n      },\n\n      selectNode: () => {\n        if (instance instanceof AteAngularNodeView) {\n          instance._selectNodeView();\n        }\n        dom.classList.add(\"ProseMirror-selectednode\");\n      },\n\n      deselectNode: () => {\n        if (instance instanceof AteAngularNodeView) {\n          instance._deselectNodeView();\n        }\n        dom.classList.remove(\"ProseMirror-selectednode\");\n      },\n\n      destroy: () => {\n        if (options.onDestroy) {\n          options.onDestroy();\n        }\n        subscriptions.forEach(s => s.unsubscribe());\n        applicationRef.detachView(componentRef.hostView);\n        componentRef.destroy();\n      },\n\n      stopEvent: event => {\n        const target = event.target as HTMLElement;\n        const isEditable =\n          target.tagName === \"INPUT\" || target.tagName === \"TEXTAREA\" || target.isContentEditable;\n        return isEditable;\n      },\n\n      ignoreMutation: mutation => {\n        if (typeof ignoreMutation === \"function\") {\n          return ignoreMutation(mutation);\n        }\n        return ignoreMutation;\n      },\n    };\n  };\n}\n"]}