@wcardinal/wcardinal-ui 0.410.0 → 0.412.0

package/dist/types/wcardinal/ui/d-base.d.ts

@@ -625,6 +625,7 @@ export declare class DBase<THEME extends DThemeBase = DThemeBase, OPTIONS extend
     protected onShortcut(e: KeyboardEvent): void;
     protected init(options?: OPTIONS): void;
     get weight(): number;
+    set weight(weight: number);
     protected onMove(newX: number, newY: number, oldX: number, oldY: number): void;
     resize(width?: number, height?: number): boolean;
     getClearType(): DLayoutClearType;

package/dist/types/wcardinal/ui/d-dialog-gesture-impl.d.ts

@@ -12,7 +12,7 @@ export declare class DDialogGestureImpl<PARENT extends DDialogGestureParent> imp
     protected _isEnabled: boolean;
     protected _isDirty: boolean;
     protected _constraint?: DDialogGestureConstraint;
-    protected _util?: UtilGesture<any>;
+    protected _util?: UtilGesture<PARENT>;
     constructor(parent: PARENT, options: DDialogGestureOptions);
     get parent(): PARENT;
     get mode(): DDialogGestureMode;
@@ -23,6 +23,6 @@ export declare class DDialogGestureImpl<PARENT extends DDialogGestureParent> imp
     isDirty(): boolean;
     isClean(): boolean;
     toClean(): void;
-    protected newUtil(): UtilGesture<any>;
+    protected newUtil(): UtilGesture<PARENT>;
     protected toConstrained(target: DBase, layer: DApplicationLayerLike, x: number, y: number): void;
 }

package/dist/types/wcardinal/ui/d-table-body-cell.d.ts

@@ -2,8 +2,8 @@ import { InteractionEvent, Point } from "pixi.js";
 import { DBase } from "./d-base";
 import { DTableColumn } from "./d-table-column";
 import { DTableDataSupplimental } from "./d-table-data";
