@knime/kds-table 0.1.0

package/dist/src/components/control/actionbar/FilterControl.vue.d.ts

@@ -0,0 +1,168 @@
+import { nextTick } from 'vue';
+import { FilterConfig } from '../../../types/FilterConfig';
+type __VLS_Props = {
+    filterConfigs?: Array<FilterConfig | undefined>;
+    columnHeaders: string[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    openPopover: (columnIndex?: number) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    columnFilter: (colInd: number, value: string | number | string[] | [null] | null | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onColumnFilter?: ((colInd: number, value: string | number | string[] | [null] | null | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    filterPopoverRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: ({
+            readonly modelValue?: boolean | undefined;
+            readonly role?: import('@knime/kds-components').KdsPopoverRole | undefined;
+            readonly popoverType?: import('@knime/kds-components').KdsPopoverType | undefined;
+            readonly fullWidth?: boolean | undefined;
+            readonly maxInlineSize?: string | undefined;
+            readonly content?: string | undefined;
+            readonly placement?: Exclude<import('@knime/kds-components').KdsPopoverPlacement, "custom"> | undefined;
+            readonly customPlacementPosition?: never | undefined;
+            readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined | undefined;
+        } | {
+            readonly modelValue?: boolean | undefined;
+            readonly role?: import('@knime/kds-components').KdsPopoverRole | undefined;
+            readonly popoverType?: import('@knime/kds-components').KdsPopoverType | undefined;
+            readonly fullWidth?: boolean | undefined;
+            readonly maxInlineSize?: string | undefined;
+            readonly content?: string | undefined;
+            readonly placement: "custom";
+            readonly customPlacementPosition: {
+                x: number;
+                y: number;
+            };
+            readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined | undefined;
+        }) & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            popoverEl: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "update:modelValue", value: boolean) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<({
+            modelValue?: boolean;
+        } & {
+            role?: import('@knime/kds-components').KdsPopoverRole;
+            popoverType?: import('@knime/kds-components').KdsPopoverType;
+            fullWidth?: boolean;
+            maxInlineSize?: string;
+            content?: string;
+        } & {
+            placement?: Exclude<import('@knime/kds-components').KdsPopoverPlacement, "custom">;
+            customPlacementPosition?: never;
+        }) | ({
+            modelValue?: boolean;
+        } & {
+            role?: import('@knime/kds-components').KdsPopoverRole;
+            popoverType?: import('@knime/kds-components').KdsPopoverType;
+            fullWidth?: boolean;
+            maxInlineSize?: string;
+            content?: string;
+        } & {
+            placement: "custom";
+            customPlacementPosition: {
+                x: number;
+                y: number;
+            };
+        })> & Readonly<{
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        }>, {
+            anchorStyle: Record<string, string>;
+            popoverId: string;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (value: boolean) => any;
+        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<{} & (Readonly<({
+        modelValue?: boolean;
+    } & {
+        role?: import('@knime/kds-components').KdsPopoverRole;
+        popoverType?: import('@knime/kds-components').KdsPopoverType;
+        fullWidth?: boolean;
+        maxInlineSize?: string;
+        content?: string;
+    } & {
+        placement?: Exclude<import('@knime/kds-components').KdsPopoverPlacement, "custom">;
+        customPlacementPosition?: never;
+    }) | ({
+        modelValue?: boolean;
+    } & {
+        role?: import('@knime/kds-components').KdsPopoverRole;
+        popoverType?: import('@knime/kds-components').KdsPopoverType;
+        fullWidth?: boolean;
+        maxInlineSize?: string;
+        content?: string;
+    } & {
+        placement: "custom";
+        customPlacementPosition: {
+            x: number;
+            y: number;
+        };
+    })> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>), "anchorStyle" | "popoverId"> & {
+        anchorStyle: Record<string, string>;
+        popoverId: string;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | null;
+    filterBodyRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        filterConfigs?: Array<FilterConfig | undefined>;
+        columnHeaders: string[];
+    }> & Readonly<{
+        onColumnFilter?: ((colInd: number, value: string | number | string[] | [null] | null | undefined) => any) | undefined;
+    }>, {
+        addAndFocusColumn: (columnIndex: number) => Promise<void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        columnFilter: (colInd: number, value: string | number | string[] | [null] | null | undefined) => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        filterConfigs?: Array<FilterConfig | undefined>;
+        columnHeaders: string[];
+    }> & Readonly<{
+        onColumnFilter?: ((colInd: number, value: string | number | string[] | [null] | null | undefined) => any) | undefined;
+    }>, {
+        addAndFocusColumn: (columnIndex: number) => Promise<void>;
+    }, {}, {}, {}, {}> | null;
+}, any>;
+export default _default;
+//# sourceMappingURL=FilterControl.vue.d.ts.map

package/dist/src/components/control/actionbar/FilterControl.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterControl.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/actionbar/FilterControl.vue"],"names":[],"mappings":"AAAA,OAgGO,EAAY,QAAQ,EAAkB,MAAM,KAAK,CAAC;AAIzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAOhE,KAAK,WAAW,GAAG;IACjB,aAAa,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;IAChD,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;;gCAuBuC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAsM0zd,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAjB/9d,wBASG"}

package/dist/src/components/control/actionbar/FilterControlBody.vue.d.ts

@@ -0,0 +1,14 @@
+import { FilterConfig } from '../../../types/FilterConfig';
+type __VLS_Props = {
+    filterConfigs?: Array<FilterConfig | undefined>;
+    columnHeaders: string[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    addAndFocusColumn: (columnIndex: number) => Promise<void>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    columnFilter: (colInd: number, value: string | number | string[] | [null] | null | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onColumnFilter?: ((colInd: number, value: string | number | string[] | [null] | null | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;
+//# sourceMappingURL=FilterControlBody.vue.d.ts.map

package/dist/src/components/control/actionbar/FilterControlBody.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterControlBody.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/actionbar/FilterControlBody.vue"],"names":[],"mappings":"AA0RA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAShE,KAAK,WAAW,GAAG;IACjB,aAAa,CAAC,EAAE,KAAK,CAAC,YAAY,GAAG,SAAS,CAAC,CAAC;IAChD,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;;qCA2I4C,MAAM;;;;;;AAkTpD,wBAQG"}

package/dist/src/components/control/actionbar/PopoverContainer.vue.d.ts

@@ -0,0 +1,19 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        header?(_: {}): any;
+        body?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=PopoverContainer.vue.d.ts.map

package/dist/src/components/control/actionbar/PopoverContainer.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PopoverContainer.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/actionbar/PopoverContainer.vue"],"names":[],"mappings":"AAqCA,iBAAS,cAAc;WAsCT,OAAO,IAA6B;;wBAXtB,GAAG;sBACL,GAAG;;;;EAe5B;AAOD,KAAK,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAC9D,QAAA,MAAM,eAAe,0RAMnB,CAAC;wBACkB,uBAAuB,CAAC,OAAO,eAAe,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;AAAnG,wBAAoG;AAEpG,KAAK,uBAAuB,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IACxC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KAEV,CAAA;CACD,CAAC"}

package/dist/src/components/control/actionbar/SortControl.vue.d.ts

@@ -0,0 +1,146 @@
+import { KdsDropdownOption } from '@knime/kds-components';
+import { SortConfig } from '../../../types/TableConfig';
+export type SortControlOptions = {
+    selectableColumns: KdsDropdownOption[];
+    selectableDirections: Record<string, KdsDropdownOption[]>;
+};
+type __VLS_Props = {
+    sortConfig?: SortConfig;
+    sortControlOptions: SortControlOptions;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    columnSort: (colInd: number | undefined, direction: 0 | 1 | -1) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onColumnSort?: ((colInd: number | undefined, direction: 0 | 1 | -1) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    sortPopoverRef: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: ({
+            readonly modelValue?: boolean | undefined;
+            readonly role?: import('@knime/kds-components').KdsPopoverRole | undefined;
+            readonly popoverType?: import('@knime/kds-components').KdsPopoverType | undefined;
+            readonly fullWidth?: boolean | undefined;
+            readonly maxInlineSize?: string | undefined;
+            readonly content?: string | undefined;
+            readonly placement?: Exclude<import('@knime/kds-components').KdsPopoverPlacement, "custom"> | undefined;
+            readonly customPlacementPosition?: never | undefined;
+            readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined | undefined;
+        } | {
+            readonly modelValue?: boolean | undefined;
+            readonly role?: import('@knime/kds-components').KdsPopoverRole | undefined;
+            readonly popoverType?: import('@knime/kds-components').KdsPopoverType | undefined;
+            readonly fullWidth?: boolean | undefined;
+            readonly maxInlineSize?: string | undefined;
+            readonly content?: string | undefined;
+            readonly placement: "custom";
+            readonly customPlacementPosition: {
+                x: number;
+                y: number;
+            };
+            readonly "onUpdate:modelValue"?: ((value: boolean) => any) | undefined | undefined;
+        }) & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            popoverEl: HTMLDivElement;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: (event: "update:modelValue", value: boolean) => void;
+        $el: HTMLDivElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<({
+            modelValue?: boolean;
+        } & {
+            role?: import('@knime/kds-components').KdsPopoverRole;
+            popoverType?: import('@knime/kds-components').KdsPopoverType;
+            fullWidth?: boolean;
+            maxInlineSize?: string;
+            content?: string;
+        } & {
+            placement?: Exclude<import('@knime/kds-components').KdsPopoverPlacement, "custom">;
+            customPlacementPosition?: never;
+        }) | ({
+            modelValue?: boolean;
+        } & {
+            role?: import('@knime/kds-components').KdsPopoverRole;
+            popoverType?: import('@knime/kds-components').KdsPopoverType;
+            fullWidth?: boolean;
+            maxInlineSize?: string;
+            content?: string;
+        } & {
+            placement: "custom";
+            customPlacementPosition: {
+                x: number;
+                y: number;
+            };
+        })> & Readonly<{
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        }>, {
+            anchorStyle: Record<string, string>;
+            popoverId: string;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:modelValue": (value: boolean) => any;
+        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<{} & (Readonly<({
+        modelValue?: boolean;
+    } & {
+        role?: import('@knime/kds-components').KdsPopoverRole;
+        popoverType?: import('@knime/kds-components').KdsPopoverType;
+        fullWidth?: boolean;
+        maxInlineSize?: string;
+        content?: string;
+    } & {
+        placement?: Exclude<import('@knime/kds-components').KdsPopoverPlacement, "custom">;
+        customPlacementPosition?: never;
+    }) | ({
+        modelValue?: boolean;
+    } & {
+        role?: import('@knime/kds-components').KdsPopoverRole;
+        popoverType?: import('@knime/kds-components').KdsPopoverType;
+        fullWidth?: boolean;
+        maxInlineSize?: string;
+        content?: string;
+    } & {
+        placement: "custom";
+        customPlacementPosition: {
+            x: number;
+            y: number;
+        };
+    })> & Readonly<{
+        "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>), "anchorStyle" | "popoverId"> & {
+        anchorStyle: Record<string, string>;
+        popoverId: string;
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) | null;
+}, any>;
+export default _default;
+//# sourceMappingURL=SortControl.vue.d.ts.map

package/dist/src/components/control/actionbar/SortControl.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SortControl.vue.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/actionbar/SortControl.vue"],"names":[],"mappings":"AAyKA,OAAO,EAEL,KAAK,iBAAiB,EAIvB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK7D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iBAAiB,EAAE,iBAAiB,EAAE,CAAC;IACvC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAAC;CAC3D,CAAC;AAIF,KAAK,WAAW,GAAG;IACjB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,kBAAkB,EAAE,kBAAkB,CAAC;CACxC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAoS06T,GAAG,8CAA8C,GAAG,yBAAyB,GAAG,6DAAmC,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAhBliU,wBAQG"}

package/dist/src/components/control/actionbar/filterConfigActive.d.ts

@@ -0,0 +1,6 @@
+import { FilterConfig } from '../../../types/FilterConfig';
+export declare const defaultValueFor: (is: FilterConfig["is"]) => FilterConfig["modelValue"];
+export declare const missingValueFor: (is: FilterConfig["is"]) => FilterConfig["modelValue"];
+export declare const isMissingMode: (config: FilterConfig) => boolean;
+export declare const isActive: (config: FilterConfig | undefined) => config is FilterConfig;
+//# sourceMappingURL=filterConfigActive.d.ts.map

package/dist/src/components/control/actionbar/filterConfigActive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterConfigActive.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/actionbar/filterConfigActive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,eAAO,MAAM,eAAe,GAC1B,IAAI,YAAY,CAAC,IAAI,CAAC,KACrB,YAAY,CAAC,YAAY,CAK3B,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,IAAI,YAAY,CAAC,IAAI,CAAC,KACrB,YAAY,CAAC,YAAY,CAK3B,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,QAAQ,YAAY,KAAG,OASpD,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,QAAQ,YAAY,GAAG,SAAS,KAC/B,MAAM,IAAI,YAWZ,CAAC"}

package/dist/src/components/control/actionbar/useButtonPopoverInteraction.d.ts

@@ -0,0 +1,11 @@
+import { Ref } from 'vue';
+export declare const useButtonPopoverInteraction: ({ keepButtonActive, }: {
+    keepButtonActive: Ref<boolean>;
+}) => {
+    onButtonClick: (isActive: boolean) => void;
+    onPopoverToggle: (isOpen: boolean) => void;
+    buttonIsActive: Ref<boolean, boolean>;
+    showPopover: Ref<boolean, boolean>;
+    openPopover: () => void;
+};
+//# sourceMappingURL=useButtonPopoverInteraction.d.ts.map

package/dist/src/components/control/actionbar/useButtonPopoverInteraction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useButtonPopoverInteraction.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/actionbar/useButtonPopoverInteraction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAc,MAAM,KAAK,CAAC;AAE3C,eAAO,MAAM,2BAA2B,GAAI,uBAEzC;IACD,gBAAgB,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;CAChC;8BAQkC,OAAO;8BAKP,OAAO;;;;CAiBzC,CAAC"}

package/dist/src/components/control/composables/useIdGeneration.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export declare const useIdGeneration: (ids: Ref<string[]>, selectedIndex: Ref<null | number>, nodeTitle: string) => {
+    generateOptionId: (itemId?: string) => string;
+    activeDescendantId: import('vue').ComputedRef<string>;
+    buttonId: string;
+};
+//# sourceMappingURL=useIdGeneration.d.ts.map

package/dist/src/components/control/composables/useIdGeneration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIdGeneration.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/composables/useIdGeneration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAY,MAAM,KAAK,CAAC;AAGzC,eAAO,MAAM,eAAe,GAC1B,KAAK,GAAG,CAAC,MAAM,EAAE,CAAC,EAClB,eAAe,GAAG,CAAC,IAAI,GAAG,MAAM,CAAC,EACjC,WAAW,MAAM;gCAWkB,MAAM;;;CAU1C,CAAC"}

package/dist/src/components/control/composables/useScrollToElement.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+export declare const useScrollToElement: ({ toggleButton, }: {
+    toggleButton: Ref<HTMLElement | null>;
+}) => {
+    scrollTo: (element: HTMLElement) => void;
+};
+//# sourceMappingURL=useScrollToElement.d.ts.map

package/dist/src/components/control/composables/useScrollToElement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScrollToElement.d.ts","sourceRoot":"","sources":["../../../../../src/components/control/composables/useScrollToElement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAe/B,eAAO,MAAM,kBAAkB,GAAI,mBAEhC;IACD,YAAY,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;CACvC;wBA0C4B,WAAW;CAMvC,CAAC"}

package/dist/src/components/layout/Cell.vue.d.ts

@@ -0,0 +1,227 @@
+import { Slot } from 'vue';
+import { CellProps } from './CellProps';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<Record<string, Slot>> & Record<string, Slot>;
+    refs: {
+        cellRenderer: ({
+            $: import('vue').ComponentInternalInstance;
+            $data: {};
+            $props: {
+                readonly isMissing: boolean;
+                readonly isSlotted: boolean;
+                readonly isSelected: boolean;
+                readonly isInCellSelection: boolean;
+                readonly isToBeExpanded: boolean;
+                readonly noPaddingTopBottom?: boolean | undefined;
+                readonly noPaddingLeftRight?: boolean | undefined;
+                readonly text: string | undefined;
+                readonly title: string | null;
+                readonly color: string | null;
+                readonly classes: (string | null)[];
+                readonly selectOnMove: boolean;
+                readonly size: number;
+                readonly defaultTopBottomPadding: number;
+                readonly defaultLeftRightPadding: number;
+                readonly enableExpand?: boolean | undefined;
+                readonly isEditing?: boolean | undefined;
+                readonly inlineBlock?: boolean | undefined;
+                readonly onInput?: ((...args: any[]) => any) | undefined;
+                readonly onSelect?: ((...args: any[]) => any) | undefined;
+                readonly onClick?: ((...args: any[]) => any) | undefined;
+                readonly onExpand?: ((...args: any[]) => any) | undefined;
+            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+            $attrs: import('vue').Attrs;
+            $refs: {
+                [x: string]: unknown;
+            } & {
+                dataCell: HTMLTableCellElement;
+            };
+            $slots: Readonly<{
+                [name: string]: Slot<any> | undefined;
+            }>;
+            $root: import('vue').ComponentPublicInstance | null;
+            $parent: import('vue').ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "input", ...args: any[]) => void) & ((event: "select", ...args: any[]) => void) & ((event: "click", ...args: any[]) => void) & ((event: "expand", ...args: any[]) => void);
+            $el: HTMLTableCellElement;
+            $options: import('vue').ComponentOptionsBase<Readonly<import('./CellRendererProps').CellRendererProps> & Readonly<{
+                onInput?: ((...args: any[]) => any) | undefined;
+                onSelect?: ((...args: any[]) => any) | undefined;
+                onClick?: ((...args: any[]) => any) | undefined;
+                onExpand?: ((...args: any[]) => any) | undefined;
+            }>, {
+                getCellContentDimensions: () => {
+                    width: number;
+                    height: number;
+                };
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                input: (...args: any[]) => void;
+                select: (...args: any[]) => void;
+                click: (...args: any[]) => void;
+                expand: (...args: any[]) => void;
+            }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+                beforeCreate?: (() => void) | (() => void)[];
+                created?: (() => void) | (() => void)[];
+                beforeMount?: (() => void) | (() => void)[];
+                mounted?: (() => void) | (() => void)[];
+                beforeUpdate?: (() => void) | (() => void)[];
+                updated?: (() => void) | (() => void)[];
+                activated?: (() => void) | (() => void)[];
+                deactivated?: (() => void) | (() => void)[];
+                beforeDestroy?: (() => void) | (() => void)[];
+                beforeUnmount?: (() => void) | (() => void)[];
+                destroyed?: (() => void) | (() => void)[];
+                unmounted?: (() => void) | (() => void)[];
+                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import('vue').nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+        } & Readonly<{}> & Omit<Readonly<import('./CellRendererProps').CellRendererProps> & Readonly<{
+            onInput?: ((...args: any[]) => any) | undefined;
+            onSelect?: ((...args: any[]) => any) | undefined;
+            onClick?: ((...args: any[]) => any) | undefined;
+            onExpand?: ((...args: any[]) => any) | undefined;
+        }>, "getCellContentDimensions"> & {
+            getCellContentDimensions: () => {
+                width: number;
+                height: number;
+            };
+        } & {} & import('vue').ComponentCustomProperties & {} & {
+            $slots: {
+                'editable-cell'?(_: {
+                    cellElement: HTMLTableCellElement;
+                }): any;
+                default?(_: {
+                    width: number;
+                }): any;
+            };
+        }) | null;
+    };
+    rootEl: HTMLTableCellElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<CellProps, {
+    getCellContentDimensions: () => {
+        width: number;
+        height: number;
+    } | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    input: (...args: any[]) => void;
+    select: (...args: any[]) => void;
+    click: (...args: any[]) => void;
+    dataValueView: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<CellProps> & Readonly<{
+    onInput?: ((...args: any[]) => any) | undefined;
+    onSelect?: ((...args: any[]) => any) | undefined;
+    onClick?: ((...args: any[]) => any) | undefined;
+    onDataValueView?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    cellRenderer: ({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            readonly isMissing: boolean;
+            readonly isSlotted: boolean;
+            readonly isSelected: boolean;
+            readonly isInCellSelection: boolean;
+            readonly isToBeExpanded: boolean;
+            readonly noPaddingTopBottom?: boolean | undefined;
+            readonly noPaddingLeftRight?: boolean | undefined;
+            readonly text: string | undefined;
+            readonly title: string | null;
+            readonly color: string | null;
+            readonly classes: (string | null)[];
+            readonly selectOnMove: boolean;
+            readonly size: number;
+            readonly defaultTopBottomPadding: number;
+            readonly defaultLeftRightPadding: number;
+            readonly enableExpand?: boolean | undefined;
+            readonly isEditing?: boolean | undefined;
+            readonly inlineBlock?: boolean | undefined;
+            readonly onInput?: ((...args: any[]) => any) | undefined;
+            readonly onSelect?: ((...args: any[]) => any) | undefined;
+            readonly onClick?: ((...args: any[]) => any) | undefined;
+            readonly onExpand?: ((...args: any[]) => any) | undefined;
+        } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $attrs: import('vue').Attrs;
+        $refs: {
+            [x: string]: unknown;
+        } & {
+            dataCell: HTMLTableCellElement;
+        };
+        $slots: Readonly<{
+            [name: string]: Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance | null;
+        $parent: import('vue').ComponentPublicInstance | null;
+        $host: Element | null;
+        $emit: ((event: "input", ...args: any[]) => void) & ((event: "select", ...args: any[]) => void) & ((event: "click", ...args: any[]) => void) & ((event: "expand", ...args: any[]) => void);
+        $el: HTMLTableCellElement;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('./CellRendererProps').CellRendererProps> & Readonly<{
+            onInput?: ((...args: any[]) => any) | undefined;
+            onSelect?: ((...args: any[]) => any) | undefined;
+            onClick?: ((...args: any[]) => any) | undefined;
+            onExpand?: ((...args: any[]) => any) | undefined;
+        }>, {
+            getCellContentDimensions: () => {
+                width: number;
+                height: number;
+            };
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            input: (...args: any[]) => void;
+            select: (...args: any[]) => void;
+            click: (...args: any[]) => void;
+            expand: (...args: any[]) => void;
+        }, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import('vue').nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
+    } & Readonly<{}> & Omit<Readonly<import('./CellRendererProps').CellRendererProps> & Readonly<{
+        onInput?: ((...args: any[]) => any) | undefined;
+        onSelect?: ((...args: any[]) => any) | undefined;
+        onClick?: ((...args: any[]) => any) | undefined;
+        onExpand?: ((...args: any[]) => any) | undefined;
+    }>, "getCellContentDimensions"> & {
+        getCellContentDimensions: () => {
+            width: number;
+            height: number;
+        };
+    } & {} & import('vue').ComponentCustomProperties & {} & {
+        $slots: {
+            'editable-cell'?(_: {
+                cellElement: HTMLTableCellElement;
+            }): any;
+            default?(_: {
+                width: number;
+            }): any;
+        };
+    }) | null;
+}, HTMLTableCellElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Cell.vue.d.ts.map