@g1cloud/open-bluesea-grid 1.0.0-alpha.1

package/css/bluesea-grid.css

@@ -0,0 +1 @@
+@import '../dist/open-bluesea-grid.css';

package/dist/BSGridColumnSettingModal-GMHDkrKO.js

@@ -0,0 +1,4 @@
+import { BSGridColumnSettingModal as _sfc_main } from "./open-bluesea-grid.es.js";
+export {
+  _sfc_main as default
+};

package/dist/component/DateFilterModel.d.ts

@@ -0,0 +1,18 @@
+import { BetweenDateFilter } from "@/model/FilterModel.ts";
+import { Dayjs } from "dayjs";
+import { type DateRangePreset } from "./DateRangePresetModel.ts";
+import type { TimeZone } from "@g1cloud/open-bluesea-core";
+export type DateRange = {
+    from?: string;
+    to?: string;
+};
+export type DateRangePresetKey = string;
+export declare const convertDateRangePresetKey: (preset: DateRangePreset) => DateRangePresetKey;
+export declare class BetweenDateFilterWithPreset extends BetweenDateFilter {
+    readonly name: string;
+    readonly fromValue?: (Date | Dayjs | string) | undefined;
+    readonly toValue?: (Date | Dayjs | string) | undefined;
+    presetKey?: DateRangePresetKey;
+    constructor(name: string, fromValue?: (Date | Dayjs | string) | undefined, toValue?: (Date | Dayjs | string) | undefined, preset?: DateRangePreset);
+    static createFromPresetKey(name: string, presetKey: DateRangePresetKey, candidatePresets: DateRangePreset[], timeZone: TimeZone): BetweenDateFilterWithPreset | undefined;
+}

package/dist/component/DateRangePresetModel.d.ts

@@ -0,0 +1,15 @@
+import type { TimeZone } from "@g1cloud/open-bluesea-core";
+import { Dayjs } from "dayjs";
+import type { DateRange } from "./DateFilterModel.ts";
+export type MomentType = 'TODAY' | 'THIS_WEEK' | 'THIS_MONTH' | 'THIS_YEAR' | 'LAST_HOURS' | 'LAST_DAYS' | 'DAYS_AGO' | 'WEEKS_AGO' | 'MONTHS_AGO' | 'YEARS_AGO';
+export type MomentSetting = {
+    type: MomentType;
+    value?: number;
+};
+export type DateRangePreset = {
+    caption: string;
+    from?: MomentSetting;
+    to?: MomentSetting;
+};
+export declare const createDateRangeFromPreset: (value: DateRangePreset, timeZone: TimeZone) => DateRange;
+export declare const resolveMoment: (setting: MomentSetting, from: boolean, timeZone: TimeZone, baseDate?: Dayjs) => Dayjs | undefined;

package/dist/component/GridExtension.d.ts

@@ -0,0 +1,16 @@
+import type { Column } from "./GridModel.ts";
+import type { MenuItem } from "@g1cloud/open-bluesea-core";
+export type GridExtensionContext = {
+    gridId?: string;
+    table?: HTMLTableElement;
+};
+export type GridContextMenuType = 'HeaderCell' | 'BodyCell';
+export type GridContextMenuParam = {
+    type: GridContextMenuType;
+    column: Column;
+    row?: unknown;
+    cell?: unknown;
+};
+export type GridExtension = {
+    extendsContextMenu?: (event: MouseEvent, param: GridContextMenuParam, context: GridExtensionContext) => MenuItem[] | undefined;
+};

package/dist/component/GridLib.d.ts

