dockview-angular 4.13.0 → 5.0.0

package/dist/esm2022/lib/gridview/gridview-angular.component.mjs

@@ -0,0 +1,98 @@
+import { Component, ElementRef, EventEmitter, Injector, Input, Output, ViewChild, ChangeDetectionStrategy, EnvironmentInjector, inject, } from '@angular/core';
+import { createGridview, PROPERTY_KEYS_GRIDVIEW, } from 'dockview-core';
+import { AngularFrameworkComponentFactory } from '../utils/component-factory';
+import { AngularLifecycleManager } from '../utils/lifecycle-utils';
+import * as i0 from "@angular/core";
+export class GridviewAngularComponent {
+    constructor() {
+        this.ready = new EventEmitter();
+        this.lifecycleManager = new AngularLifecycleManager();
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+    }
+    ngOnInit() {
+        this.initializeGridview();
+    }
+    ngOnDestroy() {
+        this.lifecycleManager.destroy();
+        if (this.gridviewApi) {
+            this.gridviewApi.dispose();
+        }
+    }
+    ngOnChanges(changes) {
+        if (this.gridviewApi) {
+            const coreChanges = {};
+            let hasChanges = false;
+            // Check for changes in core gridview properties
+            PROPERTY_KEYS_GRIDVIEW.forEach((key) => {
+                if (changes[key] && !changes[key].isFirstChange()) {
+                    coreChanges[key] = changes[key].currentValue;
+                    hasChanges = true;
+                }
+            });
+            if (hasChanges) {
+                this.gridviewApi.updateOptions(coreChanges);
+            }
+        }
+    }
+    getGridviewApi() {
+        return this.gridviewApi;
+    }
+    initializeGridview() {
+        if (!this.components) {
+            throw new Error('GridviewAngularComponent: components input is required');
+        }
+        const coreOptions = this.extractCoreOptions();
+        const frameworkOptions = this.createFrameworkOptions();
+        this.gridviewApi = createGridview(this.containerRef.nativeElement, {
+            ...coreOptions,
+            ...frameworkOptions,
+        });
+        // Emit ready event
+        this.ready.emit({ api: this.gridviewApi });
+    }
+    extractCoreOptions() {
+        const coreOptions = {};
+        PROPERTY_KEYS_GRIDVIEW.forEach((key) => {
+            const value = this[key];
+            if (value !== undefined) {
+                coreOptions[key] = value;
+            }
+        });
+        return coreOptions;
+    }
+    createFrameworkOptions() {
+        const componentFactory = new AngularFrameworkComponentFactory(this.components, this.injector, this.environmentInjector);
+        return {
+            createComponent: (options) => {
+                return componentFactory.createGridviewComponent(options);
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GridviewAngularComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: GridviewAngularComponent, isStandalone: true, selector: "dv-gridview", inputs: { components: "components", className: "className", orientation: "orientation", proportionalLayout: "proportionalLayout", hideBorders: "hideBorders", debug: "debug", disableAutoResizing: "disableAutoResizing" }, outputs: { ready: "ready" }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["gridviewContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: '<div #gridviewContainer class="gridview-container"></div>', isInline: true, styles: [":host{display:block;width:100%;height:100%}.gridview-container{width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GridviewAngularComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dv-gridview', standalone: true, template: '<div #gridviewContainer class="gridview-container"></div>', changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;width:100%;height:100%}.gridview-container{width:100%;height:100%}\n"] }]
+        }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['gridviewContainer', { static: true }]
+            }], components: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], proportionalLayout: [{
+                type: Input
+            }], hideBorders: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], disableAutoResizing: [{
+                type: Input
+            }], ready: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"gridview-angular.component.js","sourceRoot":"","sources":["../../../../src/lib/gridview/gridview-angular.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    ElementRef,\n    EventEmitter,\n    Injector,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    Type,\n    ViewChild,\n    ChangeDetectionStrategy,\n    OnChanges,\n    SimpleChanges,\n    EnvironmentInjector,\n    inject,\n} from '@angular/core';\nimport {\n    GridviewApi,\n    GridviewOptions,\n    createGridview,\n    PROPERTY_KEYS_GRIDVIEW,\n    GridviewFrameworkOptions,\n    GridviewComponentOptions,\n} from 'dockview-core';\nimport { AngularFrameworkComponentFactory } from '../utils/component-factory';\nimport { AngularLifecycleManager } from '../utils/lifecycle-utils';\nimport { GridviewAngularReadyEvent } from './types';\n\nexport interface GridviewAngularOptions extends GridviewOptions {\n    components: Record<string, Type<any>>;\n}\n\n@Component({\n    selector: 'dv-gridview',\n    standalone: true,\n    template: '<div #gridviewContainer class=\"gridview-container\"></div>',\n    styles: [\n        `\n            :host {\n                display: block;\n                width: 100%;\n                height: 100%;\n            }\n\n            .gridview-container {\n                width: 100%;\n                height: 100%;\n            }\n        `,\n    ],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class GridviewAngularComponent implements OnInit, OnDestroy, OnChanges {\n    @ViewChild('gridviewContainer', { static: true })\n    private containerRef!: ElementRef<HTMLDivElement>;\n\n    @Input() components!: Record<string, Type<any>>;\n\n    // Core gridview options as inputs\n    @Input() className?: string;\n    @Input() orientation?: 'horizontal' | 'vertical';\n    @Input() proportionalLayout?: boolean;\n    @Input() hideBorders?: boolean;\n    @Input() debug?: boolean;\n    @Input() disableAutoResizing?: boolean;\n\n    @Output() ready = new EventEmitter<GridviewAngularReadyEvent>();\n\n    private gridviewApi?: GridviewApi;\n    private lifecycleManager = new AngularLifecycleManager();\n    private injector = inject(Injector);\n    private environmentInjector = inject(EnvironmentInjector);\n\n    ngOnInit(): void {\n        this.initializeGridview();\n    }\n\n    ngOnDestroy(): void {\n        this.lifecycleManager.destroy();\n        if (this.gridviewApi) {\n            this.gridviewApi.dispose();\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (this.gridviewApi) {\n            const coreChanges: Partial<GridviewOptions> = {};\n            let hasChanges = false;\n\n            // Check for changes in core gridview properties\n            PROPERTY_KEYS_GRIDVIEW.forEach((key) => {\n                if (changes[key] && !changes[key].isFirstChange()) {\n                    (coreChanges as any)[key] = changes[key].currentValue;\n                    hasChanges = true;\n                }\n            });\n\n            if (hasChanges) {\n                this.gridviewApi.updateOptions(coreChanges);\n            }\n        }\n    }\n\n    getGridviewApi(): GridviewApi | undefined {\n        return this.gridviewApi;\n    }\n\n    private initializeGridview(): void {\n        if (!this.components) {\n            throw new Error(\n                'GridviewAngularComponent: components input is required'\n            );\n        }\n\n        const coreOptions = this.extractCoreOptions();\n        const frameworkOptions = this.createFrameworkOptions();\n\n        this.gridviewApi = createGridview(this.containerRef.nativeElement, {\n            ...coreOptions,\n            ...frameworkOptions,\n        });\n\n        // Emit ready event\n        this.ready.emit({ api: this.gridviewApi });\n    }\n\n    private extractCoreOptions(): GridviewOptions {\n        const coreOptions: Partial<GridviewComponentOptions> = {};\n\n        PROPERTY_KEYS_GRIDVIEW.forEach((key) => {\n            const value = (this as any)[key];\n            if (value !== undefined) {\n                (coreOptions as any)[key] = value;\n            }\n        });\n\n        return coreOptions as GridviewOptions;\n    }\n\n    private createFrameworkOptions(): GridviewFrameworkOptions {\n        const componentFactory = new AngularFrameworkComponentFactory(\n            this.components,\n            this.injector,\n            this.environmentInjector\n        );\n\n        return {\n            createComponent: (options) => {\n                return componentFactory.createGridviewComponent(options);\n            },\n        };\n    }\n}\n"]}

