@toolbox-web/grid-angular 0.7.0 → 0.7.2

package/lib/angular-column-config.d.ts

@@ -1,140 +0,0 @@
-import { Type } from '@angular/core';
-import { ColumnConfig, GridConfig } from '@toolbox-web/grid';
-/**
- * Interface for Angular renderer components.
- *
- * Renderer components receive the cell value, row data, and column config as inputs.
- * Use Angular signal inputs for reactive updates.
- *
- * @example
- * ```typescript
- * import { Component, input } from '@angular/core';
- * import type { AngularCellRenderer } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-status-badge',
- *   template: `<span [class]="'badge-' + value()">{{ value() }}</span>`
- * })
- * export class StatusBadgeComponent implements AngularCellRenderer<Employee, string> {
- *   value = input.required<string>();
- *   row = input.required<Employee>();
- *   column = input<unknown>();
- * }
- * ```
- */
-export interface AngularCellRenderer<TRow = unknown, TValue = unknown> {
-    /** The cell value - use `input<TValue>()` or `input.required<TValue>()` */
-    value: {
-        (): TValue | undefined;
-    };
-    /** The full row data - use `input<TRow>()` or `input.required<TRow>()` */
-    row: {
-        (): TRow | undefined;
-    };
-    /** The column configuration (optional) - use `input<unknown>()` */
-    column?: {
-        (): unknown;
-    };
-}
-/**
- * Interface for Angular editor components.
- *
- * Editor components receive the cell value, row data, and column config as inputs,
- * plus must emit `commit` and `cancel` outputs.
- *
- * @example
- * ```typescript
- * import { Component, input, output } from '@angular/core';
- * import type { AngularCellEditor } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-status-editor',
- *   template: `
- *     <select [value]="value()" (change)="commit.emit($any($event.target).value)">
- *       <option value="active">Active</option>
- *       <option value="inactive">Inactive</option>
- *     </select>
- *   `
- * })
- * export class StatusEditorComponent implements AngularCellEditor<Employee, string> {
- *   value = input.required<string>();
- *   row = input.required<Employee>();
- *   column = input<unknown>();
- *   commit = output<string>();
- *   cancel = output<void>();
- * }
- * ```
- */
-export interface AngularCellEditor<TRow = unknown, TValue = unknown> extends AngularCellRenderer<TRow, TValue> {
-    /** Emit to commit the new value - use `output<TValue>()` */
-    commit: {
-        emit(value: TValue): void;
-        subscribe?(fn: (value: TValue) => void): {
-            unsubscribe(): void;
-        };
-    };
-    /** Emit to cancel editing - use `output<void>()` */
-    cancel: {
-        emit(): void;
-        subscribe?(fn: () => void): {
-            unsubscribe(): void;
-        };
-    };
-}
-/**
- * Angular-specific column configuration.
- *
- * Extends the base ColumnConfig to allow Angular component classes
- * to be used directly as renderers and editors.
- *
- * @example
- * ```typescript
- * import type { AngularColumnConfig } from '@toolbox-web/grid-angular';
- * import { StatusBadgeComponent, StatusEditorComponent } from './components';
- *
- * const columns: AngularColumnConfig<Employee>[] = [
- *   { field: 'name', header: 'Name' },
- *   {
- *     field: 'status',
- *     header: 'Status',
- *     editable: true,
- *     renderer: StatusBadgeComponent,
- *     editor: StatusEditorComponent,
- *   },
- * ];
- * ```
- */
-export interface AngularColumnConfig<TRow = unknown> extends Omit<ColumnConfig<TRow>, 'renderer' | 'editor'> {
-    /**
-     * Cell renderer - can be:
-     * - A function `(ctx) => HTMLElement | string`
-     * - An Angular component class implementing AngularCellRenderer
-     */
-    renderer?: ColumnConfig<TRow>['renderer'] | Type<AngularCellRenderer<TRow, unknown>>;
-    /**
-     * Cell editor - can be:
-     * - A function `(ctx) => HTMLElement`
-     * - An Angular component class implementing AngularCellEditor
-     */
-    editor?: ColumnConfig<TRow>['editor'] | Type<AngularCellEditor<TRow, unknown>>;
-}
-/**
- * Angular-specific grid configuration.
- *
- * Extends the base GridConfig to use AngularColumnConfig.
- */
-export interface AngularGridConfig<TRow = unknown> extends Omit<GridConfig<TRow>, 'columns'> {
-    columns?: AngularColumnConfig<TRow>[];
-}
-/**
- * Type guard to check if a value is an Angular component class.
- *
- * Detects Angular components by checking for internal Angular markers:
- * - ɵcmp (component definition)
- * - ɵfac (factory function)
- *
- * Also checks if it's an ES6 class (vs function) by inspecting the
- * string representation.
- */
-export declare function isComponentClass(value: unknown): value is Type<unknown>;
-//# sourceMappingURL=angular-column-config.d.ts.map

