rete-angular-plugin 2.3.2 → 2.4.0

package/20/index.d.ts

@@ -0,0 +1,553 @@
+import * as i0 from '@angular/core';
+import { Injector, Type, OnChanges, OnDestroy, ElementRef, ChangeDetectorRef, OnInit, ViewContainerRef, ComponentRef, ComponentFactoryResolver, SimpleChanges, EventEmitter } from '@angular/core';
+import { GetSchemes, ClassicPreset, NodeId, BaseSchemes, Scope, CanAssignSignal, ConnectionId } from 'rete';
+import { SocketPositionWatcher } from 'rete-render-utils';
+import { NgElement as NgElement$1, NgElementStrategy } from '@angular/elements';
+import * as i1 from '@angular/common';
+import { KeyValue } from '@angular/common';
+
+type NgElement = NgElement$1 & {
+    ngElementStrategy: NgElementStrategy & {
+        setInputValue(key: string, value: any): void;
+    };
+};
+type Position$1 = {
+    x: number;
+    y: number;
+};
+type RenderSignal<Type extends string, Data> = {
+    type: 'render';
+    data: {
+        element: HTMLElement;
+        filled?: boolean;
+        type: Type;
+    } & Data;
+} | {
+    type: 'rendered';
+    data: {
+        element: HTMLElement;
+        type: Type;
+    } & Data;
+};
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type GetControls<T extends ClassicScheme['Node'], Intersection = UnionToIntersection<T['controls']>> = Intersection[keyof Intersection] extends ClassicPreset.Control ? Intersection[keyof Intersection] : ClassicPreset.Control;
+type GetSockets<T extends ClassicScheme['Node'], Intersection = UnionToIntersection<T['inputs'] | T['outputs']>, Union = Exclude<Intersection[keyof Intersection], undefined>> = Union extends {
+    socket: any;
+} ? Union['socket'] : ClassicPreset.Socket;
+type Side = 'input' | 'output';
+type ExtractPayload<T extends ClassicScheme, K extends string> = Extract<AngularArea2D<T>, {
+    type: 'render';
+    data: {
+        type: K;
+    };
+}>['data'];
+type AngularArea2D<T extends ClassicScheme> = RenderSignal<'node', {
+    payload: T['Node'];
+}> | RenderSignal<'connection', {
+    payload: T['Connection'];
+    start?: Position$1;
+    end?: Position$1;
+}> | RenderSignal<'socket', {
+    payload: GetSockets<T['Node']>;
+    nodeId: NodeId;
+    side: Side;
+    key: string;
+}> | RenderSignal<'control', {
+    payload: GetControls<T['Node']>;
+}> | {
+    type: 'unmount';
+    data: {
+        element: HTMLElement;
+    };
+};
+type ClassicScheme = GetSchemes<ClassicPreset.Node, ClassicPreset.Connection<ClassicPreset.Node, ClassicPreset.Node> & {
+    isLoop?: boolean;
+}>;
+
+type Item$1 = {
+    key: string;
+    ngElement: NgElement;
+};
+type Renderer = {
+    get(element: HTMLElement): Item$1 | undefined;
+    mount(element: HTMLElement, key: string, component: any, injector: Injector, props: Record<string, unknown>): void;
+    update(item: Item$1, props: Record<string, unknown>): void;
+    unmount(element: HTMLElement): void;
+};
+/**
+ * Signals that can be emitted by the plugin
+ * @priority 10
+ */
+type Produces<Schemes extends BaseSchemes> = {
+    type: 'connectionpath';
+    data: {
+        payload: Schemes['Connection'];
+        path?: string;
+        points: Position$1[];
+    };
+};
+type Requires<Schemes extends BaseSchemes> = RenderSignal<'node', {
+    payload: Schemes['Node'];
+}> | RenderSignal<'connection', {
+    payload: Schemes['Connection'];
+    start?: Position$1;
+    end?: Position$1;
+}> | {
+    type: 'unmount';
+    data: {
+        element: HTMLElement;
+    };
+};
+/**
+ * Angular plugin. Renders nodes, connections and other elements using React.
+ * @priority 9
+ * @emits connectionpath
+ * @listens render
+ * @listens unmount
+ */
+declare class AngularPlugin<Schemes extends BaseSchemes, T = Requires<Schemes>> extends Scope<Produces<Schemes>, [Requires<Schemes> | T]> {
+    private params;
+    presets: RenderPreset<Schemes, T>[];
+    renderer: Renderer;
+    owners: WeakMap<HTMLElement, RenderPreset<Schemes, T>>;
+    /**
+     * @constructor
+     * @param params Plugin properties
+     * @param params.injector Angular's Injector instance
+     */
+    constructor(params: {
+        injector: Injector;
+    });
+    setParent(scope: Scope<Requires<Schemes> | T>): void;
+    private unmount;
+    private mount;
+    /**
+     * Adds a preset to the plugin.
+     * @param preset Preset that can render nodes, connections and other elements.
+     */
+    addPreset<K>(preset: RenderPreset<Schemes, CanAssignSignal<T, K> extends true ? K : 'Cannot apply preset. Provided signals are not compatible'>): void;
+}
+
+type RenderPreset<Schemes extends BaseSchemes, T> = {
+    attach?: (plugin: AngularPlugin<Schemes, T>) => void;
+    update: (context: Extract<T, {
+        type: 'render';
+    }>, plugin: AngularPlugin<Schemes, T>) => Record<string, unknown> | undefined | null | void;
+    mount: (context: Extract<T, {
+        type: 'render';
+    }>, plugin: AngularPlugin<Schemes, T>) => {
+        key: string;
+        component: any;
+        props: Record<string, unknown>;
+    } | undefined | null | void;
+};
+
+type AngularComponent = Type<any>;
+type CustomizationProps<Schemes extends ClassicScheme> = {
+    node?: (data: ExtractPayload<Schemes, 'node'>) => AngularComponent | null;
+    connection?: (data: ExtractPayload<Schemes, 'connection'>) => AngularComponent | null;
+    socket?: (data: ExtractPayload<Schemes, 'socket'>) => AngularComponent | null;
+    control?: (data: ExtractPayload<Schemes, 'control'>) => AngularComponent | null;
+};
+type ClassicProps<Schemes extends ClassicScheme, K> = {
+    socketPositionWatcher?: SocketPositionWatcher<Scope<never, [K]>>;
+    customize?: CustomizationProps<Schemes>;
+};
+/**
+ * Classic preset for rendering nodes, connections, controls and sockets.
+ */
+declare function setup$3<Schemes extends ClassicScheme, K extends AngularArea2D<Schemes>>(props?: ClassicProps<Schemes, K>): RenderPreset<Schemes, K>;
+
+declare namespace index_d$4 {
+  export {
+    setup$3 as setup,
+  };
+}
+
+type Item = {
+    label: string;
+    key: string;
+    handler(): void;
+    subitems?: Item[];
+};
+type ContextMenuRender = RenderSignal<'contextmenu', {
+    items: Item[];
+    onHide(): void;
+    searchBar?: boolean;
+}>;
+
+/**
+ * Preset for rendering context menu.
+ */
+declare function setup$2<Schemes extends BaseSchemes, K extends ContextMenuRender>(props?: {
+    delay?: number;
+}): RenderPreset<Schemes, K>;
+
+declare namespace index_d$3 {
+  export {
+    setup$2 as setup,
+  };
+}
+
+type Rect = {
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+};
+type Transform = {
+    x: number;
+    y: number;
+    k: number;
+};
+type Translate = (dx: number, dy: number) => void;
+type MinimapData = {
+    ratio: number;
+    nodes: Rect[];
+    viewport: Rect;
+    start(): Transform;
+    translate: Translate;
+    point(x: number, y: number): void;
+};
+type MinimapRender = RenderSignal<'minimap', MinimapData>;
+
+/**
+ * Preset for rendering minimap.
+ */
+declare function setup$1<Schemes extends BaseSchemes, K extends MinimapRender>(props?: {
+    size?: number;
+}): RenderPreset<Schemes, K>;
+
+declare namespace index_d$2 {
+  export {
+    setup$1 as setup,
+  };
+}
+
+type Position = {
+    x: number;
+    y: number;
+};
+type Pin = {
+    id: string;
+    position: Position;
+    selected?: boolean;
+};
+type PinData = {
+    id: ConnectionId;
+    pins: Pin[];
+};
+type PinsRender = RenderSignal<'reroute-pins', {
+    data: PinData;
+}>;
+
+type Props = {
+    translate?: (id: string, dx: number, dy: number) => void;
+    contextMenu?: (id: string) => void;
+    pointerdown?: (id: string) => void;
+};
+/**
+ * Preset for rendering pins.
+ */
+declare function setup<Schemes extends BaseSchemes, K extends PinsRender>(props?: Props): RenderPreset<Schemes, K>;
+
+declare const index_d$1_setup: typeof setup;
+declare namespace index_d$1 {
+  export {
+    index_d$1_setup as setup,
+  };
+}
+
+/**
+ * Built-in presets, responsible for rendering different parts of the editor.
+ * @module
+ */
+
+declare namespace index_d {
+  export {
+    index_d$4 as classic,
+    index_d$3 as contextMenu,
+    index_d$2 as minimap,
+    index_d$1 as reroute,
+  };
+}
+
+declare class RefDirective implements OnChanges, OnDestroy {
+    private el;
+    data: any;
+    emit: any;
+    constructor(el: ElementRef);
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RefDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<RefDirective, "[refComponent]", never, { "data": { "alias": "data"; "required": false; }; "emit": { "alias": "emit"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type NodeExtraData = {
+    width?: number;
+    height?: number;
+};
+type SortValue<N extends ClassicPreset.Node> = (N['controls'] | N['inputs'] | N['outputs'])[string];
+declare class NodeComponent implements OnChanges {
+    private cdr;
+    data: ClassicPreset.Node & NodeExtraData;
+    emit: (data: any) => void;
+    rendered: () => void;
+    seed: number;
+    get width(): number;
+    get height(): number;
+    get selected(): boolean;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    sortByIndex<N extends ClassicPreset.Node, I extends KeyValue<string, SortValue<N>>>(a: I, b: I): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "emit": { "alias": "emit"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ConnectionComponent {
+    data: ClassicPreset.Connection<ClassicPreset.Node, ClassicPreset.Node>;
+    start: Position$1;
+    end: Position$1;
+    path: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConnectionComponent, "connection", never, { "data": { "alias": "data"; "required": false; }; "start": { "alias": "start"; "required": false; }; "end": { "alias": "end"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type PositionWatcher = (cb: (value: Position$1) => void) => (() => void);
+declare class ConnectionWrapperComponent implements OnInit, OnChanges {
+    private cdr;
+    viewContainerRef: ViewContainerRef;
+    private componentFactoryResolver;
+    data: ClassicPreset.Connection<ClassicPreset.Node, ClassicPreset.Node>;
+    start: Position$1 | PositionWatcher;
+    end: Position$1 | PositionWatcher;
+    path: (start: Position$1, end: Position$1) => Promise<string>;
+    rendered: any;
+    connectionComponent: any;
+    ref: ComponentRef<any>;
+    startOb: Position$1 | null;
+    get _start(): Position$1 | null;
+    endOb: Position$1 | null;
+    get _end(): Position$1 | null;
+    _path: string;
+    constructor(cdr: ChangeDetectorRef, viewContainerRef: ViewContainerRef, componentFactoryResolver: ComponentFactoryResolver);
+    ngOnChanges(): Promise<void>;
+    updatePath(): Promise<void>;
+    ngOnInit(): void;
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConnectionWrapperComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConnectionWrapperComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "start": { "alias": "start"; "required": false; }; "end": { "alias": "end"; "required": false; }; "path": { "alias": "path"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; "connectionComponent": { "alias": "connectionComponent"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SocketComponent implements OnChanges {
+    private cdr;
+    data: any;
+    rendered: any;
+    get title(): any;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SocketComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SocketComponent, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ControlComponent<T extends 'text' | 'number'> implements OnChanges {
+    private cdr;
+    data: ClassicPreset.InputControl<T>;
+    rendered: any;
+    pointerdown(event: any): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    onChange(e: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ControlComponent<any>, "ng-component", never, { "data": { "alias": "data"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ReteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteModule, never, [typeof i1.CommonModule, typeof RefDirective, typeof NodeComponent, typeof ConnectionComponent, typeof ConnectionWrapperComponent, typeof SocketComponent, typeof ControlComponent], [typeof RefDirective, typeof NodeComponent, typeof ConnectionComponent, typeof ConnectionWrapperComponent, typeof SocketComponent, typeof ControlComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReteModule>;
+}
+
+declare class ContextMenuComponent implements OnChanges, OnDestroy {
+    private cdr;
+    items: Item[];
+    delay: number;
+    searchBar?: boolean;
+    onHide: () => void;
+    rendered: () => void;
+    filter: string;
+    hide: {
+        timeout: null | number;
+        cancel(): void;
+        call(delay: number): void;
+    };
+    customAttribute: string;
+    pointerover(): void;
+    pointerleave(): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    setFilter(value: string): void;
+    getItems(): Item[];
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuComponent, "ng-component", never, { "items": { "alias": "items"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "searchBar": { "alias": "searchBar"; "required": false; }; "onHide": { "alias": "onHide"; "required": false; }; "rendered": { "alias": "rendered"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ContextMenuSearchComponent {
+    value: string;
+    update: EventEmitter<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuSearchComponent, "context-menu-search", never, { "value": { "alias": "value"; "required": false; }; }, { "update": "update"; }, never, never, true, never>;
+}
+
+declare class ContextMenuItemComponent {
+    private cdr;
+    subitems?: Item[];
+    delay: number;
+    select: EventEmitter<void>;
+    hide: EventEmitter<void>;
+    get block(): boolean;
+    get hasSubitems(): Item[];
+    click(event: MouseEvent): void;
+    pointerdown(event: PointerEvent): void;
+    wheel(event: MouseEvent): void;
+    hideSubitems: {
+        timeout: null | number;
+        cancel(): void;
+        call(delay: number): void;
+    };
+    visibleSubitems: boolean;
+    pointerover(): void;
+    pointerleave(): void;
+    constructor(cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuItemComponent, "context-menu-item", never, { "subitems": { "alias": "subitems"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; }, { "select": "select"; "hide": "hide"; }, never, ["*"], true, never>;
+}
+
+declare class ReteContextMenuModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReteContextMenuModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteContextMenuModule, never, [typeof i1.CommonModule, typeof ContextMenuComponent, typeof ContextMenuSearchComponent, typeof ContextMenuItemComponent], [typeof ContextMenuComponent, typeof ContextMenuSearchComponent, typeof ContextMenuItemComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReteContextMenuModule>;
+}
+
+declare class MinimapComponent implements OnChanges {
+    el: ElementRef;
+    private cdr;
+    rendered: () => void;
+    size: number;
+    ratio: MinimapData['ratio'];
+    nodes: MinimapData['nodes'];
+    viewport: MinimapData['viewport'];
+    translate: MinimapData['translate'];
+    point: MinimapData['point'];
+    get width(): string;
+    get height(): string;
+    pointerdown(event: PointerEvent): void;
+    dblclick(event: MouseEvent): void;
+    constructor(el: ElementRef, cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    px(value: number): string;
+    scale(value: number): number;
+    identifyMiniNode(_: number, item: MinimapData['nodes'][number]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinimapComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MinimapComponent, "ng-component", never, { "rendered": { "alias": "rendered"; "required": false; }; "size": { "alias": "size"; "required": false; }; "ratio": { "alias": "ratio"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "viewport": { "alias": "viewport"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "point": { "alias": "point"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MiniViewportComponent {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    containerWidth: number;
+    translate: MinimapData['translate'];
+    drag: {
+        start(e: {
+            pageX: number;
+            pageY: number;
+        }): void;
+    };
+    get styleLeft(): string;
+    get styleTop(): string;
+    get styleWidth(): string;
+    get styleHeight(): string;
+    pointerdown(event: PointerEvent): void;
+    px(value: number): string;
+    scale(v: number): number;
+    invert(v: number): number;
+    onDrag(dx: number, dy: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniViewportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MiniViewportComponent, "minimap-mini-viewport", never, { "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "containerWidth": { "alias": "containerWidth"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MiniNodeComponent {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    get styleLeft(): string;
+    get styleTop(): string;
+    get styleWidth(): string;
+    get styleHeight(): string;
+    px(value: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MiniNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MiniNodeComponent, "minimap-mini-node", never, { "left": { "alias": "left"; "required": false; }; "top": { "alias": "top"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ReteMinimapModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReteMinimapModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteMinimapModule, never, [typeof i1.CommonModule, typeof MinimapComponent, typeof MiniViewportComponent, typeof MiniNodeComponent], [typeof MinimapComponent, typeof MiniViewportComponent, typeof MiniNodeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReteMinimapModule>;
+}
+
+declare class PinsComponent implements OnChanges {
+    private cdr;
+    rendered: () => void;
+    pins: PinData['pins'];
+    down?: (id: string) => void;
+    translate?: (id: string, dx: number, dy: number) => void;
+    menu?: (id: string) => void;
+    getPointer?: () => Position;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    track(_: number, item: Pin): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinsComponent, "ng-component", never, { "rendered": { "alias": "rendered"; "required": false; }; "pins": { "alias": "pins"; "required": false; }; "down": { "alias": "down"; "required": false; }; "translate": { "alias": "translate"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "getPointer": { "alias": "getPointer"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PinComponent implements OnChanges {
+    private cdr;
+    position: Position;
+    selected?: boolean;
+    getPointer: () => Position;
+    menu: EventEmitter<void>;
+    translate: EventEmitter<{
+        dx: number;
+        dy: number;
+    }>;
+    down: EventEmitter<void>;
+    drag: {
+        start(e: {
+            pageX: number;
+            pageY: number;
+        }): void;
+    };
+    get _selected(): boolean;
+    get top(): string;
+    get left(): string;
+    pointerdown(event: PointerEvent): void;
+    contextmenu(event: MouseEvent): void;
+    constructor(cdr: ChangeDetectorRef);
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PinComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PinComponent, "reroute-pin", never, { "position": { "alias": "position"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "getPointer": { "alias": "getPointer"; "required": false; }; }, { "menu": "menu"; "translate": "translate"; "down": "down"; }, never, never, true, never>;
+}
+
+declare class ReteRerouteModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReteRerouteModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ReteRerouteModule, never, [typeof i1.CommonModule, typeof PinsComponent, typeof PinComponent], [typeof PinsComponent, typeof PinComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ReteRerouteModule>;
+}
+
+export { AngularPlugin, ConnectionComponent, ConnectionWrapperComponent, ContextMenuComponent, ContextMenuItemComponent, ContextMenuSearchComponent, ControlComponent, MiniNodeComponent, MiniViewportComponent, MinimapComponent, NodeComponent, PinComponent, PinsComponent, index_d as Presets, RefDirective, ReteContextMenuModule, ReteMinimapModule, ReteModule, ReteRerouteModule, SocketComponent };
+export type { AngularArea2D, Produces, RenderPreset };

package/20/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "rete-angular-plugin-ng20",
+  "version": "0.0.0",
+  "module": "fesm2022/rete-angular-plugin-ng20.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/rete-angular-plugin-ng20.mjs"
+    }
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "scripts": {
+    "prepublishOnly": "node --eval \"console.error('ERROR: Trying to publish a package that has been compiled in full compilation mode. This is not allowed.\\nPlease delete and rebuild the package with partial compilation mode, before attempting to publish.\\n')\" && exit 1"
+  }
+}

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [2.4.0](https://github.com/retejs/angular-plugin/compare/v2.3.2...v2.4.0) (2025-06-30)
+
+
+### Features
+
+* angular 20 support ([c773cfc](https://github.com/retejs/angular-plugin/commit/c773cfc9a1bc9bc9619352430370067351f6ba0e))
+
 ## [2.3.2](https://github.com/retejs/angular-plugin/compare/v2.3.1...v2.3.2) (2025-02-09)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rete-angular-plugin",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "author": "Vitaliy Stoliarov",
   "license": "MIT",
   "keywords": [
@@ -18,9 +18,9 @@
     "url": "https://github.com/retejs/angular-plugin/issues"
   },
   "peerDependencies": {
-    "@angular/common": ">= 12 < 20",
-    "@angular/core": ">= 12 < 20",
-    "@angular/elements": ">= 12 < 20",
+    "@angular/common": ">= 12 < 21",
+    "@angular/core": ">= 12 < 21",
+    "@angular/elements": ">= 12 < 21",
     "rete": "^2.0.1",
     "rete-area-plugin": "^2.0.0",
     "rete-render-utils": "^2.0.0",