@adyen/bento-vue2 0.0.8 → 0.0.9

package/dist/@types/components/button/button.vue.d.ts

@@ -31,6 +31,7 @@ declare const _default: import("vue").DefineComponent<{
         [x: string]: boolean;
     }>;
     onClickButton: () => void;
+    hasSlot: (name: string) => boolean;
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("blur" | "click" | "focus" | "keydown.esc")[], string, Readonly<import("vue").ExtractPropTypes<{
     disabled: {
         type: BooleanConstructor;

package/dist/@types/components/data-grid/components/data-grid-columns.vue.d.ts

@@ -0,0 +1,74 @@
+import { PropType } from 'vue';
+import { BentoColumn, BentoDatagridAllItemsSelectedState, BentoDatagridSortByColumn, BentoDatagridSortDirection } from '../data-grid.types';
+import { BentoTypographyElement } from '@/components/typography';
+declare const _default: import("vue").DefineComponent<{
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    hasResizableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allItemsSelectedState: {
+        type: PropType<BentoDatagridAllItemsSelectedState>;
+        default: any;
+    };
+    sortBy: {
+        type: PropType<BentoDatagridSortByColumn[]>;
+        default: () => any[];
+    };
+    gridColumnWidthStyle: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}, {
+    DATAGRID_SELECT_FIELD_NAME: string;
+    conditionalColumnClasses: (column: BentoColumn) => {
+        'b-data-grid-columns__column--sortable': boolean;
+        'b-data-grid-columns__column--padding-left-unset': boolean;
+        'b-data-grid-columns__column--padding-right-unset': boolean;
+        'b-data-grid-columns__column--numeric': boolean;
+    };
+    conditionalColumnSeperatorClasses: import("vue").ComputedRef<{
+        'b-data-grid-columns__column-seperator-container--is-resizeable': boolean;
+    }>;
+    allItemsSelectedCheckboxState: import("vue").Ref<{
+        allItemsSelected: boolean;
+        isIndeterminate: boolean;
+    }>;
+    onAllRowSelect: (areAllItemsSelected: boolean) => void;
+    conditionalSortDirectionClasses: (field: string, direction: BentoDatagridSortDirection) => {
+        'b-data-grid-columns__column-sort-icon--sorted': boolean;
+    };
+    sortByColumnField: (field: string) => void;
+    startResize: (hasResizableColumns: boolean, field: string, event: MouseEvent) => void;
+    BentoDatagridSortDirection: typeof BentoDatagridSortDirection;
+    BentoTypographyElement: typeof BentoTypographyElement;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("sort" | "column-resize" | "select-all-rows")[], string, Readonly<import("vue").ExtractPropTypes<{
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    hasResizableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allItemsSelectedState: {
+        type: PropType<BentoDatagridAllItemsSelectedState>;
+        default: any;
+    };
+    sortBy: {
+        type: PropType<BentoDatagridSortByColumn[]>;
+        default: () => any[];
+    };
+    gridColumnWidthStyle: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>>, {
+    hasResizableColumns: boolean;
+    allItemsSelectedState: BentoDatagridAllItemsSelectedState;
+    sortBy: BentoDatagridSortByColumn[];
+}>;
+export default _default;

package/dist/@types/components/data-grid/components/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoDataGridColumns } from './data-grid-columns.vue';

package/dist/@types/components/data-grid/composables/index.d.ts

@@ -0,0 +1,4 @@
+export { default as useResizer } from './useResizer';
+export { default as useCalculateColumnWidth, DATAGRID_SELECT_FIELD_NAME, } from './useCalculateColumnWidth/useCalculateColumnWidth';
+export { useSorter } from './useSorter';
+export { useSelector } from './useSelector';

package/dist/@types/components/data-grid/composables/useCalculateColumnWidth/useCalculateColumnWidth.d.ts

@@ -1,10 +1,29 @@
-import { MaybeRef } from '../../../../types';
-import { BentoColumn } from '../../data-grid.types';
+import { BentoColumn, BentoColumnWidthOverridesLookup } from '../../data-grid.types';
 import { CalculateColumnWidthOptions } from './useCalculateColumnWidth.types';
+import { MaybeRef } from '../../../../types';
 export declare const DEFAULT_COLUMN_WIDTH = 100;
 export declare const DEFAULT_COLUMN_MIN_WIDTH = 50;
 export declare const DATAGRID_SELECT_FIELD_NAME = "b-select";
-export declare const useCalculateColumnWidth: (newColumns: MaybeRef<BentoColumn[]>, newGridWidth: MaybeRef<number>, options?: CalculateColumnWidthOptions) => {
-    caclulatedWidths: import("vue").ComputedRef<BentoColumn[]>;
+export declare const useCalculateColumnWidth: (newColumns: MaybeRef<BentoColumn[]>, bodyRef: MaybeRef<HTMLDivElement | undefined>, options?: CalculateColumnWidthOptions) => {
+    columnDefs: import("vue").ComputedRef<{
+        width: number;
+        field: string;
+        label: string;
+        minWidth?: number;
+        flex?: number;
+        sortable?: boolean;
+        numeric?: boolean;
+        padding?: {
+            left?: boolean;
+            right?: boolean;
+        };
+        overflow?: import("../../data-grid.types").BentoColumnOverflow;
+    }[]>;
+    gridColumnWidthStyle: import("vue").ComputedRef<{
+        gridTemplateColumns: string;
+        gridColumnEnd: number;
+        width: string;
+    }>;
+    onColumnWidthOverride: (newColumnWidthOverridesLookup: BentoColumnWidthOverridesLookup) => void;
 };
 export default useCalculateColumnWidth;

package/dist/@types/components/data-grid/composables/useResizer.d.ts

@@ -1,17 +1,8 @@
 import { Ref } from 'vue';
-import { BentoColumn } from '../data-grid.types';
+import { BentoColumn, BentoColumnWidthOverridesLookup } from '../data-grid.types';
 export declare const useResizer: (columns: Ref<BentoColumn[]>, emit: (event: string, ...args: unknown[]) => void) => {
-    resizeData: {
-        resizingColumnField: string;
-        offsetLeft: number;
-        stepPositionX: number;
-        resizedColumnsWidths: {
-            [k: string]: {
-                width: number;
-                minWidth: number;
-            };
-        };
-    };
+    resizeData: Ref<BentoColumnWidthOverridesLookup>;
     allColumnRefs: import("vue").ToRefs<{}>;
     startResize: (hasResizableColumns: boolean, field: BentoColumn['field'], event: MouseEvent) => void;
 };
+export default useResizer;

package/dist/@types/components/data-grid/composables/useSelector.d.ts

@@ -1,7 +1,7 @@
 import { Ref } from 'vue';
 import { BentoDatagridData, BentoDatagridDataItemId, BentoDatagridGetDataItemIdFn, BentoDatagridIsDataItemDisabledFn } from '../data-grid.types';
 export declare const useSelector: (selection: Ref<BentoDatagridDataItemId[]>, emit: (event: string, emitedSelectedItems: BentoDatagridDataItemId[]) => void, data: Ref<BentoDatagridData>, getDataItemId: BentoDatagridGetDataItemIdFn, isDataItemDisabled: BentoDatagridIsDataItemDisabledFn) => {
-    onAllRowSelect: () => void;
+    onAllRowSelect: (allItemsSelected: boolean) => void;
     onRowSelect: () => void;
     allItemsSelectedState: {
         allItemsSelected: boolean;

package/dist/@types/components/data-grid/composables/useSorter.d.ts

@@ -2,7 +2,7 @@ import { Ref } from 'vue';
 import { BentoColumn, BentoDatagridSortByColumn, BentoDatagridSortDirection } from '../data-grid.types';
 export declare const useSorter: (sortBy: Ref<BentoDatagridSortByColumn[]>, columns: Ref<BentoColumn[]>, emit: (event: string, updatedSortBy: BentoDatagridSortByColumn[]) => void) => {
     conditionalSortDirectionClasses: (field: string, direction: BentoDatagridSortDirection) => {
-        'b-data-grid__column-sort-icon--sorted': boolean;
+        'b-data-grid-columns__column-sort-icon--sorted': boolean;
     };
     sortByColumnField: (field: string) => void;
 };

package/dist/@types/components/data-grid/data-grid.types.d.ts

@@ -37,3 +37,13 @@ export type BentoDatagridDataItemId = string | number;
 export type BentoDatagridGetDataItemIdFn = (item: BentoDatagridDataItem) => BentoDatagridDataItemId;
 export type BentoDatagridIsDataItemDisabledFn = (item: BentoDatagridDataItem) => boolean;
 export type BentoDatagridPaginationProps = InstanceType<typeof BentoPagination>['$props'];
+export interface BentoColumnWidthOverridesLookup {
+    [field: string]: {
+        width: BentoColumn['width'];
+        minWidth: BentoColumn['minWidth'];
+    };
+}
+export interface BentoDatagridAllItemsSelectedState {
+    allItemsSelected: boolean;
+    isIndeterminate: boolean;
+}

package/dist/@types/components/data-grid/data-grid.vue.d.ts

@@ -116,7 +116,8 @@ declare const _default: import("vue").DefineComponent<{
         default: () => any[];
     };
 }, {
-    processedColumns: import("vue").ComputedRef<{
+    body: import("vue").Ref<HTMLDivElement>;
+    columnDefs: import("vue").ComputedRef<{
         width: number;
         field: string;
         label: string;
@@ -140,12 +141,6 @@ declare const _default: import("vue").DefineComponent<{
     conditionalGridClasses: import("vue").ComputedRef<{
         [x: string]: boolean;
     }>;
-    conditionalColumnClasses: (column: BentoColumn) => {
-        'b-data-grid__column--sortable': boolean;
-        'b-data-grid__column--padding-left-unset': boolean;
-        'b-data-grid__column--padding-right-unset': boolean;
-        'b-data-grid__column--numeric': boolean;
-    };
     conditionalRowClasses: (row: BentoDatagridDataItem) => {
         'b-data-grid__row--disabled': boolean;
     };
@@ -156,43 +151,29 @@ declare const _default: import("vue").DefineComponent<{
         'b-data-grid__cell--numeric': boolean;
         'b-data-grid__cell--condensed': boolean;
     };
-    conditionalColumnSeperatorClasses: import("vue").ComputedRef<{
-        'b-data-grid__column-seperator-container--is-resizeable': boolean;
-    }>;
     conditionalPaginationClasses: import("vue").ComputedRef<{
         'b-data-grid__pagination--padding-left-unset': boolean;
         'b-data-grid__pagination--padding-right-unset': boolean;
     }>;
-    resizeData: {
-        resizingColumnField: string;
-        offsetLeft: number;
-        stepPositionX: number;
-        resizedColumnsWidths: {
-            [k: string]: {
-                width: number;
-                minWidth: number;
-            };
-        };
-    };
-    startResize: (hasResizableColumns: boolean, field: string, event: MouseEvent) => void;
-    conditionalSortDirectionClasses: (field: string, direction: BentoDatagridSortDirection) => {
-        'b-data-grid__column-sort-icon--sorted': boolean;
-    };
-    sortByColumnField: (field: string) => void;
+    onColumnWidthOverride: (newColumnWidthOverridesLookup: import("./data-grid.types").BentoColumnWidthOverridesLookup) => void;
+    onColumnResized: (resizeEvent: {
+        field: string;
+        width: number;
+    }) => void;
+    onSort: (updatedSortBy: BentoDatagridSortByColumn[]) => void;
     allItemsSelectedState: {
         allItemsSelected: boolean;
         isIndeterminate: boolean;
     };
     selectedItems: import("vue").Ref<BentoDatagridDataItemId[]>;
-    onAllRowSelect: () => void;
+    onAllRowSelect: (allItemsSelected: boolean) => void;
     onRowSelect: () => void;
     DATAGRID_SELECT_FIELD_NAME: string;
     BentoDatagridSortDirection: typeof BentoDatagridSortDirection;
     BentoTypographyElement: typeof BentoTypographyElement;
     BentoTypographyVariant: typeof BentoTypographyVariant;
-    paginationNavigate: (page: number) => void;
+    onPaginationNavigate: (page: number) => void;
     onItemsPerPageChange: (itemsPerPage: number) => void;
-    body: any;
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("sort" | "navigate" | "select" | "items-page" | "column-resize" | "update:filters")[], string, Readonly<import("vue").ExtractPropTypes<{
     condensed: {
         type: BooleanConstructor;
@@ -312,12 +293,12 @@ declare const _default: import("vue").DefineComponent<{
     loading: boolean;
     condensed: boolean;
     filters: import("../filter-bar").BentoFilterBarModel;
-    getDataItemId: BentoDatagridGetDataItemIdFn;
     hasResizableColumns: boolean;
+    sortBy: BentoDatagridSortByColumn[];
+    getDataItemId: BentoDatagridGetDataItemIdFn;
     isDataItemDisabled: BentoDatagridIsDataItemDisabledFn;
     pagination: any;
     selectable: boolean;
     selection: BentoDatagridDataItemId[];
-    sortBy: BentoDatagridSortByColumn[];
 }>;
 export default _default;

package/dist/@types/utils/ts/debounce/debounce.d.ts

@@ -0,0 +1,2 @@
+import { AnyFn } from '../../../types';
+export declare const debounce: <T>(callback: AnyFn<T>, debounceTime: number) => (...args: T[]) => void;

package/dist/@types/utils/ts/debounce/index.d.ts

@@ -0,0 +1 @@
+export * from './debounce';

package/dist/@types/utils/ts/hasSlot.d.ts

@@ -0,0 +1,2 @@
+import type { Slots } from 'vue/types/v3-setup-context';
+export declare const hasSlot: (slots: Slots) => (name: string) => boolean;

package/dist/@types/utils/ts/i18n.d.ts

@@ -1,5 +1,10 @@
 import type { WritableComputedRef } from 'vue';
 import VueI18n from 'vue-i18n';
+export declare const defaultI18nOptions: {
+    locale: string;
+    fallbackLocale: string;
+    fallbackRoot: boolean;
+};
 export declare function createI18n(options?: VueI18n.I18nOptions): VueI18n;
 export interface Composer {
     locale: WritableComputedRef<string>;