package/lib/angular-column-config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular-column-config.d.ts","sourceRoot":"","sources":["../../../../libs/grid-angular/src/lib/angular-column-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,mBAAmB,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO;IACnE,2EAA2E;IAC3E,KAAK,EAAE;QAAE,IAAI,MAAM,GAAG,SAAS,CAAA;KAAE,CAAC;IAClC,0EAA0E;IAC1E,GAAG,EAAE;QAAE,IAAI,IAAI,GAAG,SAAS,CAAA;KAAE,CAAC;IAC9B,mEAAmE;IACnE,MAAM,CAAC,EAAE;QAAE,IAAI,OAAO,CAAA;KAAE,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,WAAW,iBAAiB,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,CAAE,SAAQ,mBAAmB,CAAC,IAAI,EAAE,MAAM,CAAC;IAC5G,4DAA4D;IAC5D,MAAM,EAAE;QAAE,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG;YAAE,WAAW,IAAI,IAAI,CAAA;SAAE,CAAA;KAAE,CAAC;IACxG,oDAAoD;IACpD,MAAM,EAAE;QAAE,IAAI,IAAI,IAAI,CAAC;QAAC,SAAS,CAAC,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG;YAAE,WAAW,IAAI,IAAI,CAAA;SAAE,CAAA;KAAE,CAAC;CAC/E;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,mBAAmB,CAAC,IAAI,GAAG,OAAO,CAAE,SAAQ,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,UAAU,GAAG,QAAQ,CAAC;IAC1G;;;;OAIG;IACH,QAAQ,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAErF;;;;OAIG;IACH,MAAM,CAAC,EAAE,YAAY,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;CAChF;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,IAAI,GAAG,OAAO,CAAE,SAAQ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1F,OAAO,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,IAAI,CAAC,OAAO,CAAC,CAcvE"}

package/lib/angular-grid-adapter.d.ts

