@honed/table 0.9.1 → 0.10.0

package/dist/index.d.ts

@@ -1,33 +1,27 @@
-import { BindingOptions } from '@honed/refine';
+import { Binding } from '@honed/action';
 import { BulkOperation } from '@honed/action';
 import { BulkSelection } from '@honed/action';
-import { ComputedRef } from 'vue';
-import { Direction } from '@honed/refine';
 import { Executable } from '@honed/action';
-import { Filter } from '@honed/refine';
-import { FilterBinding } from '@honed/refine';
-import { FilterValue } from '@honed/refine';
-import { HonedFilter } from '@honed/refine';
 import { HonedRefine } from '@honed/refine';
-import { HonedSearch } from '@honed/refine';
-import { HonedSort } from '@honed/refine';
 import { InlineOperation } from '@honed/action';
-import { MatchBinding } from '@honed/refine';
 import { MaybeEndpoint } from '@honed/action';
 import { MaybeId } from '@honed/action';
 import { PageOperation } from '@honed/action';
 import { PageOperationData } from '@honed/action';
-import { Ref } from 'vue';
+import { RecordBinding } from '@honed/action';
 import { Refine } from '@honed/refine';
-import { Search } from '@honed/refine';
-import { SearchBinding } from '@honed/refine';
 import { Sort } from '@honed/refine';
-import { SortBinding } from '@honed/refine';
-import { Visit } from '@inertiajs/core';
-import { VisitCallbacks } from '@inertiajs/core';
 import { VisitOptions } from '@inertiajs/core';
 
