@toolbox-web/grid 0.2.8 → 0.3.1

package/lib/core/plugin/base-plugin.d.ts

@@ -0,0 +1,616 @@
+import { ColumnConfig, ColumnState, GridPlugin, HeaderContentDefinition, IconValue, ToolPanelDefinition, DEFAULT_GRID_ICONS } from '../types';
+import { CellClickEvent, CellEditor, CellMouseEvent, CellRenderer, GridElementRef, HeaderClickEvent, HeaderRenderer, PluginQuery, RowClickEvent, ScrollEvent } from './types';
+export { PLUGIN_QUERIES } from './types';
+export type { CellClickEvent, CellCoords, CellEditor, CellMouseEvent, CellRenderer, ContextMenuItem, ContextMenuParams, GridElementRef, HeaderClickEvent, HeaderRenderer, KeyboardModifiers, PluginCellRenderContext, PluginQuery, RowClickEvent, ScrollEvent, } from './types';
+/**
+ * Grid element interface for plugins.
+ * Extends GridElementRef with plugin-specific methods.
+ */
+export interface GridElement extends GridElementRef {
+    getPlugin<T extends BaseGridPlugin>(PluginClass: new (...args: any[]) => T): T | undefined;
+    getPluginByName(name: string): BaseGridPlugin | undefined;
+}
+/**
+ * Header render context for plugin header renderers.
+ */
+export interface PluginHeaderRenderContext {
+    /** Column configuration */
+    column: ColumnConfig;
+    /** Column index */
+    colIndex: number;
+}
+/**
+ * Abstract base class for all grid plugins.
+ *
+ * @template TConfig - Configuration type for the plugin
+ */
+export declare abstract class BaseGridPlugin<TConfig = unknown> implements GridPlugin {
+    /** Unique plugin identifier (derived from class name by default) */
+    abstract readonly name: string;
+    /** Plugin version - override in subclass if needed */
+    readonly version: string;
+    /** CSS styles to inject into the grid's shadow DOM */
+    readonly styles?: string;
+    /** Custom cell renderers keyed by type name */
+    readonly cellRenderers?: Record<string, CellRenderer>;
+    /** Custom header renderers keyed by type name */
+    readonly headerRenderers?: Record<string, HeaderRenderer>;
+    /** Custom cell editors keyed by type name */
+    readonly cellEditors?: Record<string, CellEditor>;
+    /** The grid instance this plugin is attached to */
+    protected grid: GridElement;
+    /** Plugin configuration - merged with defaults in attach() */
+    protected config: TConfig;
+    /** User-provided configuration from constructor */
+    protected readonly userConfig: Partial<TConfig>;
+    /**
+     * Default configuration - subclasses should override this getter.
+     * Note: This must be a getter (not property initializer) for proper inheritance
+     * since property initializers run after parent constructor.
+     */
+    protected get defaultConfig(): Partial<TConfig>;
+    constructor(config?: Partial<TConfig>);
+    /**
+     * Called when the plugin is attached to a grid.
+     * Override to set up event listeners, initialize state, etc.
+     */
+    attach(grid: GridElement): void;
+    /**
+     * Called when the plugin is detached from a grid.
+     * Override to clean up event listeners, timers, etc.
+     */
+    detach(): void;
+    /**
+     * Get another plugin instance from the same grid.
+     * Use for inter-plugin communication.
+     */
+    protected getPlugin<T extends BaseGridPlugin>(PluginClass: new (...args: any[]) => T): T | undefined;
+    /**
+     * Emit a custom event from the grid.
+     */
+    protected emit<T>(eventName: string, detail: T): void;
+    /**
+     * Request a re-render of the grid.
+     */
+    protected requestRender(): void;
+    /**
+     * Request a lightweight style update without rebuilding DOM.
+     * Use this instead of requestRender() when only CSS classes need updating.
+     */
+    protected requestAfterRender(): void;
+    /**
+     * Get the current rows from the grid.
+     */
+    protected get rows(): any[];
+    /**
+     * Get the original unfiltered/unprocessed rows from the grid.
+     * Use this when you need all source data regardless of active filters.
+     */
+    protected get sourceRows(): any[];
+    /**
+     * Get the current columns from the grid.
+     */
+    protected get columns(): ColumnConfig[];
+    /**
+     * Get only visible columns from the grid (excludes hidden).
+     * Use this for rendering that needs to match the grid template.
+     */
+    protected get visibleColumns(): ColumnConfig[];
+    /**
+     * Get the shadow root of the grid.
+     */
+    protected get shadowRoot(): ShadowRoot | null;
+    /**
+     * Get the disconnect signal for event listener cleanup.
+     * This signal is aborted when the grid disconnects from the DOM.
+     * Use this when adding event listeners that should be cleaned up automatically.
+     *
+     * Best for:
+     * - Document/window-level listeners added in attach()
+     * - Listeners on the grid element itself
+     * - Any listener that should persist across renders
+     *
+     * Not needed for:
+     * - Listeners on elements created in afterRender() (removed with element)
+     *
+     * @example
+     * element.addEventListener('click', handler, { signal: this.disconnectSignal });
+     * document.addEventListener('keydown', handler, { signal: this.disconnectSignal });
+     */
+    protected get disconnectSignal(): AbortSignal;
+    /**
+     * Get the grid-level icons configuration.
+     * Returns merged icons (user config + defaults).
+     */
+    protected get gridIcons(): typeof DEFAULT_GRID_ICONS;
+    /**
+     * Resolve an icon value to string or HTMLElement.
+     * Checks plugin config first, then grid-level icons, then defaults.
+     *
+     * @param iconKey - The icon key in GridIcons (e.g., 'expand', 'collapse')
+     * @param pluginOverride - Optional plugin-level override
+     * @returns The resolved icon value
+     */
+    protected resolveIcon(iconKey: keyof typeof DEFAULT_GRID_ICONS, pluginOverride?: IconValue): IconValue;
+    /**
+     * Set an icon value on an element.
+     * Handles both string (text/HTML) and HTMLElement values.
+     *
+     * @param element - The element to set the icon on
+     * @param icon - The icon value (string or HTMLElement)
+     */
+    protected setIcon(element: HTMLElement, icon: IconValue): void;
+    /**
+     * Log a warning message.
+     */
+    protected warn(message: string): void;
+    /**
+     * Transform rows before rendering.
+     * Called during each render cycle before rows are rendered to the DOM.
+     * Use this to filter, sort, or add computed properties to rows.
+     *
+     * @param rows - The current rows array (readonly to encourage returning a new array)
+     * @returns The modified rows array to render
+     *
+     * @example
+     * ```ts
+     * processRows(rows: readonly any[]): any[] {
+     *   // Filter out hidden rows
+     *   return rows.filter(row => !row._hidden);
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * processRows(rows: readonly any[]): any[] {
+     *   // Add computed properties
+     *   return rows.map(row => ({
+     *     ...row,
+     *     _fullName: `${row.firstName} ${row.lastName}`
+     *   }));
+     * }
+     * ```
+     */
+    processRows?(rows: readonly any[]): any[];
+    /**
+     * Transform columns before rendering.
+     * Called during each render cycle before column headers and cells are rendered.
+     * Use this to add, remove, or modify column definitions.
+     *
+     * @param columns - The current columns array (readonly to encourage returning a new array)
+     * @returns The modified columns array to render
+     *
+     * @example
+     * ```ts
+     * processColumns(columns: readonly ColumnConfig[]): ColumnConfig[] {
+     *   // Add a selection checkbox column
+     *   return [
+     *     { field: '_select', header: '', width: 40 },
+     *     ...columns
+     *   ];
+     * }
+     * ```
+     */
+    processColumns?(columns: readonly ColumnConfig[]): ColumnConfig[];
+    /**
+     * Called before each render cycle begins.
+     * Use this to prepare state or cache values needed during rendering.
+     *
+     * @example
+     * ```ts
+     * beforeRender(): void {
+     *   this.visibleRowCount = this.calculateVisibleRows();
+     * }
+     * ```
+     */
+    beforeRender?(): void;
+    /**
+     * Called after each render cycle completes.
+     * Use this for DOM manipulation, adding event listeners to rendered elements,
+     * or applying visual effects like selection highlights.
+     *
+     * @example
+     * ```ts
+     * afterRender(): void {
+     *   // Apply selection styling to rendered rows
+     *   const rows = this.shadowRoot?.querySelectorAll('.data-row');
+     *   rows?.forEach((row, i) => {
+     *     row.classList.toggle('selected', this.selectedRows.has(i));
+     *   });
+     * }
+     * ```
+     */
+    afterRender?(): void;
+    /**
+     * Called after scroll-triggered row rendering completes.
+     * This is a lightweight hook for applying visual state to recycled DOM elements.
+     * Use this instead of afterRender when you need to reapply styling during scroll.
+     *
+     * Performance note: This is called frequently during scroll. Keep implementation fast.
+     *
+     * @example
+     * ```ts
+     * onScrollRender(): void {
+     *   // Reapply selection state to visible cells
+     *   this.applySelectionToVisibleCells();
+     * }
+     * ```
+     */
+    onScrollRender?(): void;
+    /**
+     * Return extra height contributed by this plugin (e.g., expanded detail rows).
+     * Used to adjust scrollbar height calculations for virtualization.
+     *
+     * @returns Total extra height in pixels
+     *
+     * @example
+     * ```ts
+     * getExtraHeight(): number {
+     *   return this.expandedRows.size * this.detailHeight;
+     * }
+     * ```
+     */
+    getExtraHeight?(): number;
+    /**
+     * Return extra height that appears before a given row index.
+     * Used by virtualization to correctly calculate scroll positions when
+     * there's variable height content (like expanded detail rows) above the viewport.
+     *
+     * @param beforeRowIndex - The row index to calculate extra height before
+     * @returns Extra height in pixels that appears before this row
+     *
+     * @example
+     * ```ts
+     * getExtraHeightBefore(beforeRowIndex: number): number {
+     *   let height = 0;
+     *   for (const expandedRowIndex of this.expandedRowIndices) {
+     *     if (expandedRowIndex < beforeRowIndex) {
+     *       height += this.getDetailHeight(expandedRowIndex);
+     *     }
+     *   }
+     *   return height;
+     * }
+     * ```
+     */
+    getExtraHeightBefore?(beforeRowIndex: number): number;
+    /**
+     * Adjust the virtualization start index to render additional rows before the visible range.
+     * Use this when expanded content (like detail rows) needs its parent row to remain rendered
+     * even when the parent row itself has scrolled above the viewport.
+     *
+     * @param start - The calculated start row index
+     * @param scrollTop - The current scroll position
+     * @param rowHeight - The height of a single row
+     * @returns The adjusted start index (lower than or equal to original start)
+     *
+     * @example
+     * ```ts
+     * adjustVirtualStart(start: number, scrollTop: number, rowHeight: number): number {
+     *   // If row 5 is expanded and scrolled partially, keep it rendered
+     *   for (const expandedRowIndex of this.expandedRowIndices) {
+     *     const expandedRowTop = expandedRowIndex * rowHeight;
+     *     const expandedRowBottom = expandedRowTop + rowHeight + this.detailHeight;
+     *     if (expandedRowBottom > scrollTop && expandedRowIndex < start) {
+     *       return expandedRowIndex;
+     *     }
+     *   }
+     *   return start;
+     * }
+     * ```
+     */
+    adjustVirtualStart?(start: number, scrollTop: number, rowHeight: number): number;
+    /**
+     * Render a custom row, bypassing the default row rendering.
+     * Use this for special row types like group headers, detail rows, or footers.
+     *
+     * @param row - The row data object
+     * @param rowEl - The row DOM element to render into
+     * @param rowIndex - The index of the row in the data array
+     * @returns `true` if the plugin handled rendering (prevents default), `false`/`void` for default rendering
+     *
+     * @example
+     * ```ts
+     * renderRow(row: any, rowEl: HTMLElement, rowIndex: number): boolean | void {
+     *   if (row._isGroupHeader) {
+     *     rowEl.innerHTML = `<div class="group-header">${row._groupLabel}</div>`;
+     *     return true; // Handled - skip default rendering
+     *   }
+     *   // Return void to let default rendering proceed
+     * }
+     * ```
+     */
+    renderRow?(row: any, rowEl: HTMLElement, rowIndex: number): boolean | void;
+    /**
+     * Handle queries from other plugins.
+     * This is the generic mechanism for inter-plugin communication.
+     * Plugins can respond to well-known query types or define their own.
+     *
+     * @param query - The query object with type and context
+     * @returns Query-specific response, or undefined if not handling this query
+     *
+     * @example
+     * ```ts
+     * onPluginQuery(query: PluginQuery): unknown {
+     *   switch (query.type) {
+     *     case PLUGIN_QUERIES.CAN_MOVE_COLUMN:
+     *       // Prevent moving pinned columns
+     *       const column = query.context as ColumnConfig;
+     *       if (column.sticky === 'left' || column.sticky === 'right') {
+     *         return false;
+     *       }
+     *       break;
+     *     case PLUGIN_QUERIES.GET_CONTEXT_MENU_ITEMS:
+     *       const params = query.context as ContextMenuParams;
+     *       return [{ id: 'my-action', label: 'My Action', action: () => {} }];
+     *   }
+     * }
+     * ```
+     */
+    onPluginQuery?(query: PluginQuery): unknown;
+    /**
+     * Handle keyboard events on the grid.
+     * Called when a key is pressed while the grid or a cell has focus.
+     *
+     * @param event - The native KeyboardEvent
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onKeyDown(event: KeyboardEvent): boolean | void {
+     *   // Handle Ctrl+A for select all
+     *   if (event.ctrlKey && event.key === 'a') {
+     *     this.selectAllRows();
+     *     return true; // Prevent default browser select-all
+     *   }
+     * }
+     * ```
+     */
+    onKeyDown?(event: KeyboardEvent): boolean | void;
+    /**
+     * Handle cell click events.
+     * Called when a data cell is clicked (not headers).
+     *
+     * @param event - Cell click event with row/column context
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onCellClick(event: CellClickEvent): boolean | void {
+     *   if (event.field === '_select') {
+     *     this.toggleRowSelection(event.rowIndex);
+     *     return true; // Handled
+     *   }
+     * }
+     * ```
+     */
+    onCellClick?(event: CellClickEvent): boolean | void;
+    /**
+     * Handle row click events.
+     * Called when any part of a data row is clicked.
+     * Note: This is called in addition to onCellClick, not instead of.
+     *
+     * @param event - Row click event with row context
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onRowClick(event: RowClickEvent): boolean | void {
+     *   if (this.config.mode === 'row') {
+     *     this.selectRow(event.rowIndex, event.originalEvent);
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onRowClick?(event: RowClickEvent): boolean | void;
+    /**
+     * Handle header click events.
+     * Called when a column header is clicked. Commonly used for sorting.
+     *
+     * @param event - Header click event with column context
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onHeaderClick(event: HeaderClickEvent): boolean | void {
+     *   if (event.column.sortable !== false) {
+     *     this.toggleSort(event.field);
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onHeaderClick?(event: HeaderClickEvent): boolean | void;
+    /**
+     * Handle scroll events on the grid viewport.
+     * Called during scrolling. Note: This may be called frequently; debounce if needed.
+     *
+     * @param event - Scroll event with scroll position and viewport dimensions
+     *
+     * @example
+     * ```ts
+     * onScroll(event: ScrollEvent): void {
+     *   // Update sticky column positions
+     *   this.updateStickyPositions(event.scrollLeft);
+     * }
+     * ```
+     */
+    onScroll?(event: ScrollEvent): void;
+    /**
+     * Handle cell mousedown events.
+     * Used for initiating drag operations like range selection or column resize.
+     *
+     * @param event - Mouse event with cell context
+     * @returns `true` to indicate drag started (prevents text selection), `false`/`void` otherwise
+     *
+     * @example
+     * ```ts
+     * onCellMouseDown(event: CellMouseEvent): boolean | void {
+     *   if (event.rowIndex !== undefined && this.config.mode === 'range') {
+     *     this.startDragSelection(event.rowIndex, event.colIndex);
+     *     return true; // Prevent text selection
+     *   }
+     * }
+     * ```
+     */
+    onCellMouseDown?(event: CellMouseEvent): boolean | void;
+    /**
+     * Handle cell mousemove events during drag operations.
+     * Only called when a drag is in progress (after mousedown returned true).
+     *
+     * @param event - Mouse event with current cell context
+     * @returns `true` to continue handling the drag, `false`/`void` otherwise
+     *
+     * @example
+     * ```ts
+     * onCellMouseMove(event: CellMouseEvent): boolean | void {
+     *   if (this.isDragging && event.rowIndex !== undefined) {
+     *     this.extendSelection(event.rowIndex, event.colIndex);
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onCellMouseMove?(event: CellMouseEvent): boolean | void;
+    /**
+     * Handle cell mouseup events to end drag operations.
+     *
+     * @param event - Mouse event with final cell context
+     * @returns `true` if drag was finalized, `false`/`void` otherwise
+     *
+     * @example
+     * ```ts
+     * onCellMouseUp(event: CellMouseEvent): boolean | void {
+     *   if (this.isDragging) {
+     *     this.finalizeDragSelection();
+     *     this.isDragging = false;
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onCellMouseUp?(event: CellMouseEvent): boolean | void;
+    /**
+     * Contribute plugin-specific state for a column.
+     * Called by the grid when collecting column state for serialization.
+     * Plugins can add their own properties to the column state.
+     *
+     * @param field - The field name of the column
+     * @returns Partial column state with plugin-specific properties, or undefined if no state to contribute
+     *
+     * @example
+     * ```ts
+     * getColumnState(field: string): Partial<ColumnState> | undefined {
+     *   const filterModel = this.filterModels.get(field);
+     *   if (filterModel) {
+     *     // Uses module augmentation to add filter property to ColumnState
+     *     return { filter: filterModel } as Partial<ColumnState>;
+     *   }
+     *   return undefined;
+     * }
+     * ```
+     */
+    getColumnState?(field: string): Partial<ColumnState> | undefined;
+    /**
+     * Apply plugin-specific state to a column.
+     * Called by the grid when restoring column state from serialized data.
+     * Plugins should restore their internal state based on the provided state.
+     *
+     * @param field - The field name of the column
+     * @param state - The column state to apply (may contain plugin-specific properties)
+     *
+     * @example
+     * ```ts
+     * applyColumnState(field: string, state: ColumnState): void {
+     *   // Check for filter property added via module augmentation
+     *   const filter = (state as any).filter;
+     *   if (filter) {
+     *     this.filterModels.set(field, filter);
+     *     this.applyFilter();
+     *   }
+     * }
+     * ```
+     */
+    applyColumnState?(field: string, state: ColumnState): void;
+    /**
+     * Report horizontal scroll boundary offsets for this plugin.
+     * Plugins that obscure part of the scroll area (e.g., pinned/sticky columns)
+     * should return how much space they occupy on each side.
+     * The keyboard navigation uses this to ensure focused cells are fully visible.
+     *
+     * @param rowEl - The row element (optional, for calculating widths from rendered cells)
+     * @param focusedCell - The currently focused cell element (optional, to determine if scrolling should be skipped)
+     * @returns Object with left/right pixel offsets and optional skipScroll flag, or undefined if plugin has no offsets
+     *
+     * @example
+     * ```ts
+     * getHorizontalScrollOffsets(rowEl?: HTMLElement, focusedCell?: HTMLElement): { left: number; right: number; skipScroll?: boolean } | undefined {
+     *   // Calculate total width of left-pinned columns
+     *   const leftCells = rowEl?.querySelectorAll('.sticky-left') ?? [];
+     *   let left = 0;
+     *   leftCells.forEach(el => { left += (el as HTMLElement).offsetWidth; });
+     *   // Skip scroll if focused cell is pinned (always visible)
+     *   const skipScroll = focusedCell?.classList.contains('sticky-left');
+     *   return { left, right: 0, skipScroll };
+     * }
+     * ```
+     */
+    getHorizontalScrollOffsets?(rowEl?: HTMLElement, focusedCell?: HTMLElement): {
+        left: number;
+        right: number;
+        skipScroll?: boolean;
+    } | undefined;
+    /**
+     * Register a tool panel for this plugin.
+     * Return undefined if plugin has no tool panel.
+     * The shell will create a toolbar toggle button and render the panel content
+     * when the user opens the panel.
+     *
+     * @returns Tool panel definition, or undefined if plugin has no panel
+     *
+     * @example
+     * ```ts
+     * getToolPanel(): ToolPanelDefinition | undefined {
+     *   return {
+     *     id: 'columns',
+     *     title: 'Columns',
+     *     icon: '☰',
+     *     tooltip: 'Show/hide columns',
+     *     order: 10,
+     *     render: (container) => {
+     *       this.renderColumnList(container);
+     *       return () => this.cleanup();
+     *     },
+     *   };
+     * }
+     * ```
+     */
+    getToolPanel?(): ToolPanelDefinition | undefined;
+    /**
+     * Register content for the shell header center section.
+     * Return undefined if plugin has no header content.
+     * Examples: search input, selection summary, status indicators.
+     *
+     * @returns Header content definition, or undefined if plugin has no header content
+     *
+     * @example
+     * ```ts
+     * getHeaderContent(): HeaderContentDefinition | undefined {
+     *   return {
+     *     id: 'quick-filter',
+     *     order: 10,
+     *     render: (container) => {
+     *       const input = document.createElement('input');
+     *       input.type = 'text';
+     *       input.placeholder = 'Search...';
+     *       input.addEventListener('input', this.handleInput);
+     *       container.appendChild(input);
+     *       return () => input.removeEventListener('input', this.handleInput);
+     *     },
+     *   };
+     * }
+     * ```
+     */
+    getHeaderContent?(): HeaderContentDefinition | undefined;
+}
+//# sourceMappingURL=base-plugin.d.ts.map