@@ -1,220 +0,0 @@
-import { ApplicationRef, EnvironmentInjector, ViewContainerRef } from '@angular/core';
-import { ColumnConfig, ColumnEditorSpec, ColumnViewRenderer, FrameworkAdapter, GridConfig, TypeDefault } from '@toolbox-web/grid';
-import { AngularColumnConfig, AngularGridConfig } from './angular-column-config';
-/**
- * Framework adapter that enables zero-boilerplate integration of Angular components
- * with the grid's light DOM configuration API.
- *
- * ## Usage
- *
- * **One-time setup in your app:**
- * ```typescript
- * import { Component, inject, EnvironmentInjector, ApplicationRef, ViewContainerRef } from '@angular/core';
- * import { GridElement } from '@toolbox-web/grid';
- * import { AngularGridAdapter } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-root',
- *   // ...
- * })
- * export class AppComponent {
- *   constructor() {
- *     const injector = inject(EnvironmentInjector);
- *     const appRef = inject(ApplicationRef);
- *     const viewContainerRef = inject(ViewContainerRef);
- *     GridElement.registerAdapter(new AngularGridAdapter(injector, appRef, viewContainerRef));
- *   }
- * }
- * ```
- *
- * **Declarative configuration in templates (structural directive - recommended):**
- * ```html
- * <tbw-grid>
- *   <tbw-grid-column field="status">
- *     <app-status-badge *tbwRenderer="let value; row as row" [value]="value" />
- *     <app-status-editor *tbwEditor="let value" [value]="value" />
- *   </tbw-grid-column>
- * </tbw-grid>
- * ```
- *
- * **Declarative configuration in templates (nested directive - legacy):**
- * ```html
- * <tbw-grid>
- *   <tbw-grid-column field="status">
- *     <tbw-grid-column-view>
- *       <ng-template let-value let-row="row">
- *         <app-status-badge [value]="value" [row]="row" />
- *       </ng-template>
- *     </tbw-grid-column-view>
- *     <tbw-grid-column-editor>
- *       <ng-template let-value let-onCommit="onCommit" let-onCancel="onCancel">
- *         <app-status-select [value]="value" (commit)="onCommit($event)" (cancel)="onCancel()" />
- *       </ng-template>
- *     </tbw-grid-column-editor>
- *   </tbw-grid-column>
- * </tbw-grid>
- * ```
- *
- * The adapter automatically:
- * - Detects Angular templates registered by directives (both structural and nested)
- * - Creates embedded views with cell context (value, row, column)
- * - Handles editor callbacks (onCommit/onCancel)
- * - Manages view lifecycle and change detection
- */
-export declare class AngularGridAdapter implements FrameworkAdapter {
-    private injector;
-    private appRef;
-    private viewContainerRef;
-    private viewRefs;
-    private componentRefs;
-    private typeRegistry;
-    constructor(injector: EnvironmentInjector, appRef: ApplicationRef, viewContainerRef: ViewContainerRef);
-    /**
-     * Processes an Angular grid configuration, converting component class references
-     * to actual renderer/editor functions.
-     *
-     * Call this method on your gridConfig before passing it to the grid.
-     *
-     * @example
-     * ```typescript
-     * import { AngularGridAdapter, type AngularGridConfig } from '@toolbox-web/grid-angular';
-     *
-     * const config: AngularGridConfig<Employee> = {
-     *   columns: [
-     *     { field: 'status', renderer: StatusBadgeComponent, editor: StatusEditorComponent },
-     *   ],
-     * };
-     *
-     * // In component
-     * constructor() {
-     *   const adapter = inject(AngularGridAdapter); // or create new instance
-     *   this.processedConfig = adapter.processGridConfig(config);
-     * }
-     * ```
-     *
-     * @param config - Angular grid configuration with possible component class references
-     * @returns Processed GridConfig with actual renderer/editor functions
-     */
-    processGridConfig<TRow = unknown>(config: AngularGridConfig<TRow>): GridConfig<TRow>;
-    /**
-     * Processes a single column configuration, converting component class references
-     * to actual renderer/editor functions.
-     *
-     * @param column - Angular column configuration
-     * @returns Processed ColumnConfig
-     */
-    processColumn<TRow = unknown>(column: AngularColumnConfig<TRow>): ColumnConfig<TRow>;
-    /**
-     * Determines if this adapter can handle the given element.
-     * Checks if a template is registered for this element (structural or nested).
-     */
-    canHandle(element: HTMLElement): boolean;
-    /**
-     * Creates a view renderer function that creates an embedded view
-     * from the registered template and returns its DOM element.
-     *
-     * Returns undefined if no template is registered for this element,
-     * allowing the grid to use its default rendering.
-     */
-    createRenderer<TRow = unknown, TValue = unknown>(element: HTMLElement): ColumnViewRenderer<TRow, TValue>;
-    /**
-     * Creates an editor spec that creates an embedded view.
-     *
-     * **Auto-wiring**: The adapter automatically listens for `commit` and `cancel`
-     * CustomEvents on the rendered component. If the component emits these events,
-     * the adapter will call the grid's commit/cancel functions automatically.
-     *
-     * This means templates can be simplified from:
-     * ```html
-     * <app-editor *tbwEditor="let value; onCommit as onCommit"
-     *   [value]="value" (commit)="onCommit($event)" />
-     * ```
-     * To just:
-     * ```html
-     * <app-editor *tbwEditor="let value" [value]="value" />
-     * ```
-     * As long as the component emits `(commit)` with the new value.
-     */
-    createEditor<TRow = unknown, TValue = unknown>(element: HTMLElement): ColumnEditorSpec<TRow, TValue>;
-    /**
-     * Creates a detail renderer function for MasterDetailPlugin.
-     * Renders Angular templates for expandable detail rows.
-     */
-    createDetailRenderer<TRow = unknown>(gridElement: HTMLElement): ((row: TRow) => HTMLElement) | undefined;
-    /**
-     * Framework adapter hook called by MasterDetailPlugin during attach().
-     * Parses the <tbw-grid-detail> element and returns an Angular template-based renderer.
-     *
-     * This enables MasterDetailPlugin to automatically use Angular templates
-     * without manual configuration in the Grid directive.
-     */
-    parseDetailElement<TRow = unknown>(detailElement: Element): ((row: TRow, rowIndex: number) => HTMLElement | string) | undefined;
-    /**
-     * Creates a responsive card renderer function for ResponsivePlugin.
-     * Renders Angular templates for card layout in responsive mode.
-     *
-     * @param gridElement - The grid element to look up the template for
-     * @returns A card renderer function or undefined if no template is found
-     */
-    createResponsiveCardRenderer<TRow = unknown>(gridElement: HTMLElement): ((row: TRow, rowIndex: number) => HTMLElement) | undefined;
-    /**
-     * Creates a tool panel renderer from a light DOM element.
-     * The renderer creates an Angular template-based panel content.
-     */
-    createToolPanelRenderer(element: HTMLElement): ((container: HTMLElement) => void | (() => void)) | undefined;
-    /**
-     * Gets type-level defaults from the application's GridTypeRegistry.
-     *
-     * This enables application-wide type defaults configured via `provideGridTypeDefaults()`.
-     * The returned TypeDefault contains renderer/editor functions that instantiate
-     * Angular components dynamically.
-     *
-     * @example
-     * ```typescript
-     * // app.config.ts
-     * export const appConfig: ApplicationConfig = {
-     *   providers: [
-     *     provideGridTypeDefaults({
-     *       country: {
-     *         renderer: CountryCellComponent,
-     *         editor: CountryEditorComponent
-     *       }
-     *     })
-     *   ]
-     * };
-     *
-     * // Any grid with type: 'country' columns will use these components
-     * gridConfig = {
-     *   columns: [{ field: 'country', type: 'country' }]
-     * };
-     * ```
-     */
-    getTypeDefault<TRow = unknown>(type: string): TypeDefault<TRow> | undefined;
-    /**
-     * Creates a renderer function from an Angular component class.
-     * @internal
-     */
-    private createComponentRenderer;
-    /**
-     * Creates an editor function from an Angular component class.
-     * @internal
-     */
-    private createComponentEditor;
-    /**
-     * Subscribes to an Angular output on a component instance.
-     * Works with both EventEmitter and OutputEmitterRef (signal outputs).
-     * @internal
-     */
-    private subscribeToOutput;
-    /**
-     * Sets component inputs using Angular's setInput API.
-     * @internal
-     */
-    private setComponentInputs;
-    /**
-     * Clean up all view references and component references.
-     * Call this when your app/component is destroyed.
-     */
-    destroy(): void;
-}
-//# sourceMappingURL=angular-grid-adapter.d.ts.map

