@ironsource/shared-ui 2.1.12-test.99 → 2.2.0-rc.0

package/components/table/v4/index.js

@@ -0,0 +1,23 @@
+import r from "./DataGrid.vue.js";
+import t from "./DataGridMenu.vue.js";
+import o from "./DataGridRowsCounter.vue.js";
+import a from "./DataGridHeader.vue.js";
+import i from "./DataGridContainer.vue.js";
+import m from "./MultipleDataGrid.vue.js";
+const n = () => [
+  r,
+  t,
+  o,
+  m,
+  a,
+  i
+];
+export {
+  r as DataGrid,
+  i as DataGridContainer,
+  a as DataGridHeader,
+  t as DataGridMenu,
+  o as DataGridRowsCounter,
+  n as DataGridTypes,
+  m 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.vue.js

@@ -0,0 +1,7 @@
+import e from "./Editable.vue2.js";
+/* empty css               */import o from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../Editable.vue_vue_type_style_index_0_scoped_2561e913_lang.css"; //*');
+const p = /* @__PURE__ */ o(e, [["__scopeId", "data-v-2561e913"]]);
+export {
+  p as default
+};

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

@@ -0,0 +1,43 @@
+ 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__ */ u({
+  __name: "Editable",
+  props: {
+    cell: { default: "" },
+    isEditing: { type: Boolean, default: !1 },
+    validateFunction: { type: Function, default: () => !1 },
+    isLoading: { type: Boolean, default: !1 },
+    rowIndex: null,
+    cellIndex: null
+  },
+  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: l[0] || (l[0] = //@ts-ignore
+      (...f) => e(o) && e(o)(...f))
+    }, [
+      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(k(t.cell), 1)
+              ]),
+              _: 1
+            })
+          ], !0)
+        ]))
+      ])
+    ], 512));
+  }
+});
+export {
+  N as default
+};

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.vue.js

@@ -0,0 +1,7 @@
+import e from "./EditableV4.vue2.js";
+/* empty css                 */import o from "../../../_virtual/_plugin-vue_export-helper.js";
+// import "../../../EditableV4.vue_vue_type_style_index_0_scoped_1bbe222a_lang.css"; //*');
+const a = /* @__PURE__ */ o(e, [["__scopeId", "data-v-1bbe222a"]]);
+export {
+  a as default
+};

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

@@ -0,0 +1,57 @@
+ 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 x from "../../input/v4/TextField.vue.js";
+import B from "../../icon/v4/IconV4.vue.js";
+import "../../icon/v4/IconFlag.vue.js";
+const C = { class: "editable-wrapper" }, E = {
+  key: 1,
+  class: "editable-content"
+}, S = /* @__PURE__ */ f({
+  __name: "EditableV4",
+  props: {
+    cell: { default: "" },
+    isLoading: { type: Boolean, default: !1 },
+    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: (e) => e }
+  },
+  setup(e) {
+    const s = e, { onEdit: n, target: c, isEditing: u } = v(s);
+    return (l, a) => (o(), i("div", {
+      ref_key: "target",
+      ref: c,
+      class: "editable",
+      onClick: a[0] || (a[0] = //@ts-ignore
+      (...p) => t(n) && t(n)(...p))
+    }, [
+      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(e.displayValue(e.cell)), 1)
+              ]),
+              _: 1
+            }),
+            e.type === "dropdown" ? (o(), b(t(B), {
+              key: 0,
+              class: "caret-icon",
+              name: "caret-down",
+              size: "20px"
+            })) : g("", !0)
+          ], !0)
+        ]))
+      ])
+    ], 512));
+  }
+});
+export {
+  S as default
+};