package/lib/core/plugin/base-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-plugin.d.ts","sourceRoot":"","sources":["../../../../../../libs/grid/src/lib/core/plugin/base-plugin.ts"],"names":[],"mappings":"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"}

package/lib/core/plugin/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * tbw-grid Plugin System
+ *
+ * Public API for the plugin infrastructure.
+ * All plugins extend BaseGridPlugin and are attached to grids via PluginManager.
+ */
+export { BaseGridPlugin, PLUGIN_QUERIES } from './base-plugin';
+export type { CellClickEvent, CellCoords, CellEditor, CellMouseEvent, CellRenderer, ContextMenuItem, ContextMenuParams, GridElement, HeaderClickEvent, HeaderRenderer, KeyboardModifiers, PluginCellRenderContext, PluginHeaderRenderContext, PluginQuery, RowClickEvent, ScrollEvent, } from './base-plugin';
+export { PluginManager } from './plugin-manager';
+export type { ColumnConfig } from '../types';
+//# sourceMappingURL=index.d.ts.map

package/lib/core/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../libs/grid/src/lib/core/plugin/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/D,YAAY,EACV,cAAc,EACd,UAAU,EACV,UAAU,EACV,cAAc,EACd,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,gBAAgB,EAChB,cAAc,EACd,iBAAiB,EACjB,uBAAuB,EACvB,yBAAyB,EACzB,WAAW,EACX,aAAa,EACb,WAAW,GACZ,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAIjD,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC"}