package/lib/angular-grid-adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"angular-grid-adapter.d.ts","sourceRoot":"","sources":["../../../../libs/grid-angular/src/lib/angular-grid-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EAId,mBAAmB,EAInB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAEV,YAAY,EAEZ,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,UAAU,EACV,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAoB,KAAK,mBAAmB,EAAE,KAAK,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAmC7G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,qBAAa,kBAAmB,YAAW,gBAAgB;IAMvD,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,gBAAgB;IAP1B,OAAO,CAAC,QAAQ,CAAkC;IAClD,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,YAAY,CAAiC;gBAG3C,QAAQ,EAAE,mBAAmB,EAC7B,MAAM,EAAE,cAAc,EACtB,gBAAgB,EAAE,gBAAgB;IAc5C;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,iBAAiB,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,EAAE,iBAAiB,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC;IAapF;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,EAAE,mBAAmB,CAAC,IAAI,CAAC,GAAG,YAAY,CAAC,IAAI,CAAC;IAgBpF;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO;IAIxC;;;;;;OAMG;IACH,cAAc,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,WAAW,GAAG,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC;IA+BxG;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO,EAAE,OAAO,EAAE,WAAW,GAAG,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC;IAmFpG;;;OAGG;IACH,oBAAoB,CAAC,IAAI,GAAG,OAAO,EAAE,WAAW,EAAE,WAAW,GAAG,CAAC,CAAC,GAAG,EAAE,IAAI,KAAK,WAAW,CAAC,GAAG,SAAS;IA4BxG;;;;;;OAMG;IACH,kBAAkB,CAAC,IAAI,GAAG,OAAO,EAC/B,aAAa,EAAE,OAAO,GACrB,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,KAAK,WAAW,GAAG,MAAM,CAAC,GAAG,SAAS;IA4BtE;;;;;;OAMG;IACH,4BAA4B,CAAC,IAAI,GAAG,OAAO,EACzC,WAAW,EAAE,WAAW,GACvB,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,KAAK,WAAW,CAAC,GAAG,SAAS;IA6B7D;;;OAGG;IACH,uBAAuB,CAAC,OAAO,EAAE,WAAW,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,KAAK,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,SAAS;IAsC5G;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,cAAc,CAAC,IAAI,GAAG,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,GAAG,SAAS;IA4B3E;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAgC/B;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IA+C7B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAczB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;OAGG;IACH,OAAO,IAAI,IAAI;CAMhB"}

