@ironsource/shared-ui 2.1.12-test.50 → 2.1.12-test.53

package/components/table/v4/index.js

@@ -1,17 +1,20 @@
 import r from "./DataGrid.vue.js";
 import t from "./DataGridMenu.vue.js";
 import o from "./DataGridRowsCounter.vue.js";
-import a from "./MultipleDataGrid.vue.js";
-const e = () => [
+import a from "./DataGridHeader.vue.js";
+import i from "./MultipleDataGrid.vue.js";
+const G = () => [
   r,
   t,
   o,
+  i,
   a
 ];
 export {
   r as DataGrid,
+  a as DataGridHeader,
   t as DataGridMenu,
   o as DataGridRowsCounter,
-  e as DataGridTypes,
-  a as MultipleDataGrid
+  G as DataGridTypes,
+  i as MultipleDataGrid
 };

package/components/table/v4/storyUtils.d.ts

@@ -13,3 +13,28 @@ export declare const exampleObjectRows: {
 }[];
 export declare const exampleNumbersRows: string[][];
 export declare const exampleNumbersRowsExtra: string[][];
+export declare const exampleData: {
+    first: string;
+    last: string;
+    address: string;
+    state: string;
+    zip: string;
+    phone: string;
+}[];
+export declare const BASIC_COLUMNS: {
+    id: string;
+    title: string;
+    isSortable: boolean;
+}[];
+export declare const EXTRA_COLUMNS: {
+    id: string;
+    title: string;
+}[];
+export declare const columnOptions: {
+    id: string;
+    title: string;
+    options: {
+        id: string;
+        title: string;
+    }[];
+}[];

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

@@ -1,5 +1,5 @@
 export declare const editableCommon: (props: any) => {
     onEdit: () => void;
-    target: import("vue").Ref<any, any>;
-    isEditing: import("vue").Ref<boolean, boolean>;
+    target: any;
+    isEditing: import("vue").Ref<boolean>;
 };

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

@@ -1,4 +1,4 @@
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__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;
@@ -10,7 +10,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     isLoading: boolean;
     isEditing: boolean;
     validateFunction: () => false;
-}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     cell?: string;
     isEditing?: boolean;
     validateFunction?: (value: unknown) => string | boolean;
@@ -22,12 +22,12 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     isLoading: boolean;
     isEditing: boolean;
     validateFunction: () => false;
-}>>> & Readonly<{}>, {
+}>>>, {
     cell: string;
     isEditing: boolean;
     validateFunction: (value: unknown) => string | boolean;
     isLoading: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+}>, {
     input?(_: {}): any;
     content?(_: {}): any;
 }>;

package/components/table-cells/v3/Editable.vue2.js