package/dist/esm2022/lib/gridview/types.mjs

@@ -0,0 +1,3 @@
+// Re-export commonly used types from dockview-core
+export { GridviewApi } from 'dockview-core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL2dyaWR2aWV3L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWVBLG1EQUFtRDtBQUNuRCxPQUFPLEVBQUUsV0FBVyxFQUFtQixNQUFNLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEdyaWR2aWV3T3B0aW9ucywgR3JpZHZpZXdBcGkgfSBmcm9tICdkb2Nrdmlldy1jb3JlJztcblxuZXhwb3J0IGludGVyZmFjZSBHcmlkdmlld0FuZ3VsYXJSZWFkeUV2ZW50IHtcbiAgICBhcGk6IEdyaWR2aWV3QXBpO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdyaWR2aWV3QW5ndWxhck9wdGlvbnMgZXh0ZW5kcyBHcmlkdmlld09wdGlvbnMge1xuICAgIGNvbXBvbmVudHM6IFJlY29yZDxzdHJpbmcsIFR5cGU8YW55Pj47XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgR3JpZHZpZXdBbmd1bGFyRXZlbnRzIHtcbiAgICByZWFkeTogR3JpZHZpZXdBbmd1bGFyUmVhZHlFdmVudDtcbn1cblxuLy8gUmUtZXhwb3J0IGNvbW1vbmx5IHVzZWQgdHlwZXMgZnJvbSBkb2Nrdmlldy1jb3JlXG5leHBvcnQgeyBHcmlkdmlld0FwaSwgR3JpZHZpZXdPcHRpb25zIH0gZnJvbSAnZG9ja3ZpZXctY29yZSc7XG4iXX0=