package/lib/base-grid-editor.d.ts

@@ -1,145 +0,0 @@
-import { AbstractControl } from '@angular/forms';
-import { ColumnConfig } from '@toolbox-web/grid';
-/**
- * Base class for grid cell editors.
- *
- * Provides common functionality for Angular cell editors:
- * - Automatic value resolution from FormControl or value input
- * - Common inputs (value, row, column, control)
- * - Common outputs (commit, cancel)
- * - Validation state helpers
- *
- * ## Usage
- *
- * ```typescript
- * import { Component } from '@angular/core';
- * import { BaseGridEditor } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-my-editor',
- *   template: \`
- *     <input
- *       [value]="currentValue()"
- *       [class.is-invalid]="isInvalid()"
- *       (input)="commitValue($event.target.value)"
- *       (keydown.escape)="cancelEdit()"
- *     />
- *     @if (hasErrors()) {
- *       <div class="error">{{ firstErrorMessage() }}</div>
- *     }
- *   \`
- * })
- * export class MyEditorComponent extends BaseGridEditor<MyRow, string> {
- *   // Override to customize error messages
- *   protected override getErrorMessage(errorKey: string): string {
- *     if (errorKey === 'required') return 'This field is required';
- *     if (errorKey === 'minlength') return 'Too short';
- *     return super.getErrorMessage(errorKey);
- *   }
- * }
- * ```
- *
- * ## Template Syntax
- *
- * When using the base class, you only need to pass the control:
- *
- * ```html
- * <tbw-grid-column field="name">
- *   <app-my-editor *tbwEditor="let _; control as control" [control]="control" />
- * </tbw-grid-column>
- * ```
- *
- * Or without FormArray binding (fallback to value):
- *
- * ```html
- * <tbw-grid-column field="name">
- *   <app-my-editor *tbwEditor="let value" [value]="value" />
- * </tbw-grid-column>
- * ```
- *
- * @typeParam TRow - The row data type
- * @typeParam TValue - The cell value type
- */
-export declare abstract class BaseGridEditor<TRow = unknown, TValue = unknown> {
-    private readonly elementRef;
-    /**
-     * The cell value. Used when FormControl is not available.
-     * When a FormControl is provided, value is derived from control.value instead.
-     */
-    readonly value: import('@angular/core').InputSignal<TValue | undefined>;
-    /**
-     * The full row data object.
-     */
-    readonly row: import('@angular/core').InputSignal<TRow | undefined>;
-    /**
-     * The column configuration.
-     */
-    readonly column: import('@angular/core').InputSignal<ColumnConfig<TRow> | undefined>;
-    /**
-     * The FormControl for this cell, if the grid is bound to a FormArray.
-     * When provided, the editor uses control.value instead of the value input.
-     */
-    readonly control: import('@angular/core').InputSignal<AbstractControl<any, any, any> | undefined>;
-    /**
-     * Emits when the user commits a new value.
-     */
-    readonly commit: import('@angular/core').OutputEmitterRef<TValue>;
-    /**
-     * Emits when the user cancels editing.
-     */
-    readonly cancel: import('@angular/core').OutputEmitterRef<void>;
-    /**
-     * The current value, derived from FormControl if available, otherwise from value input.
-     * This is the recommended way to get the current value in your editor template.
-     */
-    readonly currentValue: import('@angular/core').Signal<TValue | undefined>;
-    /**
-     * Whether the control is invalid (has validation errors).
-     * Returns false if no FormControl is available.
-     */
-    readonly isInvalid: import('@angular/core').Signal<boolean>;
-    /**
-     * Whether the control is dirty (has been modified).
-     * Returns false if no FormControl is available.
-     */
-    readonly isDirty: import('@angular/core').Signal<boolean>;
-    /**
-     * Whether the control has been touched.
-     * Returns false if no FormControl is available.
-     */
-    readonly isTouched: import('@angular/core').Signal<boolean>;
-    /**
-     * Whether the control has any validation errors.
-     */
-    readonly hasErrors: import('@angular/core').Signal<boolean>;
-    /**
-     * The first error message from the control's validation errors.
-     * Returns an empty string if no errors.
-     */
-    readonly firstErrorMessage: import('@angular/core').Signal<string>;
-    /**
-     * All error messages from the control's validation errors.
-     */
-    readonly allErrorMessages: import('@angular/core').Signal<string[]>;
-    /**
-     * Commit a new value. Emits the commit output AND dispatches a DOM event.
-     * The DOM event enables the grid's auto-wiring to catch the commit.
-     * Call this when the user confirms their edit.
-     */
-    commitValue(newValue: TValue): void;
-    /**
-     * Cancel editing. Emits the cancel output AND dispatches a DOM event.
-     * Call this when the user cancels (e.g., presses Escape).
-     */
-    cancelEdit(): void;
-    /**
-     * Get a human-readable error message for a validation error.
-     * Override this method to customize error messages for your editor.
-     *
-     * @param errorKey - The validation error key (e.g., 'required', 'minlength')
-     * @param errorValue - The error value (e.g., { requiredLength: 5, actualLength: 3 })
-     * @returns A human-readable error message
-     */
-    protected getErrorMessage(errorKey: string, errorValue?: unknown): string;
-}
-//# sourceMappingURL=base-grid-editor.d.ts.map