-export type DTableBodyCellOnChange<ROW, VALUE, EMITTER = any> = (newValue: VALUE, oldValue: VALUE, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW, VALUE>, emitter: EMITTER) => void;
-export interface DTableBodyCell<ROW, VALUE> extends DBase {
+export type DTableBodyCellOnChange<ROW, VALUE = unknown, EMITTER = any> = (newValue: VALUE, oldValue: VALUE, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW, VALUE>, emitter: EMITTER) => void;
+export interface DTableBodyCell<ROW, VALUE = unknown> extends DBase {
     /**
      * A row data if exists.
      * Otherwise, Undefined.

package/dist/types/wcardinal/ui/d-table-body-row.d.ts

@@ -8,29 +8,29 @@ import { DTableRow, DTableRowOptions, DThemeTableRow } from "./d-table-row";
 export interface DTableBodyRowSelectionOptions {
     type?: DTableDataSelectionType;
 }
-export interface DTableBodyRowOptions<ROW, THEME extends DThemeTableBodyRow = DThemeTableBodyRow> extends DTableRowOptions<ROW, DTableColumn<ROW, unknown>, THEME> {
+export interface DTableBodyRowOptions<ROW, THEME extends DThemeTableBodyRow = DThemeTableBodyRow> extends DTableRowOptions<THEME> {
     height?: number;
     cell?: DTableBodyCellOptions<ROW>;
     selection?: DTableBodyRowSelectionOptions;
 }
 export interface DThemeTableBodyRow extends DThemeTableRow {
 }
-export type DTableBodyRowOnChange<ROW, VALUE, EMITTER = any> = (newValue: VALUE, oldValue: VALUE, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW, VALUE>, emitter: EMITTER) => void;
-export declare class DTableBodyRow<ROW, THEME extends DThemeTableBodyRow = DThemeTableBodyRow, OPTIONS extends DTableBodyRowOptions<ROW, THEME> = DTableBodyRowOptions<ROW, THEME>> extends DTableRow<ROW, DTableColumn<ROW, unknown>, THEME, OPTIONS> {
+export type DTableBodyRowOnChange<ROW, VALUE = unknown, EMITTER = any> = (newValue: VALUE, oldValue: VALUE, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW, VALUE>, emitter: EMITTER) => void;
+export declare class DTableBodyRow<ROW, THEME extends DThemeTableBodyRow = DThemeTableBodyRow, OPTIONS extends DTableBodyRowOptions<ROW, THEME> = DTableBodyRowOptions<ROW, THEME>> extends DTableRow<ROW, DTableColumn<ROW>, THEME, OPTIONS> {
     protected _value?: ROW;
     protected _supplimental?: DTableDataSupplimental | null;
     protected _index: number;
-    protected _onChange: DTableBodyRowOnChange<ROW, unknown>;
+    protected _onChange: DTableBodyRowOnChange<ROW>;
     protected _onCellChangeBound: DTableBodyCellOnChange<ROW, any>;
     protected _columnIndexToCellOptions: Map<number, DTableBodyCellOptions<ROW>>;
-    constructor(onChange: DTableBodyRowOnChange<ROW, unknown>, isEven: boolean, columnIndexToCellOptions: Map<number, DTableBodyCellOptions<ROW>>, options: OPTIONS);
-    protected onCellChange(newValue: unknown, oldValue: unknown, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW, unknown>): void;
-    protected newCell(columnIndex: number, column: DTableColumn<ROW, unknown>, columns: Array<DTableColumn<ROW, unknown>>, options: OPTIONS): DBase;
+    constructor(onChange: DTableBodyRowOnChange<ROW>, isEven: boolean, columnIndexToCellOptions: Map<number, DTableBodyCellOptions<ROW>>, columns: DTableColumn<ROW>[], frozen: number, options: OPTIONS);
+    protected onCellChange(newValue: unknown, oldValue: unknown, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW>): void;
+    protected newCell(columnIndex: number, column: DTableColumn<ROW>, columns: DTableColumn<ROW>[], options?: OPTIONS): DBase;
     protected newCellEditable(columnIndex: number, column: DTableColumn<ROW, any>, onChange: DTableBodyCellOnChange<ROW, any>, options: any): DBase;
     protected newCellUnediable(columnIndex: number, column: DTableColumn<ROW, any>, onChange: DTableBodyCellOnChange<ROW, any>, options: any): DBase;
     protected newCellSelect(columnIndex: number, column: DTableColumn<ROW, any>, onChange: DTableBodyCellOnChange<ROW, any>, options: any): DBase;
-    protected newCellAction(columnIndex: number, column: DTableColumn<ROW, any>, onChange: DTableBodyCellOnChange<ROW, any>, options: any): DBase;
-    protected toCellOptions(columnIndex: number, column: DTableColumn<ROW, unknown>, options: OPTIONS): DTableBodyCellOptions<ROW>;
+    protected newCellAction(columnIndex: number, column: DTableColumn<ROW>, onChange: DTableBodyCellOnChange<ROW>, options: any): DBase;
+    protected toCellOptions(columnIndex: number, column: DTableColumn<ROW>, options?: OPTIONS): DTableBodyCellOptions<ROW>;
     protected getType(): string;
     /**
      * Returns a row data if exists.

package/dist/types/wcardinal/ui/d-table-body.d.ts

@@ -34,11 +34,8 @@ export interface DTableBodyEvents<EMITTER> extends DBaseEvents<EMITTER> {
 export interface DTableBodyOnOptions<EMITTER> extends Partial<DTableBodyEvents<EMITTER>>, DOnOptions {
 }
 export interface DTableBodyOptions<ROW, DATA extends DTableData<ROW> = DTableDataList<ROW>, THEME extends DThemeTableBody = DThemeTableBody, EMITTER = any> extends DBaseOptions<THEME, EMITTER> {
-    columns?: Array<DTableColumn<ROW, unknown>>;
     row?: DTableBodyRowOptions<ROW>;
     data?: DTableDataListOptions<ROW> | DATA;
-    offset?: number;
-    frozen?: number;
     on?: DTableBodyOnOptions<EMITTER>;
 }
 export interface DThemeTableBody extends DThemeBase {
@@ -46,7 +43,8 @@ export interface DThemeTableBody extends DThemeBase {
 }
 export declare class DTableBody<ROW, DATA extends DTableData<ROW> = DTableDataList<ROW>, THEME extends DThemeTableBody = DThemeTableBody, OPTIONS extends DTableBodyOptions<ROW, DATA, THEME> = DTableBodyOptions<ROW, DATA, THEME>> extends DBase<THEME, OPTIONS> {
     protected static WORK_ON_CLICK: Point;
-    protected _columns: Array<DTableColumn<ROW, unknown>>;
+    protected _columns: DTableColumn<ROW>[];
+    protected _frozen: number;
     protected _rowHeight: number;
     protected _rowIndexMappedStart: number;
     protected _rowIndexMappedEnd: number;
@@ -55,11 +53,11 @@ export declare class DTableBody<ROW, DATA extends DTableData<ROW> = DTableDataLi
     protected _isUpdateRowsCalled: boolean;
     protected _isUpdateRowsCalledForcibly: boolean;
     protected _workRows: Array<DTableBodyRow<ROW>>;
-    protected _onRowChangeBound: DTableBodyRowOnChange<ROW, unknown>;
+    protected _onRowChangeBound: DTableBodyRowOnChange<ROW>;
     protected _columnIndexToCellOptions: Map<number, DTableBodyCellOptions<ROW>>;
     protected _data: DATA;
-    constructor(options: OPTIONS);
-    protected onRowChange(newValue: unknown, oldValue: unknown, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW, unknown>): void;
+    constructor(columns: DTableColumn<ROW>[], frozen: number, offset: number, options: OPTIONS);
+    protected onRowChange(newValue: unknown, oldValue: unknown, row: ROW, rowIndex: number, columnIndex: number, column: DTableColumn<ROW>): void;
     protected toData(options?: DATA | DTableDataListOptions<ROW>): DATA;
     protected isData(target?: ROW[] | DTableDataOptions<ROW> | DTableData<ROW>): target is DTableData<ROW>;
     onResize(newWidth: number, newHeight: number, oldWidth: number, oldHeight: number): void;

package/dist/types/wcardinal/ui/d-table-category-cell.d.ts

@@ -1,8 +1,45 @@
+import { InteractionEvent, InteractionManager, Point } from "pixi.js";
 import { DImage, DImageOptions, DThemeImage } from "./d-image";
+import { DTableCategoryColumn } from "./d-table-category-column";
+import { DBaseStateSet } from "./d-base-state-set";
+export interface DTableCategoryCellCategory {
+    readonly children: DTableCategoryCell[];
+    readonly state: DBaseStateSet;
+}
 export interface DTableCategoryCellOptions<THEME extends DThemeTableCategoryCell = DThemeTableCategoryCell> extends DImageOptions<string | null, THEME> {
 }
 export interface DThemeTableCategoryCell extends DThemeImage<string | null> {
+    getEdgeWidth(): number;
 }
+export declare const DTableCategoryCellEdge: {
+    readonly NONE: 0;
+    readonly LEFT: 1;
+    readonly RIGHT: 2;
+    readonly BOTH: 3;
+};
+export type DTableCategoryCellEdge = (typeof DTableCategoryCellEdge)[keyof typeof DTableCategoryCellEdge];
 export declare class DTableCategoryCell<THEME extends DThemeTableCategoryCell = DThemeTableCategoryCell, OPTIONS extends DTableCategoryCellOptions<THEME> = DTableCategoryCellOptions<THEME>> extends DImage<string | null, THEME, OPTIONS> {
+    protected _category: DTableCategoryCellCategory;
+    protected _column: DTableCategoryColumn;
+    protected _columnIndex: number;
+    protected _checkWork?: Point;
+    protected _onHoveredBound?: (e: InteractionEvent) => void;
+    protected _resizableEdges?: DTableCategoryCellEdge;
+    protected _edgeSize: number;
+    protected _wasResizing: boolean;
+    constructor(category: DTableCategoryCellCategory, columnIndex: number, column: DTableCategoryColumn, options?: OPTIONS);
+    get column(): DTableCategoryColumn;
+    get columnIndex(): number;
+    get category(): DTableCategoryCellCategory;
+    protected onDown(e: InteractionEvent): void;
+    protected findLeftResizableCell(columnIndex: number): DTableCategoryCell | null;
+    protected findRightResizableCellOfWeight(columnIndex: number): DTableCategoryCell | null;
+    protected checkIfEdgeResizable(columnIndex: number): boolean;
+    protected getResizableEdges(): DTableCategoryCellEdge;
+    protected onOver(e: InteractionEvent): void;
+    protected onOut(e: InteractionEvent): void;
+    protected onHovered(e: InteractionEvent): void;
+    protected toClickPosition(e: InteractionEvent): number;
+    protected onDownEdge(onDownPoint: number, columnIndex: number, interactionManager: InteractionManager): void;
     protected getType(): string;
 }

package/dist/types/wcardinal/ui/d-table-category-column-impl.d.ts

@@ -0,0 +1,24 @@
+import { utils } from "pixi.js";
+import { DTableCategoryColumn } from "./d-table-category-column";
+import { DTableColumn } from "./d-table-column";
+import { DTableColumnSelectingDialog } from "./d-table-column-selecting";
+export declare class DTableCategoryColumnImpl<ROW_VALUE, CELL_VALUE, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> extends utils.EventEmitter implements DTableCategoryColumn {
+    label: string | undefined;
+    protected _weight: number | undefined;
+    protected _width: number | undefined;
+    protected _isLocked: boolean;
+    offset: number;
+    protected _columns: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[];
+    protected _nresizable: number;
+    protected _onResizeBound: (column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>) => void;
+    constructor(index: number, column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>);
+    protected onResize(): void;
+    get resizable(): boolean;
+    get weight(): number | undefined;
+    set weight(weight: number);
+    get minWeight(): number;
+    get width(): number | undefined;
+    set width(width: number);
+    get minWidth(): number;
+    add(column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): void;
+}

package/dist/types/wcardinal/ui/d-table-category-column.d.ts

@@ -0,0 +1,10 @@
+import { utils } from "pixi.js";
+export interface DTableCategoryColumn extends utils.EventEmitter {
+    readonly label?: string;
+    weight?: number;
+    readonly minWeight: number;
+    width?: number;
+    readonly minWidth: number;
+    offset: number;
+    readonly resizable: boolean;
+}

package/dist/types/wcardinal/ui/d-table-category-container-impl.d.ts

@@ -0,0 +1,12 @@
+import { DTableCategory, DTableCategoryOptions } from "./d-table-category";
+import { DTableCategoryColumn } from "./d-table-category-column";
+import { DTableCategoryContainer } from "./d-table-category-container";
+import { DTableColumn } from "./d-table-column";
+import { DTableColumnSelectingDialog } from "./d-table-column-selecting";
+export declare class DTableCategoryContainerImpl<ROW_VALUE, CELL_VALUE, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> implements DTableCategoryContainer {
+    readonly items: DTableCategory[];
+    constructor(columns: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[], frozen: number, options?: DTableCategoryOptions);
+    protected toCount(columns: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[]): number;
+    protected isCategory(index: number, a: string | string[] | undefined, b: string | string[] | undefined): boolean;
+    protected toColumns(index: number, columns: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[], frozen: number): DTableCategoryColumn[];
+}

package/dist/types/wcardinal/ui/d-table-category-container.d.ts

@@ -0,0 +1,4 @@
+import { DTableCategory } from "./d-table-category";
+export interface DTableCategoryContainer {
+    readonly items: DTableCategory[];
+}

package/dist/types/wcardinal/ui/d-table-category.d.ts

@@ -1,24 +1,25 @@
 import { DBase } from "./d-base";
-import { DTableCategoryCellOptions } from "./d-table-category-cell";
+import { DTableCategoryCell, DTableCategoryCellOptions } from "./d-table-category-cell";
+import { DTableCategoryColumn } from "./d-table-category-column";
 import { DTableRow, DTableRowOptions, DThemeTableRow } from "./d-table-row";
-export interface DTableCategoryColumn {
-    label?: string;
-    weight?: number;
-    width?: number;
-    offset: number;
-}
-export interface DTableCategoryOptions<THEME extends DThemeTableCategory = DThemeTableCategory> extends DTableRowOptions<unknown, DTableCategoryColumn, THEME> {
-    offset?: number;
+export interface DTableCategoryOptions<THEME extends DThemeTableCategory = DThemeTableCategory> extends DTableRowOptions<THEME> {
     cell?: DTableCategoryCellOptions;
 }
 export interface DThemeTableCategory extends DThemeTableRow {
 }
 export declare class DTableCategory<THEME extends DThemeTableCategory = DThemeTableCategory, OPTIONS extends DTableCategoryOptions<THEME> = DTableCategoryOptions<THEME>> extends DTableRow<unknown, DTableCategoryColumn, THEME, OPTIONS> {
+    protected _columns: DTableCategoryColumn[];
+    protected _frozen: number;
     protected _offset: number;
-    constructor(options: OPTIONS);
+    children: DTableCategoryCell[];
+    constructor(columns: DTableCategoryColumn[], frozen: number, offset: number, options?: OPTIONS);
+    protected newOnColumnResize(index: number, column: DTableCategoryColumn): () => void;
+    protected onColumnResize(index: number, column: DTableCategoryColumn): void;
+    protected onColumnResizeWeight(row: DBase, index: number, columnWeight: number): void;
+    protected onColumnResizeWidth(row: DBase, index: number, columnWidth: number): void;
     protected onParentMove(newX: number, newY: number, oldX: number, oldY: number): void;
     protected getContentPositionX(): number;
-    protected newCell(columnIndex: number, column: DTableCategoryColumn, columns: DTableCategoryColumn[], options: OPTIONS): DBase;
-    protected toCellOptions(columnIndex: number, column: DTableCategoryColumn, options: OPTIONS): DTableCategoryCellOptions;
+    protected newCell(columnIndex: number, column: DTableCategoryColumn, columns: DTableCategoryColumn[], options?: OPTIONS): DBase;
+    protected toCellOptions(columnIndex: number, column: DTableCategoryColumn, options?: OPTIONS): DTableCategoryCellOptions;
     protected getType(): string;
 }

package/dist/types/wcardinal/ui/d-table-column-container-impl.d.ts

@@ -0,0 +1,25 @@
+import { utils } from "pixi.js";
+import { DBase } from "./d-base";
+import { DTableColumn, DTableColumnOptions } from "./d-table-column";
+import { DTableColumnContainer, DTableColumnIteratee } from "./d-table-column-container";
+import { DTableColumnSelectingDialog } from "./d-table-column-selecting";
+export interface DTableColumnContainerImplParent {
+    readonly header: DBase | null;
+    readonly body: DBase;
+}
+export declare class DTableColumnContainerImpl<ROW_VALUE, CELL_VALUE = unknown, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> extends utils.EventEmitter implements DTableColumnContainer<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG> {
+    readonly parent: DTableColumnContainerImplParent;
+    readonly frozen: number;
+    readonly items: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[];
+    constructor(parent: DTableColumnContainerImplParent, options?: DTableColumnOptions<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[]);
+    protected newOnColumnResize(index: number, column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): () => void;
+    protected onColumnResize(index: number, column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): void;
+    protected onColumnResizeHeader(index: number, column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): void;
+    protected onColumnResizeBody(index: number, column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): void;
+    protected onColumnResizeWeight(row: DBase, index: number, columnWeight: number): void;
+    protected onColumnResizeWidth(row: DBase, index: number, columnWidth: number): void;
+    get width(): number;
+    get(index: number): DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG> | null;
+    each(iteratee: DTableColumnIteratee<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): this;
+    size(): number;
+}

package/dist/types/wcardinal/ui/d-table-column-container.d.ts

@@ -0,0 +1,12 @@
+import { utils } from "pixi.js";
+import { DTableColumn } from "./d-table-column";
+import { DTableColumnSelectingDialog } from "./d-table-column-selecting";
+export type DTableColumnIteratee<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE>> = (column: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>, index: number) => boolean | void;
+export interface DTableColumnContainer<ROW_VALUE, CELL_VALUE = unknown, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> extends utils.EventEmitter {
+    readonly frozen: number;
+    readonly items: DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>[];
+    readonly width: number;
+    get(index: number): DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG> | null;
+    each(iteratee: DTableColumnIteratee<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG>): this;
+    size(): number;
+}

package/dist/types/wcardinal/ui/d-table-column-impl.d.ts

@@ -0,0 +1,44 @@
+import { utils } from "pixi.js";
+import { DAlignHorizontal } from "./d-align-horizontal";
+import { DTableBodyCellLinkLinkOptions } from "./d-table-body-cell-link";
+import { DTableBodyCellOptions } from "./d-table-body-cell-options";
+import { DTableColumn, DTableColumnOptions } from "./d-table-column";
+import { DTableColumnEditing } from "./d-table-column-editing";
+import { DTableColumnFormatter } from "./d-table-column-formatter";
+import { DTableColumnGetter } from "./d-table-column-getter";
+import { DTableColumnRenderable } from "./d-table-column-renderable";
+import { DTableColumnSelecting, DTableColumnSelectingDialog } from "./d-table-column-selecting";
+import { DTableColumnSetter } from "./d-table-column-setter";
+import { DTableColumnSorting } from "./d-table-column-sorting";
+import { DTableColumnState } from "./d-table-column-state";
+import { DTableColumnType } from "./d-table-column-type";
+import { DTableColumnUpdate } from "./d-table-column-update";
+import { DTableHeaderCellOptions, DThemeTableHeaderCell } from "./d-table-header-cell";
+export declare class DTableColumnImpl<ROW_VALUE, CELL_VALUE, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> extends utils.EventEmitter implements DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE, DIALOG> {
+    protected _weight?: number;
+    protected _width?: number;
+    readonly resizable: boolean;
+    readonly type: DTableColumnType;
+    readonly label: string;
+    readonly getter: DTableColumnGetter<ROW_VALUE, CELL_VALUE>;
+    readonly setter: DTableColumnSetter<ROW_VALUE, CELL_VALUE>;
+    readonly formatter?: DTableColumnFormatter<CELL_VALUE>;
+    readonly align: DAlignHorizontal;
+    readonly state: DTableColumnState<ROW_VALUE>;
+    readonly renderable: boolean | DTableColumnRenderable<ROW_VALUE>;
+    readonly editing: DTableColumnEditing<ROW_VALUE, CELL_VALUE>;
+    readonly sorting: DTableColumnSorting<ROW_VALUE>;
+    readonly header?: DTableHeaderCellOptions<ROW_VALUE, DThemeTableHeaderCell>;
+    readonly body?: DTableBodyCellOptions<ROW_VALUE>;
+    readonly selecting: DTableColumnSelecting<CELL_VALUE, DIALOG_VALUE, DIALOG>;
+    readonly category?: string | string[];
+    readonly frozen?: boolean | undefined;
+    offset: number;
+    readonly link?: DTableBodyCellLinkLinkOptions<ROW_VALUE, CELL_VALUE>;
+    readonly update: DTableColumnUpdate;
+    constructor(index: number, options: DTableColumnOptions<ROW_VALUE, CELL_VALUE>);
+    get weight(): number | undefined;
+    set weight(weight: number);
+    get width(): number | undefined;
+    set width(width: number);
+}

package/dist/types/wcardinal/ui/d-table-column.d.ts

@@ -1,3 +1,4 @@
+import { utils } from "pixi.js";
 import { DAlignHorizontal } from "./d-align-horizontal";
 import { DTableBodyCellLinkLinkOptions } from "./d-table-body-cell-link";
 import { DTableBodyCellOptions } from "./d-table-body-cell-options";
@@ -15,6 +16,7 @@ import { DTableHeaderCellOptions } from "./d-table-header-cell";
 export interface DTableColumnOptions<ROW_VALUE, CELL_VALUE = any, DIALOG_VALUE = any, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = any> {
     weight?: number;
     width?: number;
+    resizable?: boolean;
     type?: keyof typeof DTableColumnType | DTableColumnType;
     label?: string;
     getter?: DTableColumnGetter<ROW_VALUE, CELL_VALUE>;
@@ -69,25 +71,26 @@ export interface DTableColumnOptions<ROW_VALUE, CELL_VALUE = any, DIALOG_VALUE =
      */
     update?: keyof typeof DTableColumnUpdate | DTableColumnUpdate;
 }
-export interface DTableColumn<ROW_VALUE, CELL_VALUE, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> {
-    weight: number | undefined;
-    width: number | undefined;
-    type: DTableColumnType;
+export interface DTableColumn<ROW_VALUE, CELL_VALUE = unknown, DIALOG_VALUE = CELL_VALUE, DIALOG extends DTableColumnSelectingDialog<DIALOG_VALUE> = DTableColumnSelectingDialog<DIALOG_VALUE>> extends utils.EventEmitter {
+    weight?: number;
+    width?: number;
+    readonly resizable: boolean;
+    readonly type: DTableColumnType;
     label: string;
-    getter: DTableColumnGetter<ROW_VALUE, CELL_VALUE>;
-    setter: DTableColumnSetter<ROW_VALUE, CELL_VALUE>;
-    formatter?: DTableColumnFormatter<CELL_VALUE>;
-    align: DAlignHorizontal;
-    state: DTableColumnState<ROW_VALUE>;
-    renderable: boolean | DTableColumnRenderable<ROW_VALUE>;
-    editing: DTableColumnEditing<ROW_VALUE, CELL_VALUE>;
-    sorting: DTableColumnSorting<ROW_VALUE>;
-    header?: DTableHeaderCellOptions<ROW_VALUE>;
-    body?: DTableBodyCellOptions<ROW_VALUE>;
-    selecting: DTableColumnSelecting<CELL_VALUE, DIALOG_VALUE, DIALOG>;
-    category?: string | string[];
-    frozen?: boolean;
+    readonly getter: DTableColumnGetter<ROW_VALUE, CELL_VALUE>;
+    readonly setter: DTableColumnSetter<ROW_VALUE, CELL_VALUE>;
+    readonly formatter?: DTableColumnFormatter<CELL_VALUE>;
+    readonly align: DAlignHorizontal;
+    readonly state: DTableColumnState<ROW_VALUE>;
+    readonly renderable: boolean | DTableColumnRenderable<ROW_VALUE>;
+    readonly editing: DTableColumnEditing<ROW_VALUE, CELL_VALUE>;
+    readonly sorting: DTableColumnSorting<ROW_VALUE>;
+    readonly header?: DTableHeaderCellOptions<ROW_VALUE>;
+    readonly body?: DTableBodyCellOptions<ROW_VALUE>;
+    readonly selecting: DTableColumnSelecting<CELL_VALUE, DIALOG_VALUE, DIALOG>;
+    readonly category?: string | string[];
+    readonly frozen?: boolean;
     offset: number;
-    link?: DTableBodyCellLinkLinkOptions<ROW_VALUE, CELL_VALUE>;
-    update: DTableColumnUpdate;
+    readonly link?: DTableBodyCellLinkLinkOptions<ROW_VALUE, CELL_VALUE>;
+    readonly update: DTableColumnUpdate;
 }

package/dist/types/wcardinal/ui/d-table-header-cell-check.d.ts

@@ -7,7 +7,7 @@ export interface DTableHeaderCellCheckOptions {
     emittable?: boolean;
 }
 export interface DTableHeaderCellCheckParent<ROW> {
-    readonly column?: DTableColumn<ROW, unknown>;
+    readonly column?: DTableColumn<ROW>;
     readonly columnIndex?: number;
     readonly header?: DTableHeaderCellHeader<ROW>;
 }

package/dist/types/wcardinal/ui/d-table-header-cell.d.ts

@@ -1,44 +1,66 @@
-import { InteractionEvent, Point } from "pixi.js";
+import { InteractionEvent, InteractionManager, Point } from "pixi.js";
 import { DImage, DImageOptions, DThemeImage } from "./d-image";
 import { DTableColumn } from "./d-table-column";
 import { DTableDataComparator, DTableDataSorter } from "./d-table-data-sorter";
 import { DTableHeaderTable } from "./d-table-header";
 import { DTableHeaderCellCheck, DTableHeaderCellCheckOptions } from "./d-table-header-cell-check";
+import { DBaseStateSet } from "./d-base-state-set";
 export interface DTableHeaderCellHeader<ROW> {
     readonly table: DTableHeaderTable<ROW> | null;
+    readonly children: DTableHeaderCell<ROW>[];
+    readonly state: DBaseStateSet;
 }
 export interface DTableHeaderCellOptions<ROW, THEME extends DThemeTableHeaderCell = DThemeTableHeaderCell> extends DImageOptions<string | null, THEME> {
-    header?: DTableHeaderCellHeader<ROW>;
-    column?: DTableColumn<ROW, unknown>;
-    columnIndex?: number;
     check?: DTableHeaderCellCheckOptions;
 }
 export interface DThemeTableHeaderCell extends DThemeImage<string | null> {
+    getEdgeWidth(): number;
 }
+export declare const DTableHeaderCellEdge: {
+    readonly NONE: 0;
+    readonly LEFT: 1;
+    readonly RIGHT: 2;
+    readonly BOTH: 3;
+};
+export type DTableHeaderCellEdge = (typeof DTableHeaderCellEdge)[keyof typeof DTableHeaderCellEdge];
 export declare class DTableHeaderCell<ROW, THEME extends DThemeTableHeaderCell = DThemeTableHeaderCell, OPTIONS extends DTableHeaderCellOptions<ROW, THEME> = DTableHeaderCellOptions<ROW, THEME>> extends DImage<string | null, THEME, OPTIONS> {
     protected _sorter?: DTableDataSorter<ROW>;
     protected _onSorterChangeBound?: () => void;
-    protected _header?: DTableHeaderCellHeader<ROW>;
-    protected _column?: DTableColumn<ROW, unknown>;
-    protected _columnIndex?: number;
+    protected _header: DTableHeaderCellHeader<ROW>;
+    protected _column: DTableColumn<ROW>;
+    protected _columnIndex: number;
     protected _check: DTableHeaderCellCheck<ROW>;
     protected _checkWork?: Point;
-    protected init(options?: OPTIONS): void;
-    get column(): DTableColumn<ROW, unknown> | undefined;
-    get columnIndex(): number | undefined;
-    get header(): DTableHeaderCellHeader<ROW> | undefined;
+    protected _onHoveredBound?: (e: InteractionEvent) => void;
+    protected _resizableEdges?: DTableHeaderCellEdge;
+    protected _edgeSize: number;
+    protected _wasResizing: boolean;
+    constructor(header: DTableHeaderCellHeader<ROW>, columnIndex: number, column: DTableColumn<ROW>, options?: OPTIONS);
+    get column(): DTableColumn<ROW>;
+    get columnIndex(): number;
+    get header(): DTableHeaderCellHeader<ROW>;
     get check(): DTableHeaderCellCheck<ROW>;
-    protected initOnClick(options?: OPTIONS): void;
+    protected onDown(e: InteractionEvent): void;
+    protected findLeftResizableCell(columnIndex: number): DTableHeaderCell<ROW> | null;
+    protected findRightResizableCellOfWeight(columnIndex: number): DTableHeaderCell<ROW> | null;
+    protected checkIfEdgeResizable(columnIndex: number): boolean;
+    protected getResizableEdges(): DTableHeaderCellEdge;
+    protected onOver(e: InteractionEvent): void;
+    protected onOut(e: InteractionEvent): void;
+    protected onHovered(e: InteractionEvent): void;
+    protected onDownEdge(onDownPoint: number, columnIndex: number, interactionManager: InteractionManager): void;
     get sorter(): DTableDataSorter<ROW> | null;
     get comparator(): DTableDataComparator<ROW> | null;
     protected onSorterChange(): void;
     protected toClickPosition(e: InteractionEvent): number;
     protected isCheckClicked(e?: InteractionEvent | KeyboardEvent | MouseEvent | TouchEvent): boolean;
+    protected isEdgeClicked(e?: InteractionEvent | KeyboardEvent | MouseEvent | TouchEvent): boolean;
     protected onClick(e: InteractionEvent): void;
     activate(e?: InteractionEvent | KeyboardEvent | MouseEvent | TouchEvent): void;
     protected onActivate(e?: InteractionEvent | KeyboardEvent | MouseEvent | TouchEvent): void;
     protected doSort(e?: InteractionEvent | KeyboardEvent | MouseEvent | TouchEvent): void;
     get isSortable(): boolean;
+    get isResizable(): boolean;
     get isToggle(): boolean;
     toggle(): void;
     protected onToggleStart(): void;

package/dist/types/wcardinal/ui/d-table-header.d.ts

@@ -1,7 +1,7 @@
 import { DBase } from "./d-base";
 import { DTableColumn } from "./d-table-column";
 import { DTableData } from "./d-table-data";
-import { DTableHeaderCellOptions } from "./d-table-header-cell";
+import { DTableHeaderCell, DTableHeaderCellOptions } from "./d-table-header-cell";
 import { DTableRow, DTableRowOptions, DThemeTableRow } from "./d-table-row";
 export interface DTableHeaderTableBody {
     update(forcibly?: boolean): void;
@@ -10,21 +10,20 @@ export interface DTableHeaderTable<ROW> {
     readonly data: DTableData<ROW>;
     readonly body: DTableHeaderTableBody;
 }
-export interface DTableHeaderOptions<ROW, THEME extends DThemeTableHeader = DThemeTableHeader> extends DTableRowOptions<ROW, DTableColumn<ROW, unknown>, THEME> {
-    table?: DTableHeaderTable<ROW>;
-    offset?: number;
+export interface DTableHeaderOptions<ROW, THEME extends DThemeTableHeader = DThemeTableHeader> extends DTableRowOptions<THEME> {
     cell?: DTableHeaderCellOptions<ROW>;
 }
 export interface DThemeTableHeader extends DThemeTableRow {
 }
-export declare class DTableHeader<ROW, THEME extends DThemeTableHeader = DThemeTableHeader, OPTIONS extends DTableHeaderOptions<ROW, THEME> = DTableHeaderOptions<ROW, THEME>> extends DTableRow<ROW, DTableColumn<ROW, unknown>, THEME, OPTIONS> {
-    protected _table: DTableHeaderTable<ROW> | null;
+export declare class DTableHeader<ROW, THEME extends DThemeTableHeader = DThemeTableHeader, OPTIONS extends DTableHeaderOptions<ROW, THEME> = DTableHeaderOptions<ROW, THEME>> extends DTableRow<ROW, DTableColumn<ROW>, THEME, OPTIONS> {
+    protected _table: DTableHeaderTable<ROW>;
     protected _offset: number;
-    constructor(options: OPTIONS);
+    children: DTableHeaderCell<ROW>[];
+    constructor(table: DTableHeaderTable<ROW>, columns: DTableColumn<ROW>[], frozen: number, offset: number, options?: OPTIONS);
     get table(): DTableHeaderTable<ROW> | null;
     protected onParentMove(newX: number, newY: number, oldX: number, oldY: number): void;
     protected getContentPositionX(): number;
-    protected newCell(columnIndex: number, column: DTableColumn<ROW, unknown>, columns: Array<DTableColumn<ROW, unknown>>, options: OPTIONS): DBase;
-    protected toCellOptions(columnIndex: number, column: DTableColumn<ROW, unknown>, options: OPTIONS): DTableHeaderCellOptions<ROW>;
+    protected newCell(columnIndex: number, column: DTableColumn<ROW>, columns: Array<DTableColumn<ROW>>, options?: OPTIONS): DBase;
+    protected toCellOptions(column: DTableColumn<ROW>, options?: OPTIONS): DTableHeaderCellOptions<ROW>;
     protected getType(): string;
 }

package/dist/types/wcardinal/ui/d-table-row.d.ts

@@ -1,28 +1,27 @@
-import { Rectangle } from "pixi.js";
+import { Rectangle, utils } from "pixi.js";
 import { DBase } from "./d-base";
 import { DLayoutHorizontal, DLayoutHorizontalOptions, DThemeLayoutHorizontal } from "./d-layout-horizontal";
-export interface DTableRowOptions<ROW, COLUMN, THEME extends DThemeTableRow = DThemeTableRow> extends DLayoutHorizontalOptions<THEME> {
-    columns?: COLUMN[];
-    frozen?: number;
+export interface DTableRowOptions<THEME extends DThemeTableRow = DThemeTableRow> extends DLayoutHorizontalOptions<THEME> {
 }
 export interface DThemeTableRow extends DThemeLayoutHorizontal {
 }
-export interface DTableRowColumn {
+export interface DTableRowColumn extends utils.EventEmitter {
     weight?: number;
+    width?: number;
     frozen?: boolean;
     offset: number;
 }
-export declare abstract class DTableRow<ROW, COLUMN extends DTableRowColumn, THEME extends DThemeTableRow = DThemeTableRow, OPTIONS extends DTableRowOptions<ROW, COLUMN, THEME> = DTableRowOptions<ROW, COLUMN, THEME>> extends DLayoutHorizontal<THEME, OPTIONS> {
+export declare abstract class DTableRow<ROW, COLUMN extends DTableRowColumn, THEME extends DThemeTableRow = DThemeTableRow, OPTIONS extends DTableRowOptions<THEME> = DTableRowOptions<THEME>> extends DLayoutHorizontal<THEME, OPTIONS> {
     protected _columns: COLUMN[];
     protected _frozen: number;
-    constructor(options: OPTIONS);
-    protected initCells(options: OPTIONS, columns: COLUMN[], frozen: number): void;
+    constructor(columns: COLUMN[], frozen: number, options?: OPTIONS);
+    protected initCells(): void;
     protected toIndexEnd(columns: COLUMN[]): number;
     protected onRefit(): void;
     updateFrozenCellPosition(x: number): void;
     protected resetFrozenCellPosition(): void;
     protected abstract getContentPositionX(): number;
     getClippingRect(target: unknown, result: Rectangle): void;
-    protected abstract newCell(columnIndex: number, column: COLUMN, columns: COLUMN[], options: OPTIONS): DBase;
+    protected abstract newCell(columnIndex: number, column: COLUMN, columns: COLUMN[], options?: OPTIONS): DBase;
     protected getType(): string;
 }

package/dist/types/wcardinal/ui/d-table-state.d.ts

@@ -46,4 +46,12 @@ export declare const DTableState: {
      * Selectable row
      */
     SELECTABLE: string;
+    /**
+     * Header or category cells hovered on their edges.
+     */
+    HOVERED_ON_EDGE: string;
+    /**
+     * Header or category of being resized.
+     */
+    RESIZING: string;
 };