-export declare interface BaseColumn<T extends Record<string, any> = Record<string, any>> {
+export declare interface Classes {
+    classes?: string;
+}
+
+export declare interface CollectionPaginate {
+    empty: boolean;
+}
+
+export declare interface Column<T extends Record<string, any> = Record<string, any>> {
     name: keyof T;
     label: string;
     type?: ColumnType;
@@ -36,19 +30,10 @@ export declare interface BaseColumn<T extends Record<string, any> = Record<strin
     badge?: boolean;
     toggleable: boolean;
     class?: string;
-    record_class?: string;
     icon?: string;
     sort?: Pick<Sort, "active" | "direction" | "next">;
 }
 
-export declare interface CollectionPaginate {
-    empty: boolean;
-}
-
-export declare interface Column<T extends Record<string, any> = Record<string, any>> extends BaseColumn<T> {
-    toggle: (options: VisitOptions) => void;
-}
-
 export declare type ColumnType = "array" | "badge" | "boolean" | "color" | "date" | "datetime" | "icon" | "image" | "numeric" | "text" | "time" | string;
 
 export declare interface CursorPaginate extends CollectionPaginate {
@@ -64,31 +49,47 @@ export declare interface EmptyState {
     operations: PageOperation[];
 }
 
-export declare interface Heading<T extends Record<string, any> = Record<string, any>> extends BaseColumn<T> {
+export declare interface Heading<T extends Record<string, any> = Record<string, any>> extends Column<T> {
     isSorting: boolean;
-    toggleSort: (options: VisitOptions) => void;
+    toggleSort: (options?: VisitOptions) => void;
+}
+
+export declare interface HonedColumn<T extends Record<string, any> = Record<string, any>> extends Column<T> {
+    toggle: (options: VisitOptions) => void;
 }
 
 export declare interface HonedTable<T extends Record<string, any> = Record<string, any>, K extends Paginate = "length-aware"> extends HonedRefine {
-    meta: ComputedRef<Record<string, any> | null>;
-    isEmpty: ComputedRef<boolean>;
-    isPageable: ComputedRef<boolean>;
-    isToggleable: ComputedRef<boolean>;
+    id: Exclude<MaybeId, undefined>;
+    meta: Record<string, any> | null;
+    emptyState: EmptyState | null;
+    views: View[];
+    placeholder: string | null;
+    isEmpty: boolean;
+    isPageable: boolean;
+    isToggleable: boolean;
     getRecordKey: (record: TableEntry<T>) => Identifier;
-    headings: ComputedRef<Heading<T>[]>;
-    columns: ComputedRef<Column<T>[]>;
-    records: ComputedRef<TableRecord<T>[]>;
-    inline: ComputedRef<boolean>;
-    bulk: ComputedRef<Executable<BulkOperation>[]>;
-    page: ComputedRef<Executable<PageOperation>[]>;
-    pages: ComputedRef<PageOption[]>;
-    currentPage: ComputedRef<PageOption | undefined>;
-    paginator: ComputedRef<PaginateMap[K]>;
+    getEntry: (record: TableEntry<T>, column: Column<T> | string) => {
+        v: any;
+        e: any;
+        c: string | null;
+        f: boolean;
+    } | null;
+    getValue: (record: TableEntry<T>, column: Column<T> | string) => any;
+    getExtra: (record: TableEntry<T>, column: Column<T> | string) => any;
+    headings: Heading<T>[];
+    columns: HonedColumn<T>[];
+    records: TableRecord<T>[];
+    inline: boolean;
+    bulk: Executable<BulkOperation>[];
+    page: Executable<PageOperation>[];
+    pages: PageOption[];
+    currentPage: PageOption | undefined;
+    paginator: PaginateMap[K];
     executeInline: (operation: InlineOperation, data: TableEntry<T>, options?: VisitOptions) => void;
     executeBulk: (operation: BulkOperation, options?: VisitOptions) => void;
     executePage: (operation: PageOperation, data?: PageOperationData, options?: VisitOptions) => void;
     applyPage: (page: PageOption, options?: VisitOptions) => void;
-    selection: Ref<BulkSelection<Identifier>, BulkSelection<Identifier>>;
+    selection: BulkSelection<Identifier>;
     select: (record: TableEntry<T>) => void;
     deselect: (record: TableEntry<T>) => void;
     toggle: (record: TableEntry<T>) => void;
@@ -97,11 +98,11 @@ export declare interface HonedTable<T extends Record<string, any> = Record<strin
     selected: (record: TableEntry<T>) => boolean;
     selectAll: () => void;
     deselectAll: () => void;
-    isPageSelected: ComputedRef<boolean>;
-    hasSelected: ComputedRef<boolean>;
-    bindCheckbox: (record: TableEntry<T>) => void;
-    bindPage: () => void;
-    bindAll: () => void;
+    isPageSelected: boolean;
+    hasSelected: boolean;
+    bindCheckbox: (record: TableEntry<T>) => RecordBinding<Identifier>;
+    bindPage: () => Binding;
+    bindAll: () => Binding;
 }
 
 export declare type Identifier = string | number;
@@ -117,11 +118,6 @@ export declare interface LengthAwarePaginate extends SimplePaginate {
     links: PaginatorLink[];
 }
 
-export declare interface PageBinding {
-    "onUpdate:modelValue": (checked: boolean | "indeterminate") => void;
-    modelValue: boolean;
-}
-
 export declare interface PageOption {
     value: number;
     active: boolean;
@@ -157,7 +153,7 @@ export declare interface Table<T extends Record<string, any> = Record<string, an
         operations: InlineOperation[];
     }>;
     paginate: PaginateMap[K];
-    columns: BaseColumn<T>[];
+    columns: Column<T>[];
     pages: PageOption[];
     toggleable: boolean;
     operations: {
@@ -170,14 +166,14 @@ export declare interface Table<T extends Record<string, any> = Record<string, an
     meta: Record<string, any>;
 }
 
-export declare type TableEntry<T extends Record<string, any> = any> = {
+export declare type TableEntry<T extends Record<string, any> = Record<string, any>> = {
     [K in keyof T]: {
         v: T[K];
         e: any;
         c: string | null;
         f: boolean;
     };
-};
+} & Classes;
 
 export declare interface TableOptions<T extends Record<string, any> = Record<string, any>> extends VisitOptions {
     /**
@@ -188,107 +184,21 @@ export declare interface TableOptions<T extends Record<string, any> = Record<str
 
 export declare interface TableRecord<T extends Record<string, any> = Record<string, any>> {
     operations: Executable<InlineOperation>[];
+    classes: string | null;
     default: (options?: VisitOptions) => void;
     select: () => void;
     deselect: () => void;
     toggle: () => void;
     selected: boolean;
-    bind: () => any;
-    entry: (column: Column<T> | string) => TableEntry<T>[keyof T] | null;
-    value: (column: Column<T> | string) => TableEntry<T>[keyof T]["v"] | null;
-    extra: (column: Column<T> | string) => TableEntry<T>[keyof T]["e"] | null;
+    bind: () => RecordBinding<Identifier>;
+    entry: (column: HonedColumn<T> | string) => TableEntry<T>[keyof T] | null;
+    value: (column: HonedColumn<T> | string) => TableEntry<T>[keyof T]["v"] | null;
+    extra: (column: HonedColumn<T> | string) => TableEntry<T>[keyof T]["e"] | null;
 }
 
 export declare type UseTable = typeof useTable;
 
-export declare function useTable<T extends Record<string, Table>, K extends Record<string, any> = Record<string, any>, U extends Paginate = "length-aware">(props: T, key: keyof T, defaults?: TableOptions): {
-    filters: HonedFilter[];
-    sorts: HonedSort[];
-    searches: HonedSearch[];
-    currentFilters: HonedFilter[];
-    currentSort: HonedSort | undefined;
-    currentSearches: HonedSearch[];
-    isSortable: boolean;
-    isSearchable: boolean;
-    isMatchable: boolean;
-    isFiltering: (name?: string | Filter | undefined) => boolean;
-    isSorting: (name?: string | Sort | undefined) => boolean;
-    isSearching: (name?: string | Search | undefined) => boolean;
-    getFilter: (filter: string | Filter) => Filter | undefined;
-    getSort: (sort: string | Sort, dir?: Direction | undefined) => Sort | undefined;
-    getSearch: (search: string | Search) => Search | undefined;
-    apply: (values: Record<string, FilterValue>, options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    applyFilter: (filter: string | Filter, value: any, options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    applySort: (sort: string | Sort, direction?: Direction | undefined, options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    applySearch: (value: string | null | undefined, options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    applyMatch: (search: string | Search, options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    clearFilter: (filter?: string | Filter | undefined, options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    clearSort: (options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    clearSearch: (options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    clearMatch: (options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    reset: (options?: Partial<Visit & VisitCallbacks> | undefined) => void;
-    bindFilter: (filter: string | Filter, options?: BindingOptions | undefined) => void | FilterBinding;
-    bindSort: (sort: string | Sort, options?: BindingOptions | undefined) => void | SortBinding;
-    bindSearch: (options?: BindingOptions | undefined) => void | SearchBinding;
-    bindMatch: (match: string | Search, options?: BindingOptions | undefined) => void | MatchBinding;
-    stringValue: (value: any) => any;
-    omitValue: (value: any) => any;
-    toggleValue: (value: any, values: any) => any;
-    delimitArray: (value: any) => string;
-    meta: Record<string, any>;
-    isEmpty: boolean;
-    isPageable: boolean;
-    isToggleable: boolean;
-    getRecordKey: (record: TableEntry<K>) => Identifier;
-    headings: Heading<K>[];
-    columns: Column<K>[];
-    records: TableRecord<K>[];
-    inline: boolean;
-    bulk: Executable<BulkOperation>[];
-    page: Executable<PageOperation>[];
-    pages: PageOption[];
-    currentPage: PageOption | undefined;
-    paginator: PaginateMap[U] & {
-        links?: {
-            navigate: (options?: VisitOptions) => void | "" | null;
-            url: string | null;
-            label: string;
-            active: boolean;
-        }[] | undefined;
-        next: (options?: VisitOptions) => void;
-        previous: (options?: VisitOptions) => void;
-        first: (options?: VisitOptions) => void;
-        last: (options?: VisitOptions) => void;
-    };
-    executeInline: (operation: InlineOperation, data: TableEntry<K>, options?: VisitOptions) => void;
-    executeBulk: (operation: BulkOperation, options?: VisitOptions) => void;
-    executePage: (operation: PageOperation, data?: PageOperationData, options?: VisitOptions) => boolean;
-    applyPage: (page: PageOption, options?: VisitOptions) => void;
-    selection: BulkSelection<Identifier>;
-    select: (record: TableEntry<K>) => void;
-    deselect: (record: TableEntry<K>) => void;
-    selectPage: () => void;
-    deselectPage: () => void;
-    toggle: (record: TableEntry<K>) => void;
-    selected: (record: TableEntry<K>) => boolean;
-    selectAll: () => void;
-    deselectAll: () => void;
-    isPageSelected: boolean;
-    hasSelected: boolean;
-    bindCheckbox: (record: TableEntry<K>) => {
-        "onUpdate:modelValue": (checked: boolean | "indeterminate") => void;
-        modelValue: boolean;
-        value: Identifier;
-    };
-    bindPage: () => {
-        "onUpdate:modelValue": (checked: boolean | "indeterminate") => void;
-        modelValue: boolean;
-    };
-    bindAll: () => {
-        "onUpdate:modelValue": (checked: boolean | "indeterminate") => void;
-        modelValue: boolean;
-    };
-};
+export declare function useTable<T extends Record<string, Table>, K extends Record<string, any> = Record<string, any>, U extends Paginate = "length-aware">(props: T, key: keyof T, defaults?: TableOptions): HonedTable<K, U>;
 
 export declare interface View {
     id: number;