@@ -1,34 +1,34 @@
- import "../../../Editable.vue_vue_type_style_index_0_scoped_2561e913_lang.css"; import { defineComponent as p, openBlock as i, createElementBlock as l, unref as t, createElementVNode as u, renderSlot as a, createVNode as m, withCtx as y, createTextVNode as _, toDisplayString as g } from "vue";
-import k from "../../typography/Text.vue.js";
-import { editableCommon as E } from "../common/Editable.common.js";
-const v = { class: "editable-container" }, b = {
+ import "../../../Editable.vue_vue_type_style_index_0_scoped_2561e913_lang.css"; import { defineComponent as u, openBlock as i, createElementBlock as a, unref as e, createElementVNode as m, renderSlot as s, createVNode as p, withCtx as y, createTextVNode as g, toDisplayString as k } from "vue";
+import E from "../../typography/Text.vue.js";
+import { editableCommon as _ } from "../common/Editable.common.js";
+const v = { class: "editable-container" }, x = {
   key: 1,
   class: "editable-content"
-}, N = /* @__PURE__ */ p({
+}, N = /* @__PURE__ */ u({
   __name: "Editable",
   props: {
     cell: { default: "" },
     isEditing: { type: Boolean, default: !1 },
     validateFunction: { type: Function, default: () => !1 },
     isLoading: { type: Boolean, default: !1 },
-    rowIndex: {},
-    cellIndex: {}
+    rowIndex: null,
+    cellIndex: null
   },
-  setup(s) {
-    const r = s, { onEdit: o, target: d, isEditing: c } = E(r);
-    return (e, n) => (i(), l("div", {
+  setup(t) {
+    const r = t, { onEdit: o, target: d, isEditing: c } = _(r);
+    return (n, l) => (i(), a("div", {
       ref_key: "target",
       ref: d,
       class: "container",
-      onClick: n[0] || (n[0] = //@ts-ignore
-      (...f) => t(o) && t(o)(...f))
+      onClick: l[0] || (l[0] = //@ts-ignore
+      (...f) => e(o) && e(o)(...f))
     }, [
-      u("div", v, [
-        t(c) ? a(e.$slots, "input", { key: 0 }, void 0, !0) : (i(), l("div", b, [
-          a(e.$slots, "content", {}, () => [
-            m(k, { size: "sm" }, {
+      m("div", v, [
+        e(c) ? s(n.$slots, "input", { key: 0 }, void 0, !0) : (i(), a("div", x, [
+          s(n.$slots, "content", {}, () => [
+            p(E, { size: "sm" }, {
               default: y(() => [
-                _(g(e.cell), 1)
+                g(k(t.cell), 1)
               ]),
               _: 1
             })

package/components/table-cells/v3/index.d.ts

@@ -1,42 +1,102 @@
 declare const EditableTypes: () => (import("vue").InjectionKey<import("../common/EditableContext").EditableContextProps> | ({
-    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
-        cell: {
-            type: import("vue").PropType<string>;
-            default: string;
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            cell: string;
+            isEditing: boolean;
+            validateFunction: (value: unknown) => string | boolean;
+            isLoading: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            cell: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            isEditing: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            validateFunction: {
+                type: import("vue").PropType<(value: unknown) => string | boolean>;
+                default: () => false;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            rowIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+            cellIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "cell" | "isEditing" | "validateFunction" | "isLoading">;
+        $attrs: {
+            [x: string]: unknown;
         };
-        isEditing: {
-            type: import("vue").PropType<boolean>;
-            default: boolean;
+        $refs: {
+            [x: string]: unknown;
         };
-        validateFunction: {
-            type: import("vue").PropType<(value: unknown) => string | boolean>;
-            default: () => false;
-        };
-        isLoading: {
-            type: import("vue").PropType<boolean>;
-            default: boolean;
-        };
-        rowIndex: {
-            type: import("vue").PropType<number>;
-            required: true;
-        };
-        cellIndex: {
-            type: import("vue").PropType<number>;
-            required: true;
+        $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: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            cell: {
+                type: import("vue").PropType<string>;
+                default: string;
+            };
+            isEditing: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            validateFunction: {
+                type: import("vue").PropType<(value: unknown) => string | boolean>;
+                default: () => false;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            rowIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+            cellIndex: {
+                type: import("vue").PropType<number>;
+                required: true;
+            };
+        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            cell: string;
+            isEditing: boolean;
+            validateFunction: (value: unknown) => string | boolean;
+            isLoading: boolean;
+        }, {}, 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)[];
         };
-    }>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
-        cell: string;
-        isEditing: boolean;
-        validateFunction: (value: unknown) => string | boolean;
-        isLoading: boolean;
-    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<import("vue").ExtractPropTypes<{
+        $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<{
         cell: {
             type: import("vue").PropType<string>;
             default: string;
@@ -61,12 +121,7 @@ declare const EditableTypes: () => (import("vue").InjectionKey<import("../common
             type: import("vue").PropType<number>;
             required: true;
         };
-    }>> & Readonly<{}>, {}, {}, {}, {}, {
-        cell: string;
-        isEditing: boolean;
-        validateFunction: (value: unknown) => string | boolean;
-        isLoading: boolean;
-    }>;
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties & {};
     __isFragment?: never;
     __isTeleport?: never;
     __isSuspense?: never;
@@ -95,12 +150,12 @@ declare const EditableTypes: () => (import("vue").InjectionKey<import("../common
         type: import("vue").PropType<number>;
         required: true;
     };
-}>> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
     cell: string;
     isEditing: boolean;
     validateFunction: (value: unknown) => string | boolean;
     isLoading: boolean;
-}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
     $slots: {
         input?(_: {}): any;
         content?(_: {}): any;

package/components/table-cells/v4/EditableV4.vue.d.ts

@@ -1,4 +1,4 @@
-declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     cell?: string;
     isLoading?: boolean;
     rowIndex: number;
@@ -16,7 +16,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     withIcons: boolean;
     validateFunction: () => false;
     displayValue: (cell: unknown) => unknown;
-}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     cell?: string;
     isLoading?: boolean;
     rowIndex: number;
@@ -34,15 +34,15 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<im
     withIcons: boolean;
     validateFunction: () => false;
     displayValue: (cell: unknown) => unknown;
-}>>> & Readonly<{}>, {
+}>>>, {
     type: "input" | "dropdown";
+    cell: string;
     withIcons: boolean;
     saveOnClickOutside: boolean;
-    cell: string;
     validateFunction: (value: unknown) => string | boolean;
     isLoading: boolean;
     displayValue: (option: unknown) => unknown;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+}>, {
     input?(_: {}): any;
     content?(_: {}): any;
 }>;

package/components/table-cells/v4/EditableV4.vue2.js

@@ -1,46 +1,46 @@
- import "../../../EditableV4.vue_vue_type_style_index_0_scoped_1bbe222a_lang.css"; import { defineComponent as f, openBlock as a, createElementBlock as r, unref as e, createElementVNode as m, renderSlot as i, createVNode as d, withCtx as y, createTextVNode as k, toDisplayString as V, createBlock as b, createCommentVNode as g } from "vue";
+ import "../../../EditableV4.vue_vue_type_style_index_0_scoped_1bbe222a_lang.css"; import { defineComponent as f, openBlock as o, createElementBlock as i, unref as t, createElementVNode as m, renderSlot as r, createVNode as d, withCtx as y, createTextVNode as k, toDisplayString as V, createBlock as b, createCommentVNode as g } from "vue";
 import { editableCommon as v } from "../common/Editable.common.js";
 import w from "../../typography/v4/Typography.vue.js";
-import B from "../../input/v4/TextField.vue.js";
-import C from "../../icon/v4/IconV4.vue.js";
+import x from "../../input/v4/TextField.vue.js";
+import B from "../../icon/v4/IconV4.vue.js";
 import "../../icon/v4/IconFlag.vue.js";
-const E = { class: "editable-wrapper" }, _ = {
+const C = { class: "editable-wrapper" }, E = {
   key: 1,
   class: "editable-content"
-}, O = /* @__PURE__ */ f({
+}, S = /* @__PURE__ */ f({
   __name: "EditableV4",
   props: {
     cell: { default: "" },
     isLoading: { type: Boolean, default: !1 },
-    rowIndex: {},
-    cellIndex: {},
+    rowIndex: null,
+    cellIndex: null,
     type: { default: "input" },
     withIcons: { type: Boolean, default: !0 },
     saveOnClickOutside: { type: Boolean, default: !0 },
     validateFunction: { type: Function, default: () => !1 },
-    displayValue: { type: Function, default: (o) => o }
+    displayValue: { type: Function, default: (e) => e }
   },
-  setup(o) {
-    const s = o, { onEdit: n, target: p, isEditing: c } = v(s);
-    return (t, l) => (a(), r("div", {
+  setup(e) {
+    const s = e, { onEdit: n, target: c, isEditing: u } = v(s);
+    return (l, a) => (o(), i("div", {
       ref_key: "target",
-      ref: p,
+      ref: c,
       class: "editable",
-      onClick: l[0] || (l[0] = //@ts-ignore
-      (...u) => e(n) && e(n)(...u))
+      onClick: a[0] || (a[0] = //@ts-ignore
+      (...p) => t(n) && t(n)(...p))
     }, [
-      m("div", E, [
-        e(c) ? i(t.$slots, "input", { key: 0 }, () => [
-          d(e(B))
-        ], !0) : (a(), r("div", _, [
-          i(t.$slots, "content", {}, () => [
-            d(e(w), { variant: "body1" }, {
+      m("div", C, [
+        t(u) ? r(l.$slots, "input", { key: 0 }, () => [
+          d(t(x))
+        ], !0) : (o(), i("div", E, [
+          r(l.$slots, "content", {}, () => [
+            d(t(w), { variant: "body1" }, {
               default: y(() => [
-                k(V(t.displayValue(t.cell)), 1)
+                k(V(e.displayValue(e.cell)), 1)
               ]),
               _: 1
             }),
-            t.type === "dropdown" ? (a(), b(e(C), {
+            e.type === "dropdown" ? (o(), b(t(B), {
               key: 0,
               class: "caret-icon",
               name: "caret-down",
@@ -53,5 +53,5 @@ const E = { class: "editable-wrapper" }, _ = {
   }
 });
 export {
-  O as default
+  S as default
 };