package/dist/esm2022/lib/paneview/angular-pane-part.mjs

@@ -0,0 +1,26 @@
+import { AngularRenderer } from '../utils/angular-renderer';
+export class AngularPanePart {
+    constructor(angularComponent, injector, environmentInjector) {
+        this.angularComponent = angularComponent;
+        this.injector = injector;
+        this.environmentInjector = environmentInjector;
+        this.renderer = new AngularRenderer({
+            component: this.angularComponent,
+            injector: this.injector,
+            environmentInjector: this.environmentInjector,
+        });
+    }
+    get element() {
+        return this.renderer.element;
+    }
+    init(parameters) {
+        this.renderer.init(parameters);
+    }
+    update(params) {
+        this.renderer.update(params);
+    }
+    dispose() {
+        this.renderer.dispose();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/paneview/paneview-angular.component.mjs

@@ -0,0 +1,122 @@
+import { Component, ElementRef, EventEmitter, Injector, Input, Output, ViewChild, ChangeDetectionStrategy, EnvironmentInjector, inject, } from '@angular/core';
+import { createPaneview, PROPERTY_KEYS_PANEVIEW, } from 'dockview-core';
+import { AngularFrameworkComponentFactory } from '../utils/component-factory';
+import { AngularLifecycleManager } from '../utils/lifecycle-utils';
+import { AngularPanePart } from './angular-pane-part';
+import * as i0 from "@angular/core";
+export class PaneviewAngularComponent {
+    constructor() {
+        this.ready = new EventEmitter();
+        this.drop = new EventEmitter();
+        this.lifecycleManager = new AngularLifecycleManager();
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+    }
+    ngOnInit() {
+        this.initializePaneview();
+    }
+    ngOnDestroy() {
+        this.lifecycleManager.destroy();
+        if (this.paneviewApi) {
+            this.paneviewApi.dispose();
+        }
+    }
+    ngOnChanges(changes) {
+        if (this.paneviewApi) {
+            const coreChanges = {};
+            let hasChanges = false;
+            // Check for changes in core paneview properties
+            PROPERTY_KEYS_PANEVIEW.forEach((key) => {
+                if (changes[key] && !changes[key].isFirstChange()) {
+                    coreChanges[key] = changes[key].currentValue;
+                    hasChanges = true;
+                }
+            });
+            if (hasChanges) {
+                this.paneviewApi.updateOptions(coreChanges);
+            }
+        }
+    }
+    getPaneviewApi() {
+        return this.paneviewApi;
+    }
+    initializePaneview() {
+        if (!this.components) {
+            throw new Error('PaneviewAngularComponent: components input is required');
+        }
+        const coreOptions = this.extractCoreOptions();
+        const frameworkOptions = this.createFrameworkOptions();
+        this.paneviewApi = createPaneview(this.containerRef.nativeElement, {
+            ...coreOptions,
+            ...frameworkOptions,
+        });
+        // Set up event listeners
+        this.setupEventListeners();
+        // Emit ready event
+        this.ready.emit({ api: this.paneviewApi });
+    }
+    extractCoreOptions() {
+        const coreOptions = {};
+        PROPERTY_KEYS_PANEVIEW.forEach((key) => {
+            const value = this[key];
+            if (value !== undefined) {
+                coreOptions[key] = value;
+            }
+        });
+        return coreOptions;
+    }
+    createFrameworkOptions() {
+        const componentFactory = new AngularFrameworkComponentFactory(this.components, this.injector, this.environmentInjector, this.headerComponents);
+        return {
+            createComponent: (options) => {
+                return componentFactory.createPaneviewComponent(options);
+            },
+            createHeaderComponent: this.headerComponents
+                ? (options) => {
+                    return new AngularPanePart(this.headerComponents[options.name], this.injector, this.environmentInjector);
+                }
+                : undefined,
+        };
+    }
+    setupEventListeners() {
+        if (!this.paneviewApi) {
+            return;
+        }
+        // Set up event subscriptions using lifecycle manager
+        const api = this.paneviewApi;
+        if (this.drop.observers.length > 0) {
+            const disposable = api.onDidDrop((event) => {
+                this.drop.emit(event);
+            });
+            this.lifecycleManager.addDisposable(disposable);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PaneviewAngularComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: PaneviewAngularComponent, isStandalone: true, selector: "dv-paneview", inputs: { components: "components", headerComponents: "headerComponents", className: "className", orientation: "orientation", hideBorders: "hideBorders", debug: "debug", disableAutoResizing: "disableAutoResizing" }, outputs: { ready: "ready", drop: "drop" }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["paneviewContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: '<div #paneviewContainer class="paneview-container"></div>', isInline: true, styles: [":host{display:block;width:100%;height:100%}.paneview-container{width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: PaneviewAngularComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dv-paneview', standalone: true, template: '<div #paneviewContainer class="paneview-container"></div>', changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;width:100%;height:100%}.paneview-container{width:100%;height:100%}\n"] }]
+        }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['paneviewContainer', { static: true }]
+            }], components: [{
+                type: Input
+            }], headerComponents: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], hideBorders: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], disableAutoResizing: [{
+                type: Input
+            }], ready: [{
+                type: Output
+            }], drop: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paneview-angular.component.js","sourceRoot":"","sources":["../../../../src/lib/paneview/paneview-angular.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    ElementRef,\n    EventEmitter,\n    Injector,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    Type,\n    ViewChild,\n    ChangeDetectionStrategy,\n    OnChanges,\n    SimpleChanges,\n    EnvironmentInjector,\n    inject,\n} from '@angular/core';\nimport {\n    PaneviewApi,\n    PaneviewOptions,\n    PaneviewDropEvent,\n    createPaneview,\n    PROPERTY_KEYS_PANEVIEW,\n    PaneviewFrameworkOptions,\n    PaneviewComponentOptions,\n} from 'dockview-core';\nimport { AngularFrameworkComponentFactory } from '../utils/component-factory';\nimport { AngularLifecycleManager } from '../utils/lifecycle-utils';\nimport { PaneviewAngularReadyEvent } from './types';\nimport { AngularPanePart } from './angular-pane-part';\n\nexport interface PaneviewAngularOptions extends PaneviewOptions {\n    components: Record<string, Type<any>>;\n    headerComponents?: Record<string, Type<any>>;\n}\n\n@Component({\n    selector: 'dv-paneview',\n    standalone: true,\n    template: '<div #paneviewContainer class=\"paneview-container\"></div>',\n    styles: [\n        `\n            :host {\n                display: block;\n                width: 100%;\n                height: 100%;\n            }\n\n            .paneview-container {\n                width: 100%;\n                height: 100%;\n            }\n        `,\n    ],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class PaneviewAngularComponent implements OnInit, OnDestroy, OnChanges {\n    @ViewChild('paneviewContainer', { static: true })\n    private containerRef!: ElementRef<HTMLDivElement>;\n\n    @Input() components!: Record<string, Type<any>>;\n    @Input() headerComponents?: Record<string, Type<any>>;\n\n    // Core paneview options as inputs\n    @Input() className?: string;\n    @Input() orientation?: 'horizontal' | 'vertical';\n    @Input() hideBorders?: boolean;\n    @Input() debug?: boolean;\n    @Input() disableAutoResizing?: boolean;\n\n    @Output() ready = new EventEmitter<PaneviewAngularReadyEvent>();\n    @Output() drop = new EventEmitter<PaneviewDropEvent>();\n\n    private paneviewApi?: PaneviewApi;\n    private lifecycleManager = new AngularLifecycleManager();\n    private injector = inject(Injector);\n    private environmentInjector = inject(EnvironmentInjector);\n\n    ngOnInit(): void {\n        this.initializePaneview();\n    }\n\n    ngOnDestroy(): void {\n        this.lifecycleManager.destroy();\n        if (this.paneviewApi) {\n            this.paneviewApi.dispose();\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (this.paneviewApi) {\n            const coreChanges: Partial<PaneviewOptions> = {};\n            let hasChanges = false;\n\n            // Check for changes in core paneview properties\n            PROPERTY_KEYS_PANEVIEW.forEach((key) => {\n                if (changes[key] && !changes[key].isFirstChange()) {\n                    (coreChanges as any)[key] = changes[key].currentValue;\n                    hasChanges = true;\n                }\n            });\n\n            if (hasChanges) {\n                this.paneviewApi.updateOptions(coreChanges);\n            }\n        }\n    }\n\n    getPaneviewApi(): PaneviewApi | undefined {\n        return this.paneviewApi;\n    }\n\n    private initializePaneview(): void {\n        if (!this.components) {\n            throw new Error(\n                'PaneviewAngularComponent: components input is required'\n            );\n        }\n\n        const coreOptions = this.extractCoreOptions();\n        const frameworkOptions = this.createFrameworkOptions();\n\n        this.paneviewApi = createPaneview(this.containerRef.nativeElement, {\n            ...coreOptions,\n            ...frameworkOptions,\n        });\n\n        // Set up event listeners\n        this.setupEventListeners();\n\n        // Emit ready event\n        this.ready.emit({ api: this.paneviewApi });\n    }\n\n    private extractCoreOptions(): PaneviewOptions {\n        const coreOptions: Partial<PaneviewComponentOptions> = {};\n\n        PROPERTY_KEYS_PANEVIEW.forEach((key) => {\n            const value = (this as any)[key];\n            if (value !== undefined) {\n                (coreOptions as any)[key] = value;\n            }\n        });\n\n        return coreOptions as PaneviewOptions;\n    }\n\n    private createFrameworkOptions(): PaneviewFrameworkOptions {\n        const componentFactory = new AngularFrameworkComponentFactory(\n            this.components,\n            this.injector,\n            this.environmentInjector,\n            this.headerComponents\n        );\n\n        return {\n            createComponent: (options) => {\n                return componentFactory.createPaneviewComponent(options);\n            },\n            createHeaderComponent: this.headerComponents\n                ? (options) => {\n                      return new AngularPanePart(\n                          this.headerComponents![options.name],\n                          this.injector,\n                          this.environmentInjector\n                      );\n                  }\n                : undefined,\n        };\n    }\n\n    private setupEventListeners(): void {\n        if (!this.paneviewApi) {\n            return;\n        }\n\n        // Set up event subscriptions using lifecycle manager\n        const api = this.paneviewApi;\n\n        if (this.drop.observers.length > 0) {\n            const disposable = api.onDidDrop((event) => {\n                this.drop.emit(event);\n            });\n            this.lifecycleManager.addDisposable(disposable);\n        }\n    }\n}\n"]}

package/dist/esm2022/lib/paneview/types.mjs

@@ -0,0 +1,3 @@
+// Re-export commonly used types from dockview-core
+export { PaneviewApi } from 'dockview-core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3BhbmV2aWV3L3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWlCQSxtREFBbUQ7QUFDbkQsT0FBTyxFQUFFLFdBQVcsRUFBc0MsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQYW5ldmlld09wdGlvbnMsIFBhbmV2aWV3QXBpLCBQYW5ldmlld0Ryb3BFdmVudCB9IGZyb20gJ2RvY2t2aWV3LWNvcmUnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBhbmV2aWV3QW5ndWxhclJlYWR5RXZlbnQge1xuICAgIGFwaTogUGFuZXZpZXdBcGk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGFuZXZpZXdBbmd1bGFyT3B0aW9ucyBleHRlbmRzIFBhbmV2aWV3T3B0aW9ucyB7XG4gICAgY29tcG9uZW50czogUmVjb3JkPHN0cmluZywgVHlwZTxhbnk+PjtcbiAgICBoZWFkZXJDb21wb25lbnRzPzogUmVjb3JkPHN0cmluZywgVHlwZTxhbnk+Pjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQYW5ldmlld0FuZ3VsYXJFdmVudHMge1xuICAgIHJlYWR5OiBQYW5ldmlld0FuZ3VsYXJSZWFkeUV2ZW50O1xuICAgIGRyb3A6IFBhbmV2aWV3RHJvcEV2ZW50O1xufVxuXG4vLyBSZS1leHBvcnQgY29tbW9ubHkgdXNlZCB0eXBlcyBmcm9tIGRvY2t2aWV3LWNvcmVcbmV4cG9ydCB7IFBhbmV2aWV3QXBpLCBQYW5ldmlld0Ryb3BFdmVudCwgUGFuZXZpZXdPcHRpb25zIH0gZnJvbSAnZG9ja3ZpZXctY29yZSc7XG4iXX0=

package/dist/esm2022/lib/splitview/angular-splitview-panel.mjs

@@ -0,0 +1,24 @@
+import { SplitviewPanel } from 'dockview-core';
+import { AngularRenderer } from '../utils/angular-renderer';
+export class AngularSplitviewPanel extends SplitviewPanel {
+    constructor(id, component, angularComponent, injector, environmentInjector) {
+        super(id, component);
+        this.angularComponent = angularComponent;
+        this.injector = injector;
+        this.environmentInjector = environmentInjector;
+    }
+    getComponent() {
+        const renderer = new AngularRenderer({
+            component: this.angularComponent,
+            injector: this.injector,
+            environmentInjector: this.environmentInjector,
+        });
+        renderer.init({
+            params: this._params?.params ?? {},
+            api: this.api,
+        });
+        this.element.appendChild(renderer.element);
+        return renderer;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/splitview/splitview-angular.component.mjs

@@ -0,0 +1,98 @@
+import { Component, ElementRef, EventEmitter, Injector, Input, Output, ViewChild, ChangeDetectionStrategy, EnvironmentInjector, inject, } from '@angular/core';
+import { createSplitview, PROPERTY_KEYS_SPLITVIEW, } from 'dockview-core';
+import { AngularFrameworkComponentFactory } from '../utils/component-factory';
+import { AngularLifecycleManager } from '../utils/lifecycle-utils';
+import * as i0 from "@angular/core";
+export class SplitviewAngularComponent {
+    constructor() {
+        this.ready = new EventEmitter();
+        this.lifecycleManager = new AngularLifecycleManager();
+        this.injector = inject(Injector);
+        this.environmentInjector = inject(EnvironmentInjector);
+    }
+    ngOnInit() {
+        this.initializeSplitview();
+    }
+    ngOnDestroy() {
+        this.lifecycleManager.destroy();
+        if (this.splitviewApi) {
+            this.splitviewApi.dispose();
+        }
+    }
+    ngOnChanges(changes) {
+        if (this.splitviewApi) {
+            const coreChanges = {};
+            let hasChanges = false;
+            // Check for changes in core splitview properties
+            PROPERTY_KEYS_SPLITVIEW.forEach((key) => {
+                if (changes[key] && !changes[key].isFirstChange()) {
+                    coreChanges[key] = changes[key].currentValue;
+                    hasChanges = true;
+                }
+            });
+            if (hasChanges) {
+                this.splitviewApi.updateOptions(coreChanges);
+            }
+        }
+    }
+    getSplitviewApi() {
+        return this.splitviewApi;
+    }
+    initializeSplitview() {
+        if (!this.components) {
+            throw new Error('SplitviewAngularComponent: components input is required');
+        }
+        const coreOptions = this.extractCoreOptions();
+        const frameworkOptions = this.createFrameworkOptions();
+        this.splitviewApi = createSplitview(this.containerRef.nativeElement, {
+            ...coreOptions,
+            ...frameworkOptions,
+        });
+        // Emit ready event
+        this.ready.emit({ api: this.splitviewApi });
+    }
+    extractCoreOptions() {
+        const coreOptions = {};
+        PROPERTY_KEYS_SPLITVIEW.forEach((key) => {
+            const value = this[key];
+            if (value !== undefined) {
+                coreOptions[key] = value;
+            }
+        });
+        return coreOptions;
+    }
+    createFrameworkOptions() {
+        const componentFactory = new AngularFrameworkComponentFactory(this.components, this.injector, this.environmentInjector);
+        return {
+            createComponent: (options) => {
+                return componentFactory.createSplitviewComponent(options);
+            },
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SplitviewAngularComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SplitviewAngularComponent, isStandalone: true, selector: "dv-splitview", inputs: { components: "components", className: "className", orientation: "orientation", proportionalLayout: "proportionalLayout", hideBorders: "hideBorders", debug: "debug", disableAutoResizing: "disableAutoResizing" }, outputs: { ready: "ready" }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["splitviewContainer"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: '<div #splitviewContainer class="splitview-container"></div>', isInline: true, styles: [":host{display:block;width:100%;height:100%}.splitview-container{width:100%;height:100%}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SplitviewAngularComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dv-splitview', standalone: true, template: '<div #splitviewContainer class="splitview-container"></div>', changeDetection: ChangeDetectionStrategy.OnPush, styles: [":host{display:block;width:100%;height:100%}.splitview-container{width:100%;height:100%}\n"] }]
+        }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['splitviewContainer', { static: true }]
+            }], components: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], orientation: [{
+                type: Input
+            }], proportionalLayout: [{
+                type: Input
+            }], hideBorders: [{
+                type: Input
+            }], debug: [{
+                type: Input
+            }], disableAutoResizing: [{
+                type: Input
+            }], ready: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"splitview-angular.component.js","sourceRoot":"","sources":["../../../../src/lib/splitview/splitview-angular.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    ElementRef,\n    EventEmitter,\n    Injector,\n    Input,\n    OnDestroy,\n    OnInit,\n    Output,\n    Type,\n    ViewChild,\n    ChangeDetectionStrategy,\n    OnChanges,\n    SimpleChanges,\n    EnvironmentInjector,\n    inject,\n} from '@angular/core';\nimport {\n    SplitviewApi,\n    SplitviewOptions,\n    createSplitview,\n    PROPERTY_KEYS_SPLITVIEW,\n    SplitviewFrameworkOptions,\n    SplitviewComponentOptions,\n} from 'dockview-core';\nimport { AngularFrameworkComponentFactory } from '../utils/component-factory';\nimport { AngularLifecycleManager } from '../utils/lifecycle-utils';\nimport { SplitviewAngularReadyEvent } from './types';\n\nexport interface SplitviewAngularOptions extends SplitviewOptions {\n    components: Record<string, Type<any>>;\n}\n\n@Component({\n    selector: 'dv-splitview',\n    standalone: true,\n    template: '<div #splitviewContainer class=\"splitview-container\"></div>',\n    styles: [\n        `\n            :host {\n                display: block;\n                width: 100%;\n                height: 100%;\n            }\n\n            .splitview-container {\n                width: 100%;\n                height: 100%;\n            }\n        `,\n    ],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SplitviewAngularComponent implements OnInit, OnDestroy, OnChanges {\n    @ViewChild('splitviewContainer', { static: true })\n    private containerRef!: ElementRef<HTMLDivElement>;\n\n    @Input() components!: Record<string, Type<any>>;\n\n    // Core splitview options as inputs\n    @Input() className?: string;\n    @Input() orientation?: 'horizontal' | 'vertical';\n    @Input() proportionalLayout?: boolean;\n    @Input() hideBorders?: boolean;\n    @Input() debug?: boolean;\n    @Input() disableAutoResizing?: boolean;\n\n    @Output() ready = new EventEmitter<SplitviewAngularReadyEvent>();\n\n    private splitviewApi?: SplitviewApi;\n    private lifecycleManager = new AngularLifecycleManager();\n    private injector = inject(Injector);\n    private environmentInjector = inject(EnvironmentInjector);\n\n    ngOnInit(): void {\n        this.initializeSplitview();\n    }\n\n    ngOnDestroy(): void {\n        this.lifecycleManager.destroy();\n        if (this.splitviewApi) {\n            this.splitviewApi.dispose();\n        }\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        if (this.splitviewApi) {\n            const coreChanges: Partial<SplitviewOptions> = {};\n            let hasChanges = false;\n\n            // Check for changes in core splitview properties\n            PROPERTY_KEYS_SPLITVIEW.forEach((key) => {\n                if (changes[key] && !changes[key].isFirstChange()) {\n                    (coreChanges as any)[key] = changes[key].currentValue;\n                    hasChanges = true;\n                }\n            });\n\n            if (hasChanges) {\n                this.splitviewApi.updateOptions(coreChanges);\n            }\n        }\n    }\n\n    getSplitviewApi(): SplitviewApi | undefined {\n        return this.splitviewApi;\n    }\n\n    private initializeSplitview(): void {\n        if (!this.components) {\n            throw new Error(\n                'SplitviewAngularComponent: components input is required'\n            );\n        }\n\n        const coreOptions = this.extractCoreOptions();\n        const frameworkOptions = this.createFrameworkOptions();\n\n        this.splitviewApi = createSplitview(this.containerRef.nativeElement, {\n            ...coreOptions,\n            ...frameworkOptions,\n        });\n\n        // Emit ready event\n        this.ready.emit({ api: this.splitviewApi });\n    }\n\n    private extractCoreOptions(): SplitviewOptions {\n        const coreOptions: Partial<SplitviewComponentOptions> = {};\n\n        PROPERTY_KEYS_SPLITVIEW.forEach((key) => {\n            const value = (this as any)[key];\n            if (value !== undefined) {\n                (coreOptions as any)[key] = value;\n            }\n        });\n\n        return coreOptions as SplitviewOptions;\n    }\n\n    private createFrameworkOptions(): SplitviewFrameworkOptions {\n        const componentFactory = new AngularFrameworkComponentFactory(\n            this.components,\n            this.injector,\n            this.environmentInjector\n        );\n\n        return {\n            createComponent: (options) => {\n                return componentFactory.createSplitviewComponent(options);\n            },\n        };\n    }\n}\n"]}

package/dist/esm2022/lib/splitview/types.mjs

@@ -0,0 +1,3 @@
+// Re-export commonly used types from dockview-core
+export { SplitviewApi } from 'dockview-core';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NwbGl0dmlldy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFlQSxtREFBbUQ7QUFDbkQsT0FBTyxFQUFFLFlBQVksRUFBb0IsTUFBTSxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUeXBlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTcGxpdHZpZXdPcHRpb25zLCBTcGxpdHZpZXdBcGkgfSBmcm9tICdkb2Nrdmlldy1jb3JlJztcblxuZXhwb3J0IGludGVyZmFjZSBTcGxpdHZpZXdBbmd1bGFyUmVhZHlFdmVudCB7XG4gICAgYXBpOiBTcGxpdHZpZXdBcGk7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU3BsaXR2aWV3QW5ndWxhck9wdGlvbnMgZXh0ZW5kcyBTcGxpdHZpZXdPcHRpb25zIHtcbiAgICBjb21wb25lbnRzOiBSZWNvcmQ8c3RyaW5nLCBUeXBlPGFueT4+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNwbGl0dmlld0FuZ3VsYXJFdmVudHMge1xuICAgIHJlYWR5OiBTcGxpdHZpZXdBbmd1bGFyUmVhZHlFdmVudDtcbn1cblxuLy8gUmUtZXhwb3J0IGNvbW1vbmx5IHVzZWQgdHlwZXMgZnJvbSBkb2Nrdmlldy1jb3JlXG5leHBvcnQgeyBTcGxpdHZpZXdBcGksIFNwbGl0dmlld09wdGlvbnMgfSBmcm9tICdkb2Nrdmlldy1jb3JlJztcbiJdfQ==

package/dist/esm2022/lib/utils/angular-renderer.mjs

@@ -0,0 +1,83 @@
+import { createComponent, ApplicationRef, } from '@angular/core';
+export class AngularRenderer {
+    constructor(options) {
+        this.options = options;
+        this.componentRef = null;
+        this._element = null;
+        this.appRef = options.injector.get(ApplicationRef);
+    }
+    get element() {
+        if (!this._element) {
+            throw new Error('Angular renderer not initialized');
+        }
+        return this._element;
+    }
+    get component() {
+        return this.componentRef;
+    }
+    init(parameters) {
+        // Only forward params, api, and containerApi to the component
+        // (matching the React renderer). Other init parameters like
+        // 'title' are internal to the framework.
+        const filtered = {};
+        if ('params' in parameters) {
+            filtered['params'] = parameters['params'];
+        }
+        if ('api' in parameters) {
+            filtered['api'] = parameters['api'];
+        }
+        if ('containerApi' in parameters) {
+            filtered['containerApi'] = parameters['containerApi'];
+        }
+        if (this.componentRef) {
+            this.update(filtered);
+        }
+        else {
+            this.render(filtered);
+        }
+    }
+    update(params) {
+        if (!this.componentRef) {
+            return;
+        }
+        const instance = this.componentRef.instance;
+        for (const key of Object.keys(params)) {
+            if (key in instance) {
+                instance[key] = params[key];
+            }
+        }
+        // trigger change detection
+        this.componentRef.changeDetectorRef.markForCheck();
+    }
+    render(parameters) {
+        try {
+            // Create the component using modern Angular API
+            this.componentRef = createComponent(this.options.component, {
+                environmentInjector: this.options.environmentInjector ||
+                    this.options.injector,
+                elementInjector: this.options.injector,
+            });
+            // Set initial parameters
+            this.update(parameters);
+            // Get the DOM element
+            const hostView = this.componentRef.hostView;
+            this._element = hostView.rootNodes[0];
+            // attach to change detection
+            this.appRef.attachView(hostView);
+            // trigger change detection
+            this.componentRef.changeDetectorRef.markForCheck();
+        }
+        catch (error) {
+            console.error('Error creating Angular component:', error);
+            throw error;
+        }
+    }
+    dispose() {
+        if (this.componentRef) {
+            this.componentRef.destroy();
+            this.componentRef = null;
+        }
+        this._element = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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