@ironsource/shared-ui 2.0.0-rc.3 → 2.0.0-rc.5

package/components/table/TableHeaderSorter.vue.js

@@ -1,29 +1,7 @@
-import { defineComponent, openBlock, createElementBlock, createVNode, normalizeClass } from 'vue';
-import SortOrderIcon from './SortOrderIcon.vue.js';
-/* empty css                                                                   */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-
-import "../../TableHeaderSorter.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = { class: "table-head-sorter-container" };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "TableHeaderSorter",
-  props: {
-    sortOrder: null
-  },
-  setup(__props) {
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", _hoisted_1, [
-        createVNode(SortOrderIcon, {
-          name: "sort-order",
-          class: normalizeClass({ "table-head-sorter-selected": __props.sortOrder === "asc" })
-        }, null, 8, ["class"]),
-        createVNode(SortOrderIcon, {
-          name: "sort-order",
-          class: normalizeClass(["table-head-sorter-desc", { "table-head-sorter-selected": __props.sortOrder === "desc" }])
-        }, null, 8, ["class"])
-      ]);
-    };
-  }
-});
-var TableHeaderSorter = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-02476f76"]]);
-
-export { TableHeaderSorter as default };
+import e from "./TableHeaderSorter.vue2.js";
+/* empty css                        */import o from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../TableHeaderSorter.vue_vue_type_style_index_0_scoped_350aa9f0_lang.css"; //*');
+const t = /* @__PURE__ */ o(e, [["__scopeId", "data-v-350aa9f0"]]);
+export {
+  t as default
+};

package/components/table/TableHeaderSorter.vue2.js

@@ -0,0 +1,23 @@
+ import "../../TableHeaderSorter.vue_vue_type_style_index_0_scoped_350aa9f0_lang.css"; import { defineComponent as o, openBlock as a, createElementBlock as l, createVNode as r, normalizeClass as t } from "vue";
+import s from "./SortOrderIcon.vue.js";
+const c = { class: "table-head-sorter-container" }, u = /* @__PURE__ */ o({
+  __name: "TableHeaderSorter",
+  props: {
+    sortOrder: null
+  },
+  setup(e) {
+    return (d, n) => (a(), l("div", c, [
+      r(s, {
+        name: "sort-order",
+        class: t({ "table-head-sorter-selected": e.sortOrder === "asc" })
+      }, null, 8, ["class"]),
+      r(s, {
+        name: "sort-order",
+        class: t(["table-head-sorter-desc", { "table-head-sorter-selected": e.sortOrder === "desc" }])
+      }, null, 8, ["class"])
+    ]));
+  }
+});
+export {
+  u as default
+};

package/components/table/codeTemplate.d.ts

@@ -8,4 +8,4 @@ export declare const codeTemplate: (args: {
     showTitle?: boolean;
     showTooltip?: boolean;
     rows: string;
-}) => any;
+}) => string;

package/components/table/index.d.ts