package/lib/base-grid-editor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-grid-editor.d.ts","sourceRoot":"","sources":["../../../../libs/grid-angular/src/lib/base-grid-editor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,8BACsB,cAAc,CAAC,IAAI,GAAG,OAAO,EAAE,MAAM,GAAG,OAAO;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IAMjD;;;OAGG;IACH,QAAQ,CAAC,KAAK,0DAAmB;IAEjC;;OAEG;IACH,QAAQ,CAAC,GAAG,wDAAiB;IAE7B;;OAEG;IACH,QAAQ,CAAC,MAAM,sEAA+B;IAE9C;;;OAGG;IACH,QAAQ,CAAC,OAAO,kFAA4B;IAM5C;;OAEG;IACH,QAAQ,CAAC,MAAM,mDAAoB;IAEnC;;OAEG;IACH,QAAQ,CAAC,MAAM,iDAAkB;IAMjC;;;OAGG;IACH,QAAQ,CAAC,YAAY,qDAMlB;IAEH;;;OAGG;IACH,QAAQ,CAAC,SAAS,0CAEf;IAEH;;;OAGG;IACH,QAAQ,CAAC,OAAO,0CAEb;IAEH;;;OAGG;IACH,QAAQ,CAAC,SAAS,0CAEf;IAEH;;OAEG;IACH,QAAQ,CAAC,SAAS,0CAGf;IAEH;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,yCAMvB;IAEH;;OAEG;IACH,QAAQ,CAAC,gBAAgB,2CAKtB;IAMH;;;;OAIG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IASnC;;;OAGG;IACH,UAAU,IAAI,IAAI;IAQlB;;;;;;;OAOG;IACH,SAAS,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM;CA4B1E"}