@@ -0,0 +1,21 @@
+import type { Column, GridColumnSetting } from "./GridModel";
+import type { MenuItem } from "@g1cloud/open-bluesea-core";
+import type { GridContextMenuParam } from "./GridExtension.ts";
+export type ColumnRender = {
+    width: number;
+    fixed?: boolean;
+    hidden?: boolean;
+};
+export type InternalColumn = Column & {
+    templateId: string;
+    render: ColumnRender;
+};
+export declare const setFixedCellLeftStyle: (table?: HTMLTableElement | null) => Promise<void>;
+export declare const styleCssToObject: (style?: string) => Record<string, string>;
+export declare const styleClassToObject: (style?: string) => Record<string, boolean>;
+export declare const filterSlotName: (column: Column) => string;
+export declare const editComponentSlotName: (column: Column) => string;
+export type GridExtensionHandler = {
+    handleExtendsContextMenu: (event: MouseEvent, param: GridContextMenuParam) => MenuItem[] | undefined;
+};
+export declare const mergeColumnSettings: (columns: Column[], settings: GridColumnSetting[]) => GridColumnSetting[];

package/dist/component/GridModel.d.ts

@@ -0,0 +1,402 @@
+import type { SavePoint, DisplayDateResolution, KeyProvider, TimeZone, RawData } from "@g1cloud/open-bluesea-core";
+import { SearchParam, type Sort } from "@/model/SearchModel";
+import { PaginatedList } from "@/model/PaginatedList";
+import { type Raw, type UnwrapNestedRefs } from "vue";
+import { AndFilter, EqualFilter, type Filter, InFilter, LikeFilter, OrFilter } from "@/model/FilterModel";
+export declare const DEFAULT_GRID_COLUMN_WIDTH = 100;
+export type GridCellType = 'TEXT' | 'NUMBER' | 'DATE' | 'PERCENTAGE' | 'BOOL' | 'MULTI_LANG_STRING' | 'NAME' | 'TEL' | 'ADDRESS' | 'MONEY';
+export type GridRowData = Record<string, any>;
+export type Column<T extends GridRowData = GridRowData> = {
+    propertyId: string;
+    templateId?: string;
+    caption: string;
+    cellType?: GridCellType;
+    dateFormat?: string | DisplayDateResolution;
+    width?: number;
+    cellStyleClass?: string;
+    cellStyleCss?: string;
+    headerCellStyleClass?: string;
+    headerCellStyleCss?: string;
+    sortable?: boolean;
+    sortPropertyId?: string;
+    tooltipProvider?: (row: T) => string | undefined;
+};
+export type PageInfo = {
+    offset?: number;
+    limit?: number;
+    totalCount?: number;
+};
+export type FilterValueType = 'STRING' | 'NUMBER';
+export type FilterItem = {
+    propertyId: string;
+    caption: string;
+    allowMultiLineFilter?: boolean;
+    filterType?: FilterValueType;
+};
+export type TextFilterCreator = (propertyId: string, keyword: string) => (InFilter | LikeFilter | EqualFilter | OrFilter)[] | Promise<(InFilter | LikeFilter | EqualFilter | OrFilter)[]>;
+export type TextFilterItem = FilterItem & {
+    filterCreator?: TextFilterCreator;
+    prefix?: boolean;
+    suffix?: boolean;
+};
+export type GridLookupConfigTextFilter = {
+    filterItems: TextFilterItem[];
+};
+export type DateFilterItem = FilterItem & {
+    timeZone?: TimeZone;
+    dateFormat?: string;
+    popupDateFormat?: string;
+    filterWidth?: string;
+};
+export type GridLookupConfigDateFilter = {
+    filterItems: DateFilterItem[];
+};
+export type GridLookupConfig = {
+    textFilter?: GridLookupConfigTextFilter;
+    dateFilter?: GridLookupConfigDateFilter;
+};
+/**
+ * BSGridLookup 에서 EmbeddableName property 에 사용할 수 있는 TextFilterCreator
+ *
+ * ```ts
+ * export const gridLookupConfig: GridLookupConfig = reactive({
+ *   textFilter: {
+ *     filterItems: [
+ *       {propertyId: 'memberName', caption: '회원명', filterCreator: nameFilterCreator()}
+ *     ]
+ *   },
+ * ```
+ * @param maxIndex 예를 들어 이 값이 4 이면, name1, name2, name3, name4 에 대해 like 검색을 한다.
+ */
+export declare const nameFilterCreator: (maxIndex?: number) => TextFilterCreator;
+export type EditingRow<T> = {
+    row: T;
+    savePoint?: SavePoint;
+};
+export declare class EditingRows<T> {
+    keyProvider?: KeyProvider<T> | undefined;
+    rows: EditingRow<T>[];
+    constructor(keyProvider?: KeyProvider<T> | undefined);
+    addEditingRow(row: EditingRow<T>): void;
+    addRow(row: T): void;
+    rowEquals(a: T, b: T): boolean;
+    removeRow(row: T): void;
+    clear(): void;
+    getEditingRow(row: T): EditingRow<T> | undefined;
+    isEditingRow(row: T): boolean;
+    getRows(): EditingRow<T>[];
+    getModifiedRows(): EditingRow<T>[];
+}
+export type SelectedRowsChangedEvent<T extends GridRowData> = {
+    allRows: boolean;
+    targetRows?: T[];
+    selected: boolean;
+};
+export interface PageGridHandler<T extends GridRowData> {
+    searchParam: SearchParam;
+    grid: UnwrapNestedRefs<GridBinding<T>>;
+    gridEventListener: GridEventListener<T>;
+    control?: UnwrapNestedRefs<GridControlBinding<T>>;
+    controlEventListener?: GridControlEventListener;
+    lookup?: UnwrapNestedRefs<GridLookupBinding>;
+    lookupEventListener?: GridLookupEventListener;
+    loadGridData: (offset?: number) => Promise<void>;
+    getSelectedRows: () => Set<T>;
+    getEditingRows: () => EditingRows<T>;
+    getAddedRows: () => T[];
+    getModifiedRows: () => T[];
+    getDeletedRows: () => T[];
+    isAddedRow: (row: T) => boolean;
+    addNewRow: (newRow: T) => number;
+    /**
+     * Grid 에 add, modified, delete 된 row 가 있으면 true 를 리턴한다.
+     */
+    isGridModified: () => boolean;
+    preferenceLoaded: boolean;
+}
+export type GridBinding<T extends GridRowData> = {
+    gridId?: string;
+    pageInfo?: PageInfo;
+    sorts?: Sort[];
+    data: T[] | Raw<T[]>;
+    loading?: boolean;
+    keyProvider: KeyProvider<T>;
+    editable?: boolean;
+    rowEditPolicy?: (row: T, editingRows: EditingRows<T>) => boolean;
+    selectedRows?: Set<T>;
+    editingRows?: EditingRows<T>;
+    rowDisplayPolicy?: (row: T) => boolean;
+    rowSelectPolicy?: (row: T) => boolean;
+    columnSettings?: GridColumnSetting[];
+    fixedColumnCount?: number;
+};
+export type GridEventListener<T extends GridRowData> = {
+    'update:selectedRows'?: (rows: Set<T>) => void;
+    'update:editingRows'?: (editingRows: EditingRows<T>) => void;
+    offsetChanged?: (offset: number, pageInfo: PageInfo) => void;
+    changeEditingRow?: (row: T, editing: boolean) => void;
+    'update:sorts'?: (sorts: Sort[]) => void;
+    settingChanged?: (columnSettings?: GridColumnSetting[], fixedColumnCount?: number) => void;
+};
+export type GridControlBinding<T extends GridRowData> = {
+    gridId?: string;
+    limit?: number;
+    selectedRows?: Set<T>;
+    totalCount: number;
+    columnSettings?: GridColumnSetting[];
+    fixedColumnCount?: number;
+};
+export type GridControlEventListener = {
+    'update:limit'?: (limit: number) => void;
+    refresh?: () => void;
+    clearFilter?: () => void;
+    clickAdd?: () => void;
+    clickRemove?: () => void;
+    settingChanged?: (columnSettings?: GridColumnSetting[], fixedColumnCount?: number) => void;
+};
+export type GridLookupBinding = {
+    gridId?: string;
+    modelValue: Filter[];
+    gridPreferenceDateFilterValues?: RawData<AndFilter>;
+};
+export type GridLookupEventListener = {
+    'update:modelValue': (value: Filter[]) => void;
+    search: (filters: Filter[]) => void;
+};
+export type GridHandlerOption<T extends GridRowData> = {
+    /**
+     * Grid 설정 정보를 저장할 때 사용된다.
+     */
+    gridId?: string;
+    /**
+     * 편집가능 여부
+     */
+    editable?: boolean;
+    /**
+     * Grid 에서 각 Row 를 구분할 수 있는 key 를 리턴한다. 주로 일련번호, 코드 등의 값이다.
+     * @param row
+     */
+    getRowKey: (row: T) => string;
+    /**
+     * 새로운 Row 를 생성한다. '행 추가' 기능으로 행이 추가될 때 호출된다.
+     */
+    newRowCreator?: () => T | undefined;
+    /**
+     * 이 값이 true 이면 행 추가 시 Grid data 마지막에 추가된다. 디폴트는 false 이다.
+     */
+    addRowToLast?: boolean;
+    /**
+     * 행이 삭제될 때 호출되는 함수.
+     * 이 함수를 지정하지 않거나 false 를 리턴하면, grid data 목록에서 해당 행이 삭제된다.
+     * 이 함수가 true 를 리턴하면 GridHandler 는 아무런 작업도 하지 않는다.
+     * @param rows 선택된 행
+     * @return 이 handler 에서 행 삭제를 처리했으면 true 를 리턴. 그렇지 않으면 false 를 리턴.
+     */
+    removeRowHandler?: (rows: Set<T>) => boolean;
+    /**
+     * Row 가 편집가능한지 여부를 리턴한다.
+     * Row 별로 편집가능여부를 제어할 때 사용.
+     * @param row 편집이 가능한지 확인하려는 Row
+     * @param editingRows 현재 편집중인 Row
+     */
+    isRowEditable?: (row: T, editingRows: EditingRows<T>) => boolean;
+    /**
+     * Row 가 선택 가능한지 여부를 리턴한다.
+     * Row 별로 선택가능여부를 제어할 때 사용.
+     * @param row
+     */
+    isRowSelectable?: (row: T) => boolean;
+};
+export type PageGridHandlerOption<T extends GridRowData> = GridHandlerOption<T> & {
+    getGridData: (param: SearchParam) => PaginatedList<T> | Promise<PaginatedList<T>>;
+    /**
+     * 초기 Limit 개수. 디폴트: 100
+     */
+    limit?: number;
+    /**
+     * Limit 목록. 디폴트: [100, 300, 500]
+     */
+    limitItems?: number[];
+    defaultFilter?: Filter[];
+    defaultSorts?: Sort[];
+};
+export declare const createPageGridHandler: <T extends GridRowData>(option: PageGridHandlerOption<T>) => PageGridHandler<T>;
+export declare class PageGridHandlerImpl<T extends GridRowData> implements PageGridHandler<T> {
+    option: PageGridHandlerOption<T>;
+    searchParam: SearchParam;
+    selectDeleteSupport: GridHandlerSelectDeleteSupport<T>;
+    grid: UnwrapNestedRefs<GridBinding<T>>;
+    gridEventListener: GridEventListener<T>;
+    control: UnwrapNestedRefs<GridControlBinding<T>>;
+    controlEventListener: GridControlEventListener;
+    lookup: GridLookupBinding;
+    lookupEventListener: GridLookupEventListener;
+    preferenceLoader?: GridPreferenceLoader;
+    constructor(option: PageGridHandlerOption<T>);
+    get preferenceLoaded(): boolean;
+    getSelectedRows(): Set<T>;
+    getEditingRows(): EditingRows<T>;
+    getAddedRows(): T[];
+    getModifiedRows(): T[];
+    getDeletedRows(): T[];
+    isAddedRow(_row: T): boolean;
+    addNewRow(_newRow: T): number;
+    isGridModified(): boolean;
+    /**
+     *
+     * @param offset
+     */
+    loadGridData(offset?: number): Promise<void>;
+    loadPreference(): void;
+    protected doSetSearchResult(result: PaginatedList<T>): void;
+    protected updateCounts(): void;
+}
+export declare class EditablePageGridHandlerImpl<T extends GridRowData> extends PageGridHandlerImpl<T> {
+    editableSupport: GridHandlerEditableSupport<T>;
+    constructor(option: PageGridHandlerOption<T>);
+    getModifiedRows(): T[];
+    getAddedRows(): T[];
+    isAddedRow(row: T): boolean;
+    addNewRow(newRow: T): number;
+    protected doSetSearchResult(result: PaginatedList<T>): void;
+}
+export interface InputGridHandler<T extends GridRowData> {
+    grid: UnwrapNestedRefs<GridBinding<T>>;
+    gridEventListener: GridEventListener<T>;
+    control: UnwrapNestedRefs<GridControlBinding<T>>;
+    controlEventListener: GridControlEventListener;
+    gridFilter: Record<string, any>;
+    setGridData: (data?: T[]) => void;
+    getSelectedRows: () => Set<T>;
+    getEditingRows: () => EditingRows<T>;
+    getAddedRows: () => T[];
+    getModifiedRows: () => T[];
+    getDeletedRows: () => T[];
+    isAddedRow: (row: T) => boolean;
+    addNewRow: (newRow: T) => number;
+    /**
+     * Grid 에 add, modified, delete 된 row 가 있으면 true 를 리턴한다.
+     */
+    isGridModified: () => boolean;
+    preferenceLoaded: boolean;
+}
+export type InputGridHandlerOption<T extends GridRowData> = GridHandlerOption<T> & {};
+export declare const createInputGridHandler: <T extends GridRowData>(option: InputGridHandlerOption<T>) => InputGridHandler<T>;
+export declare class InputGridHandlerImpl<T extends GridRowData> implements InputGridHandler<T> {
+    option: InputGridHandlerOption<T>;
+    selectDeleteSupport: GridHandlerSelectDeleteSupport<T>;
+    grid: UnwrapNestedRefs<GridBinding<T>>;
+    gridEventListener: GridEventListener<T>;
+    control: UnwrapNestedRefs<GridControlBinding<T>>;
+    controlEventListener: GridControlEventListener;
+    gridFilter: Record<string, any>;
+    preferenceLoader?: GridPreferenceLoader;
+    constructor(option: InputGridHandlerOption<T>);
+    get preferenceLoaded(): boolean;
+    setGridData(data?: T[]): void;
+    getSelectedRows(): Set<T>;
+    getEditingRows(): EditingRows<T>;
+    getDeletedRows(): T[];
+    getAddedRows(): T[];
+    getModifiedRows(): T[];
+    isAddedRow(_row: T): boolean;
+    addNewRow(_newRow: T): number;
+    isGridModified(): boolean;
+    loadPreference(): void;
+    protected updateCounts(): void;
+    protected applyGridFilter(row: T): boolean;
+}
+export declare class EditableInputGridHandlerImpl<T extends GridRowData> extends InputGridHandlerImpl<T> {
+    editableSupport: GridHandlerEditableSupport<T>;
+    constructor(option: InputGridHandlerOption<T>);
+    setGridData(data: T[]): void;
+    getModifiedRows(): T[];
+    getAddedRows(): T[];
+    isAddedRow(row: T): boolean;
+    addNewRow(newRow: T): number;
+}
+export declare class GridHandlerSelectDeleteSupport<T extends GridRowData> {
+    grid: UnwrapNestedRefs<GridBinding<T>>;
+    control: UnwrapNestedRefs<GridControlBinding<T>>;
+    controlEventListener: GridControlEventListener;
+    removeRowHandler?: ((rows: Set<T>) => boolean) | undefined;
+    private listener?;
+    selectedRows: import("vue").Reactive<Set<T>>;
+    deletedRows: T[];
+    isAddedRow?: (row: T) => boolean;
+    removeIfAddedRow?: (row: T) => void;
+    constructor(grid: UnwrapNestedRefs<GridBinding<T>>, control: UnwrapNestedRefs<GridControlBinding<T>>, controlEventListener: GridControlEventListener, removeRowHandler?: ((rows: Set<T>) => boolean) | undefined, listener?: ((eventType: "selectedRowsChanged") => void) | undefined);
+    removeSelectedRows(): void;
+    clear(): void;
+}
+export declare class GridHandlerEditableSupport<T extends GridRowData> {
+    grid: UnwrapNestedRefs<GridBinding<T>>;
+    gridEventListener: GridEventListener<T>;
+    controlEventListener: GridControlEventListener;
+    newRowCreator?: (() => T | undefined) | undefined;
+    addRowToLast?: boolean | undefined;
+    private listener?;
+    addedRows: T[];
+    constructor(grid: UnwrapNestedRefs<GridBinding<T>>, gridEventListener: GridEventListener<T>, controlEventListener: GridControlEventListener, getRowKey: KeyProvider<T>, newRowCreator?: (() => T | undefined) | undefined, addRowToLast?: boolean | undefined, listener?: ((eventType: "rowAdded" | "rowRemoved") => void) | undefined);
+    static cleanUpData<T extends GridRowData>(data: T[]): void;
+    getModifiedRows(): T[];
+    getAddedRows(): T[];
+    clearAddedRows(): void;
+    isAddedRow(row: T): boolean;
+    getNewRowKey(row: T): string | undefined;
+    setNewRowKey(row: T): void;
+    removeIfAddedRow(row: T): boolean;
+    addNewRow(newRow: T): number;
+    protected appendAddedRow(row: T): void;
+    protected createAndAddNewRow(): void;
+}
+declare class GridPreferenceLoader {
+    private gridId;
+    private handler;
+    preferenceLoaded: import("vue").Ref<boolean, boolean>;
+    private loadPromise;
+    constructor(gridId: string, handler: PageGridHandler<any> | InputGridHandler<any>);
+    loadGridPreference(): Promise<void>;
+    waitForLoaded(): Promise<void>;
+}
+export type GridColumnSetting = {
+    propertyId: string;
+    hidden?: boolean;
+    width?: number;
+};
+export type GridPreference = {
+    columnSettings?: GridColumnSetting[];
+    fixedColumnCount?: number;
+    dateFilterValues?: RawData<AndFilter>;
+};
+export interface GridPreferenceStore {
+    storePreference: (gridId: string, preference: GridPreference) => Promise<void>;
+    loadPreference: (gridId: string) => Promise<GridPreference | undefined>;
+    removePreference: (gridId: string) => Promise<void>;
+}
+export declare class LocalStorageGridPreferenceStore implements GridPreferenceStore {
+    storePreference(gridId: string, preference: GridPreference): Promise<void>;
+    loadPreference(gridId: string): Promise<any>;
+    removePreference(gridId: string): Promise<void>;
+}
+/**
+ * BSGrid 에서 값이 같은 cell 을 세로로 머지한다.
+ *
+ * @table-changed 이벤트 핸들러에서 이 함수를 호출하는 방식으로 사용함.
+ *
+ * ```
+ * <BSGrid ...
+ *   @table-changed="table => mergeSameValueVertical(['supplierCode'], table)">
+ * ```
+ *
+ * @param propertyIds
+ * @param table
+ */
+export declare const mergeSameValueVertical: (propertyIds: string[], table?: HTMLTableElement) => void;
+/**
+ * default cell formatter for BSGridCell
+ * @param column
+ * @param value
+ */
+export declare const defaultCellFormatter: <T>(column: Column, value: T) => string | T | null;
+export {};