@@ -1,4 +1,312 @@
-declare const TableTypes: () => (import("vue").InjectionKey<import("./TableContext").TableContextProps> | import("vue").DefineComponent<{
+declare const TableTypes: () => (import("vue").InjectionKey<import("./TableContext").TableContextProps> | ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            testId: string;
+            isLoading: boolean;
+            sections: import("./Table.types").Section[];
+            isSticky: boolean;
+            isStickyHeader: boolean;
+            emptyStateTitle: string;
+            emptyStateSubtitle: string;
+            isInfiniteScroll: boolean;
+            infiniteScrollThreshold: number;
+            rowHeight: number | ((index: number) => number);
+            loadingRowCount: number;
+            defaultScrollPosition: number;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            sort: {
+                type: import("vue").PropType<import("./Table.types").Sort>;
+                required: true;
+            };
+            title: {
+                type: import("vue").PropType<string>;
+                required: true;
+            };
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            columns: {
+                type: import("vue").PropType<import("./Table.types").Column[]>;
+                required: true;
+            };
+            rows: {
+                type: import("vue").PropType<unknown[][]>;
+                required: true;
+            };
+            sections: {
+                type: import("vue").PropType<import("./Table.types").Section[]>;
+                default: any;
+            };
+            isSticky: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            isStickyHeader: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            emptyStateTitle: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            emptyStateSubtitle: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            isInfiniteScroll: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            infiniteScrollThreshold: {
+                type: import("vue").PropType<number>;
+                default: number;
+            };
+            rowHeight: {
+                type: import("vue").PropType<number | ((index: number) => number)>;
+                default: number;
+            };
+            loadingRowCount: {
+                type: import("vue").PropType<number>;
+                default: number;
+            };
+            defaultScrollPosition: {
+                type: import("vue").PropType<number>;
+                default: any;
+            };
+        }>> & {
+            onOnScroll?: (event: Event) => any;
+            "onUpdate:sort"?: (newSort: import("./Table.types").Sort) => any;
+            onSaveRow?: (args_0: {
+                value: unknown;
+                confirm: () => void;
+                rowIndex: number;
+                cellIndex: number;
+            }) => any;
+            onLoadMore?: () => any;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "testId" | "isLoading" | "sections" | "isSticky" | "isStickyHeader" | "emptyStateTitle" | "emptyStateSubtitle" | "isInfiniteScroll" | "infiniteScrollThreshold" | "rowHeight" | "loadingRowCount" | "defaultScrollPosition">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot;
+        }>;
+        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: ((event: "onScroll", event: Event) => void) & ((event: "update:sort", newSort: import("./Table.types").Sort) => void) & ((event: "saveRow", args_0: {
+            value: unknown;
+            confirm: () => void;
+            rowIndex: number;
+            cellIndex: number;
+        }) => void) & ((event: "loadMore") => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            sort: {
+                type: import("vue").PropType<import("./Table.types").Sort>;
+                required: true;
+            };
+            title: {
+                type: import("vue").PropType<string>;
+                required: true;
+            };
+            testId: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            columns: {
+                type: import("vue").PropType<import("./Table.types").Column[]>;
+                required: true;
+            };
+            rows: {
+                type: import("vue").PropType<unknown[][]>;
+                required: true;
+            };
+            sections: {
+                type: import("vue").PropType<import("./Table.types").Section[]>;
+                default: any;
+            };
+            isSticky: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            isStickyHeader: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            emptyStateTitle: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            emptyStateSubtitle: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            isInfiniteScroll: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            infiniteScrollThreshold: {
+                type: import("vue").PropType<number>;
+                default: number;
+            };
+            rowHeight: {
+                type: import("vue").PropType<number | ((index: number) => number)>;
+                default: number;
+            };
+            loadingRowCount: {
+                type: import("vue").PropType<number>;
+                default: number;
+            };
+            defaultScrollPosition: {
+                type: import("vue").PropType<number>;
+                default: any;
+            };
+        }>> & {
+            onOnScroll?: (event: Event) => any;
+            "onUpdate:sort"?: (newSort: import("./Table.types").Sort) => any;
+            onSaveRow?: (args_0: {
+                value: unknown;
+                confirm: () => void;
+                rowIndex: number;
+                cellIndex: number;
+            }) => any;
+            onLoadMore?: () => any;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:sort": (newSort: import("./Table.types").Sort) => void;
+            onScroll: (event: Event) => void;
+            saveRow: (args_0: {
+                value: unknown;
+                confirm: () => void;
+                rowIndex: number;
+                cellIndex: number;
+            }) => void;
+            loadMore: () => void;
+        }, string, {
+            testId: string;
+            isLoading: boolean;
+            sections: import("./Table.types").Section[];
+            isSticky: boolean;
+            isStickyHeader: boolean;
+            emptyStateTitle: string;
+            emptyStateSubtitle: string;
+            isInfiniteScroll: boolean;
+            infiniteScrollThreshold: number;
+            rowHeight: number | ((index: number) => number);
+            loadingRowCount: number;
+            defaultScrollPosition: number;
+        }, {}, string> & {
+            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<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, 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_0: R, args_1: R) => any : (...args: any) => any, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        sort: {
+            type: import("vue").PropType<import("./Table.types").Sort>;
+            required: true;
+        };
+        title: {
+            type: import("vue").PropType<string>;
+            required: true;
+        };
+        testId: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        isLoading: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        columns: {
+            type: import("vue").PropType<import("./Table.types").Column[]>;
+            required: true;
+        };
+        rows: {
+            type: import("vue").PropType<unknown[][]>;
+            required: true;
+        };
+        sections: {
+            type: import("vue").PropType<import("./Table.types").Section[]>;
+            default: any;
+        };
+        isSticky: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        isStickyHeader: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        emptyStateTitle: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        emptyStateSubtitle: {
+            type: import("vue").PropType<string>;
+            default: string;
+        };
+        isInfiniteScroll: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        infiniteScrollThreshold: {
+            type: import("vue").PropType<number>;
+            default: number;
+        };
+        rowHeight: {
+            type: import("vue").PropType<number | ((index: number) => number)>;
+            default: number;
+        };
+        loadingRowCount: {
+            type: import("vue").PropType<number>;
+            default: number;
+        };
+        defaultScrollPosition: {
+            type: import("vue").PropType<number>;
+            default: any;
+        };
+    }>> & {
+        onOnScroll?: (event: Event) => any;
+        "onUpdate:sort"?: (newSort: import("./Table.types").Sort) => any;
+        onSaveRow?: (args_0: {
+            value: unknown;
+            confirm: () => void;
+            rowIndex: number;
+            cellIndex: number;
+        }) => any;
+        onLoadMore?: () => any;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
     sort: {
         type: import("vue").PropType<import("./Table.types").Sort>;
         required: true;
@@ -9,162 +317,60 @@ declare const TableTypes: () => (import("vue").InjectionKey<import("./TableConte
     };
     testId: {
         type: import("vue").PropType<string>;
-    } & {
         default: string;
     };
-    columns: {
-        type: import("vue").PropType<import("./Table.types").Column[]>;
-        required: true;
-    };
     isLoading: {
         type: import("vue").PropType<boolean>;
-    } & {
         default: boolean;
     };
-    isSticky: {
-        type: import("vue").PropType<boolean>;
-    } & {
-        default: boolean;
-    };
-    isStickyHeader: {
-        type: import("vue").PropType<boolean>;
-    } & {
-        default: boolean;
-    };
-    sections: {
-        type: import("vue").PropType<import("./Table.types").Section[]>;
-    } & {
-        default: any;
-    };
-    emptyStateTitle: {
-        type: import("vue").PropType<string>;
-    } & {
-        default: string;
-    };
-    emptyStateSubtitle: {
-        type: import("vue").PropType<string>;
-    } & {
-        default: string;
-    };
-    isInfiniteScroll: {
-        type: import("vue").PropType<boolean>;
-    } & {
-        default: boolean;
-    };
-    infiniteScrollThreshold: {
-        type: import("vue").PropType<number>;
-    } & {
-        default: number;
-    };
-    rowHeight: {
-        type: import("vue").PropType<number | ((index: number) => number)>;
-    } & {
-        default: number;
-    };
-    loadingRowCount: {
-        type: import("vue").PropType<number>;
-    } & {
-        default: number;
-    };
-    defaultScrollPosition: {
-        type: import("vue").PropType<number>;
-    } & {
-        default: any;
+    columns: {
+        type: import("vue").PropType<import("./Table.types").Column[]>;
+        required: true;
     };
     rows: {
         type: import("vue").PropType<unknown[][]>;
         required: true;
     };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:sort": (newSort: import("./Table.types").Sort) => void;
-} & {
-    onScroll: (event: Event) => void;
-} & {
-    saveRow: (payload_0: {
-        value: unknown;
-        confirm: () => void;
-        rowIndex: number;
-        cellIndex: number;
-    }) => void;
-} & {
-    loadMore: () => void;
-}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
-    sort: {
-        type: import("vue").PropType<import("./Table.types").Sort>;
-        required: true;
-    };
-    title: {
-        type: import("vue").PropType<string>;
-        required: true;
-    };
-    testId: {
-        type: import("vue").PropType<string>;
-    } & {
-        default: string;
-    };
-    columns: {
-        type: import("vue").PropType<import("./Table.types").Column[]>;
-        required: true;
-    };
-    isLoading: {
-        type: import("vue").PropType<boolean>;
-    } & {
-        default: boolean;
+    sections: {
+        type: import("vue").PropType<import("./Table.types").Section[]>;
+        default: any;
     };
     isSticky: {
         type: import("vue").PropType<boolean>;
-    } & {
         default: boolean;
     };
     isStickyHeader: {
         type: import("vue").PropType<boolean>;
-    } & {
         default: boolean;
     };
-    sections: {
-        type: import("vue").PropType<import("./Table.types").Section[]>;
-    } & {
-        default: any;
-    };
     emptyStateTitle: {
         type: import("vue").PropType<string>;
-    } & {
         default: string;
     };
     emptyStateSubtitle: {
         type: import("vue").PropType<string>;
-    } & {
         default: string;
     };
     isInfiniteScroll: {
         type: import("vue").PropType<boolean>;
-    } & {
         default: boolean;
     };
     infiniteScrollThreshold: {
         type: import("vue").PropType<number>;
-    } & {
         default: number;
     };
     rowHeight: {
         type: import("vue").PropType<number | ((index: number) => number)>;
-    } & {
         default: number;
     };
     loadingRowCount: {
         type: import("vue").PropType<number>;
-    } & {
         default: number;
     };
     defaultScrollPosition: {
         type: import("vue").PropType<number>;
-    } & {
         default: any;
     };
-    rows: {
-        type: import("vue").PropType<unknown[][]>;
-        required: true;
-    };
 }>> & {
     onOnScroll?: (event: Event) => any;
     "onUpdate:sort"?: (newSort: import("./Table.types").Sort) => any;
@@ -175,12 +381,22 @@ declare const TableTypes: () => (import("vue").InjectionKey<import("./TableConte
         cellIndex: number;
     }) => any;
     onLoadMore?: () => any;
-}, {
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:sort": (newSort: import("./Table.types").Sort) => void;
+    onScroll: (event: Event) => void;
+    saveRow: (args_0: {
+        value: unknown;
+        confirm: () => void;
+        rowIndex: number;
+        cellIndex: number;
+    }) => void;
+    loadMore: () => void;
+}, string, {
     testId: string;
     isLoading: boolean;
+    sections: import("./Table.types").Section[];
     isSticky: boolean;
     isStickyHeader: boolean;
-    sections: import("./Table.types").Section[];
     emptyStateTitle: string;
     emptyStateSubtitle: string;
     isInfiniteScroll: boolean;
@@ -188,7 +404,26 @@ declare const TableTypes: () => (import("vue").InjectionKey<import("./TableConte
     rowHeight: number | ((index: number) => number);
     loadingRowCount: number;
     defaultScrollPosition: number;
-}>)[];
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: Partial<Record<`section-${string}`, (_: {}) => any>> & Partial<Record<`header-${string}`, (_: {
+        column: import("./Table.types").Column;
+    }) => any>> & Partial<Record<`cell-${string}`, (_: {
+        cell: unknown;
+        isLoading: boolean;
+        cellIndex: number;
+        row: import("@vueuse/core").UseVirtualListItem<unknown[]>;
+        rowIndex: number;
+    }) => any>> & {
+        title?(_: {}): any;
+        search?(_: {}): any;
+        "table-header-actions"?(_: {}): any;
+        "floating-actions"?(_: {
+            row: import("@vueuse/core").UseVirtualListItem<unknown[]>;
+        }): any;
+        loader?(_: {}): any;
+        "empty-state"?(_: {}): any;
+    };
+})))[];
 export { default as Table } from './Table.vue';
 export { TableContext } from './TableContext';
 export type { Column, Sort } from './Table.types';

package/components/table/index.js

@@ -0,0 +1,8 @@
+import o from "./Table.vue.js";
+import { TableContext as e } from "./TableContext.js";
+const m = () => [o, e];
+export {
+  o as Table,
+  e as TableContext,
+  m as TableTypes
+};

package/components/table-cells/Editable.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     cell?: string;
     isEditing?: boolean;
     validateFunction?: (value: unknown) => string | boolean;
@@ -24,9 +24,12 @@ declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_T
     validateFunction: () => false;
 }>>>, {
     cell: string;
-    isLoading: boolean;
     isEditing: boolean;
     validateFunction: (value: unknown) => string | boolean;
+    isLoading: boolean;
+}>, {
+    input?(_: {}): any;
+    content?(_: {}): any;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
@@ -39,7 +42,15 @@ type __VLS_TypePropsToRuntimeProps<T> = {
     };
 };
 type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
         default: D[K];
-    } : P[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
 };