package/lib/component-registry.d.ts

@@ -1,63 +0,0 @@
-import { Type } from '@angular/core';
-/**
- * Register an Angular component as a grid cell renderer.
- * Call this at module level (outside the class) to register on import.
- *
- * @example
- * ```typescript
- * import { Component, input } from '@angular/core';
- * import { registerGridRenderer, GridCellRenderer } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-status-badge',
- *   template: `<span [class]="'status-' + value()">{{ value() }}</span>`,
- * })
- * export class StatusBadgeComponent implements GridCellRenderer<string> {
- *   value = input.required<string>();
- *   row = input<unknown>();
- * }
- *
- * // Register at module level - runs when file is imported
- * registerGridRenderer('app-status-badge', StatusBadgeComponent);
- * ```
- */
-export declare function registerGridRenderer(tagName: string, componentType: Type<unknown>): void;
-/**
- * Register an Angular component as a grid cell editor.
- * Call this at module level (outside the class) to register on import.
- *
- * @example
- * ```typescript
- * import { Component, input, output } from '@angular/core';
- * import { registerGridEditor, GridCellEditor } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-status-select',
- *   template: `<select [value]="value()" (change)="onChange($event)">...</select>`,
- * })
- * export class StatusSelectComponent implements GridCellEditor<string> {
- *   value = input.required<string>();
- *   commit = output<string>();
- *   cancel = output<void>();
- *
- *   onChange(e: Event) {
- *     this.commit.emit((e.target as HTMLSelectElement).value);
- *   }
- * }
- *
- * // Register at module level - runs when file is imported
- * registerGridEditor('app-status-select', StatusSelectComponent);
- * ```
- */
-export declare function registerGridEditor(tagName: string, componentType: Type<unknown>): void;
-/**
- * Get a registered component by tag name.
- * Used internally by AngularGridAdapter.
- */
-export declare function getRegisteredComponent(tagName: string): Type<unknown> | undefined;
-/**
- * Get all registered components.
- * Used internally by AngularGridAdapter.
- */
-export declare function getAllRegisteredComponents(): Map<string, Type<unknown>>;
-//# sourceMappingURL=component-registry.d.ts.map

package/lib/component-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"component-registry.d.ts","sourceRoot":"","sources":["../../../../libs/grid-angular/src/lib/component-registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAmCrC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAExF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI,CAEtF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,SAAS,CAEjF;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,IAAI,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAEvE"}