package/dist/component/vDndSupport.d.ts

@@ -0,0 +1,17 @@
+import type { DirectiveBinding } from "vue";
+export type DndContext = {
+    sourceElement: HTMLElement;
+    key?: unknown;
+    sourceType?: string;
+    dropPosition?: HTMLElement;
+};
+export type KeyProvider = (sourceElement: HTMLElement) => unknown;
+export type CreateDropPosition = (dndContext: DndContext, target: HTMLElement, direction: 'horizontal' | 'vertical') => HTMLElement;
+export type LocateDropPosition = (dndContext: DndContext, target: HTMLElement, dropPosition: HTMLElement, beforeOrAfter: 'before' | 'after', direction: 'horizontal' | 'vertical') => void;
+export type DropHandler = (dndContext: DndContext, target: HTMLElement, beforeOrAfter: 'before' | 'after') => void;
+export declare const vDragSupport: {
+    mounted: (el: HTMLElement, binding: DirectiveBinding) => void;
+};
+export declare const vDropSupport: {
+    mounted: (el: HTMLElement, binding: DirectiveBinding) => void;
+};

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+export { default as BSGrid } from './component/BSGrid.vue';
+export { default as BSGridCell } from './component/BSGridCell.vue';
+export { default as BSGridCellCheckbox } from './component/BSGridCellCheckbox.vue';
+export { default as BSGridCellDragHandle } from './component/BSGridCellDragHandle.vue';
+export { default as BSGridCellEdit } from './component/BSGridCellEdit.vue';
+export { default as BSGridCellSerialNo } from './component/BSGridCellSerialNo.vue';
+export { default as BSGridColumnSettingModal } from './component/BSGridColumnSettingModal.vue';
+export { default as BSGridControl } from './component/BSGridControl.vue';
+export { default as BSGridHeaderCell } from './component/BSGridHeaderCell.vue';
+export { default as BSGridHeaderCellCheckbox } from './component/BSGridHeaderCellCheckbox.vue';
+export { default as BSGridHeaderCellResizeHandle } from './component/BSGridHeaderCellResizeHandle.vue';
+export { default as BSGridHeaderCellSerialNo } from './component/BSGridHeaderCellSerialNo.vue';
+export { default as BSGridLookup } from './component/BSGridLookup.vue';
+export { default as BSGridRow } from './component/BSGridRow.vue';
+export { default as BSTextFilter } from './component/BSTextFilter.vue';
+export { default as BSDateRangeFilter } from './component/BSDateRangeFilter.vue';
+export { default as BSDateRangeFilters } from './component/BSDateRangeFilters.vue';
+export { default as BSDateRangePresets } from './component/BSDateRangePresets.vue';
+export { vDragSupport, vDropSupport } from './component/vDndSupport';
+export type * from './component/vDndSupport';
+export * from './component/GridModel';
+export type * from './component/GridModel';
+export * from './component/GridLib';
+export * from './component/GridExtension';
+export * from './component/DateFilterModel';
+export type * from './component/DateFilterModel';
+export * from './component/DateRangePresetModel';
+export type * from './component/DateRangePresetModel';
+export * from './model/FilterModel';
+export type * from './model/FilterModel';
+export * from './model/PaginatedList';
+export type * from './model/PaginatedList';
+export * from './model/SearchModel';
+export type * from './model/SearchModel';

package/dist/model/FilterModel.d.ts

@@ -0,0 +1,113 @@
+import { Dayjs } from "dayjs";
+export type FilterType = 'AND' | 'OR' | 'IN' | 'BT_V' | 'BT_D' | 'EQ' | 'NOT' | 'LIKE' | 'NU' | 'NN';
+export interface Filter {
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export interface LeafFilter {
+    getFilterValueString(): string | string[];
+}
+export declare abstract class AbstractFilter implements Filter {
+    protected type: FilterType;
+    protected constructor(type: FilterType);
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export declare class AndFilter extends AbstractFilter {
+    readonly filters: Filter[];
+    constructor(filters: Filter[]);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export declare class OrFilter extends AbstractFilter {
+    readonly filters: Filter[];
+    constructor(filters: Filter[]);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export declare class NotFilter extends AbstractFilter {
+    readonly filter: Filter;
+    constructor(filter: Filter);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export declare class InFilter extends AbstractFilter implements LeafFilter {
+    readonly names: string[];
+    readonly values: (string | number)[];
+    readonly ignoreCase?: boolean | undefined;
+    constructor(names: string[], values: (string | number)[], ignoreCase?: boolean | undefined);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    getFilterValueString(): string | string[];
+    isEmpty(): boolean;
+}
+export declare class LikeFilter extends AbstractFilter implements LeafFilter {
+    readonly names: string[];
+    readonly value: string;
+    readonly prefix?: boolean | undefined;
+    readonly suffix?: boolean | undefined;
+    readonly ignoreCase: boolean;
+    constructor(names: string[], value: string, prefix?: boolean | undefined, suffix?: boolean | undefined, ignoreCase?: boolean);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    getFilterValueString(): string | string[];
+    isEmpty(): boolean;
+}
+export declare class EqualFilter extends AbstractFilter implements LeafFilter {
+    readonly names: string[];
+    readonly value: string | number | boolean;
+    readonly ignoreCase?: boolean | undefined;
+    constructor(names: string[], value: string | number | boolean, ignoreCase?: boolean | undefined);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    getFilterValueString(): string | string[];
+    isEmpty(): boolean;
+}
+export declare class BetweenFilter extends AbstractFilter {
+    readonly name: string;
+    readonly fromValue?: string | number | undefined;
+    readonly toValue?: string | number | undefined;
+    constructor(name: string, fromValue?: string | number | undefined, toValue?: string | number | undefined);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export declare class BetweenDateFilter extends AbstractFilter {
+    readonly name: string;
+    readonly fromValue?: (Date | Dayjs | string) | undefined;
+    readonly toValue?: (Date | Dayjs | string) | undefined;
+    constructor(name: string, fromValue?: (Date | Dayjs | string) | undefined, toValue?: (Date | Dayjs | string) | undefined);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    isEmpty(): boolean;
+}
+export declare class IsNullFilter extends AbstractFilter implements LeafFilter {
+    readonly names: string[];
+    constructor(names: string[]);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    getFilterValueString(): string | string[];
+    isEmpty(): boolean;
+}
+export declare class IsNotNullFilter extends AbstractFilter implements LeafFilter {
+    readonly names: string[];
+    constructor(names: string[]);
+    toString(): string;
+    serialize(): unknown[] | undefined;
+    getFilterValueString(): string | string[];
+    isEmpty(): boolean;
+}
+export declare const andFilter: (filters: Filter[]) => AndFilter;
+export declare const orFilter: (filters: Filter[]) => OrFilter;
+export declare const notFilter: (filter: Filter) => NotFilter;
+export declare const inFilter: (names: string[], values: (string | number)[], ignoreCase?: boolean) => InFilter;
+export declare const likeFilter: (names: string[], value: string, prefix?: boolean, suffix?: boolean, ignoreCase?: boolean) => LikeFilter;
+export declare const equalFilter: (names: string[], value: string | number | boolean, ignoreCase?: boolean) => EqualFilter;
+export declare const betweenFilter: (name: string, fromValue?: string | number, toValue?: string | number) => BetweenFilter;
+export declare const betweenDateFilter: (name: string, fromValue?: Date | Dayjs | string, toValue?: Date | Dayjs | string) => BetweenDateFilter;
+export declare const isNullFilter: (names: string[]) => IsNullFilter;
+export declare const isNotNullFilter: (names: string[]) => IsNotNullFilter;
+export declare const acceptFilter: (filter: Filter, visit: (filter: Filter) => boolean | undefined) => void;