@ironsource/shared-ui 2.2.0-rc.23 → 2.2.0-rc.25

package/components/emptyState/v4/EmptyStateV4.vue2.js

@@ -1 +1,86 @@
- import "../../../EmptyStateV4.vue_vue_type_style_index_0_scoped_76757f22_lang.css"; 
+ import "../../../EmptyStateV4.vue_vue_type_style_index_0_scoped_76757f22_lang.css"; import I from "../../../_virtual/dynamic-import-helper.js";
+import { defineComponent as T, computed as N, defineAsyncComponent as b, openBlock as o, createElementBlock as k, mergeProps as s, unref as e, createBlock as n, createCommentVNode as a, createElementVNode as C, renderSlot as p, withCtx as m, createTextVNode as l, toDisplayString as u } from "vue";
+import E from "../../button/v4/ButtonV4.vue.js";
+import "../../button/v4/IconButtonV4.vue.js";
+import "../../button/v4/ButtonGroup.vue.js";
+import "../../button/v4/ToggleButtonGroupAB.vue.js";
+import y from "../../typography/v4/Typography.vue.js";
+import { capitalizeFirstLetter as S, snakeCaseToCamelCase as g } from "../../../utils/string.js";
+import x from "../../icon/v4/IconV4.vue.js";
+import "../../icon/v4/IconFlag.vue.js";
+import { useTestIdAttrs as z } from "../../../utils/testIds.js";
+import { EmptyStateTestIdModifiers as r } from "../../../testids/index.js";
+const A = { class: "title-wrapper" }, P = /* @__PURE__ */ T({
+  __name: "EmptyStateV4",
+  props: {
+    title: { default: "No data to display" },
+    subtitle: { default: void 0 },
+    variant: { default: "no-data" },
+    buttonText: { default: void 0 },
+    iconName: { default: null },
+    iconType: { default: "regular" },
+    iconSize: { default: "48px" },
+    testId: { default: "" }
+  },
+  emits: ["click"],
+  setup(t) {
+    const d = t, v = N(() => {
+      const i = S(g(d.variant));
+      return b(() => I(/* @__PURE__ */ Object.assign({ "./icons/IconError.vue": () => import("./icons/IconError.vue.js"), "./icons/IconFiles.vue": () => import("./icons/IconFiles.vue.js"), "./icons/IconNoAccess.vue": () => import("./icons/IconNoAccess.vue.js"), "./icons/IconNoData.vue": () => import("./icons/IconNoData.vue.js"), "./icons/IconNoResults.vue": () => import("./icons/IconNoResults.vue.js"), "./icons/IconSettings.vue": () => import("./icons/IconSettings.vue.js") }), `./icons/Icon${i}.vue`));
+    }), c = z(d.testId, r);
+    return (i, f) => (o(), k("div", s({ class: "empty-state" }, e(c)[e(r).CONTAINER]), [
+      t.variant && !t.iconName ? (o(), n(e(v), {
+        key: 0,
+        class: "empty-variant-icon"
+      })) : a("", !0),
+      t.iconName ? (o(), n(e(x), {
+        key: 1,
+        class: "custom-empty-icon",
+        name: t.iconName,
+        size: t.iconSize,
+        type: t.iconType
+      }, null, 8, ["name", "size", "type"])) : a("", !0),
+      C("div", A, [
+        p(i.$slots, "content", {}, () => [
+          t.title ? (o(), n(e(y), s({
+            key: 0,
+            variant: "h4",
+            class: "title"
+          }, e(c)[e(r).TITLE]), {
+            default: m(() => [
+              l(u(t.title), 1)
+            ]),
+            _: 1
+          }, 16)) : a("", !0),
+          t.subtitle ? (o(), n(e(y), s({
+            key: 1,
+            variant: "body1",
+            class: "subtitle"
+          }, e(c)[e(r).SUBTITLE]), {
+            default: m(() => [
+              l(u(t.subtitle), 1)
+            ]),
+            _: 1
+          }, 16)) : a("", !0)
+        ], !0)
+      ]),
+      p(i.$slots, "button", {}, () => [
+        t.buttonText ? (o(), n(e(E), {
+          key: 0,
+          variant: "outlined",
+          color: "default",
+          class: "button",
+          onClick: f[0] || (f[0] = (B) => i.$emit("click"))
+        }, {
+          default: m(() => [
+            l(u(t.buttonText), 1)
+          ]),
+          _: 1
+        })) : a("", !0)
+      ], !0)
+    ], 16));
+  }
+});
+export {
+  P as default
+};

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

@@ -1,4 +1,4 @@
-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 "../../../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 = {
@@ -38,15 +38,6 @@ const v = { class: "editable-container" }, x = {
     ], 512));
   }
 });
-export {
-  N as default
-};
-    ], !0)
-        ]))
-      ])
-    ], 512));
-  }
-});
 export {
   N as default
 };

package/components/tag/Tag.vue.d.ts

@@ -0,0 +1,100 @@
+import { ChipSize, ChipColor, ChipVariant } from '../chip/v4/Chip.types';
+declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    label: string;
+    isSelected: boolean;
+    isInvalid?: boolean;
+    testId?: string;
+    size?: ChipSize;
+    rounded?: boolean;
+    disabled?: boolean;
+    color?: ChipColor;
+    variant?: ChipVariant;
+    placeholder?: string;
+    iconName?: string;
+    editable?: boolean;
+    selectable?: boolean;
+    maxLength?: number;
+}>, {
+    isInvalid: boolean;
+    label: string;
+    testId: string;
+    size: string;
+    rounded: boolean;
+    disabled: boolean;
+    color: string;
+    variant: string;
+    placeholder: string;
+    iconName: string;
+    editable: boolean;
+    selectable: boolean;
+    maxLength: any;
+}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:label": (value: string) => void;
+    remove: () => void;
+    stopEditing: () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
+    label: string;
+    isSelected: boolean;
+    isInvalid?: boolean;
+    testId?: string;
+    size?: ChipSize;
+    rounded?: boolean;
+    disabled?: boolean;
+    color?: ChipColor;
+    variant?: ChipVariant;
+    placeholder?: string;
+    iconName?: string;
+    editable?: boolean;
+    selectable?: boolean;
+    maxLength?: number;
+}>, {
+    isInvalid: boolean;
+    label: string;
+    testId: string;
+    size: string;
+    rounded: boolean;
+    disabled: boolean;
+    color: string;
+    variant: string;
+    placeholder: string;
+    iconName: string;
+    editable: boolean;
+    selectable: boolean;
+    maxLength: any;
+}>>> & {
+    onRemove?: () => any;
+    "onUpdate:label"?: (value: string) => any;
+    onStopEditing?: () => any;
+}, {
+    label: string;
+    testId: string;
+    variant: ChipVariant;
+    disabled: boolean;
+    color: ChipColor;
+    size: ChipSize;
+    iconName: string;
+    rounded: boolean;
+    maxLength: number;
+    placeholder: string;
+    editable: boolean;
+    isInvalid: boolean;
+    selectable: boolean;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/components/tag/index.d.ts

@@ -0,0 +1,141 @@
+import Tag from './Tag.vue';
+declare const TagTypes: () => import("vue").DefineComponent<{
+    label: {
+        type: import("vue").PropType<string>;
+        required: true;
+        default: string;
+    };
+    testId: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    variant: {
+        type: import("vue").PropType<"filled" | "outlined">;
+        default: string;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    color: {
+        type: import("vue").PropType<"dark" | "default" | "primary" | "info" | "success" | "warning" | "error">;
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<"small" | "medium">;
+        default: string;
+    };
+    iconName: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    rounded: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    maxLength: {
+        type: import("vue").PropType<number>;
+        default: any;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    isSelected: {
+        type: import("vue").PropType<boolean>;
+        required: true;
+    };
+    editable: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    isInvalid: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    selectable: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:label": (value: string) => void;
+    remove: () => void;
+    stopEditing: () => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    label: {
+        type: import("vue").PropType<string>;
+        required: true;
+        default: string;
+    };
+    testId: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    variant: {
+        type: import("vue").PropType<"filled" | "outlined">;
+        default: string;
+    };
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    color: {
+        type: import("vue").PropType<"dark" | "default" | "primary" | "info" | "success" | "warning" | "error">;
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<"small" | "medium">;
+        default: string;
+    };
+    iconName: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    rounded: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    maxLength: {
+        type: import("vue").PropType<number>;
+        default: any;
+    };
+    placeholder: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    isSelected: {
+        type: import("vue").PropType<boolean>;
+        required: true;
+    };
+    editable: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    isInvalid: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    selectable: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}>> & {
+    onRemove?: () => any;
+    "onUpdate:label"?: (value: string) => any;
+    onStopEditing?: () => any;
+}, {
+    label: string;
+    testId: string;
+    variant: "filled" | "outlined";
+    disabled: boolean;
+    color: "dark" | "default" | "primary" | "info" | "success" | "warning" | "error";
+    size: "small" | "medium";
+    iconName: string;
+    rounded: boolean;
+    maxLength: number;
+    placeholder: string;
+    editable: boolean;
+    isInvalid: boolean;
+    selectable: boolean;
+}>[];
+export { Tag, TagTypes };

package/components/tagsField/TagsFieldChip.vue.d.ts

@@ -1,72 +1,29 @@
-import { ChipSize, ChipColor, ChipVariant } from '../chip/v4/Chip.types';
 declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     label: string;
     isInvalid?: boolean;
     testId?: string;
-    size?: ChipSize;
-    rounded?: boolean;
-    disabled?: boolean;
-    removable?: boolean;
-    color?: ChipColor;
-    iconColor?: string;
-    variant?: ChipVariant;
-    placeholder?: string;
 }>, {
     isInvalid: boolean;
     label: string;
     testId: string;
-    size: string;
-    rounded: boolean;
-    disabled: boolean;
-    removable: boolean;
-    color: string;
-    iconColor: string;
-    variant: string;
-    placeholder: string;
 }>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:label": (value: string) => void;
     remove: () => void;
-    stopEditing: () => void;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
     label: string;
     isInvalid?: boolean;
     testId?: string;
-    size?: ChipSize;
-    rounded?: boolean;
-    disabled?: boolean;
-    removable?: boolean;
-    color?: ChipColor;
-    iconColor?: string;
-    variant?: ChipVariant;
-    placeholder?: string;
 }>, {
     isInvalid: boolean;
     label: string;
     testId: string;
-    size: string;
-    rounded: boolean;
-    disabled: boolean;
-    removable: boolean;
-    color: string;
-    iconColor: string;
-    variant: string;
-    placeholder: string;
 }>>> & {
     onRemove?: () => any;
     "onUpdate:label"?: (value: string) => any;
-    onStopEditing?: () => any;
 }, {
     label: string;
     testId: string;
-    variant: ChipVariant;
-    disabled: boolean;
-    color: ChipColor;
-    size: ChipSize;
-    rounded: boolean;
-    placeholder: string;
     isInvalid: boolean;
-    removable: boolean;
-    iconColor: string;
 }>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/components/tagsField/TagsFieldChip.vue.js

@@ -1,7 +1,7 @@
-import o from "./TagsFieldChip.vue2.js";
-/* empty css                    */import e from "../../_virtual/_plugin-vue_export-helper.js";
-// import "../../TagsFieldChip.vue_vue_type_style_index_0_scoped_cbb21c6a_lang.css"; //*');
-const p = /* @__PURE__ */ e(o, [["__scopeId", "data-v-cbb21c6a"]]);
+import e from "./TagsFieldChip.vue2.js";
+/* empty css                    */import o from "../../_virtual/_plugin-vue_export-helper.js";
+// import "../../TagsFieldChip.vue_vue_type_style_index_0_scoped_d186b7ef_lang.css"; //*');
+const t = /* @__PURE__ */ o(e, [["__scopeId", "data-v-d186b7ef"]]);
 export {
-  p as default
+  t as default
 };

package/components/tagsField/TagsFieldChip.vue2.js

@@ -1,127 +1,81 @@
- import "../../TagsFieldChip.vue_vue_type_style_index_0_scoped_cbb21c6a_lang.css"; import { defineComponent as V, ref as d, computed as b, watch as N, nextTick as k, openBlock as u, createBlock as g, unref as t, normalizeClass as s, normalizeStyle as w, withModifiers as n, withCtx as C, createElementVNode as S, createTextVNode as K, toDisplayString as z, withDirectives as x, createElementBlock as I, isRef as D, withKeys as B, vModelText as F, createCommentVNode as O, createVNode as W, vShow as L } from "vue";
-import U from "../typography/v4/Typography.vue.js";
-import $ from "../icon/v4/IconV4.vue.js";
+ import "../../TagsFieldChip.vue_vue_type_style_index_0_scoped_d186b7ef_lang.css"; import { defineComponent as k, ref as p, computed as x, openBlock as C, createBlock as I, unref as t, normalizeClass as c, withModifiers as s, withCtx as f, createElementVNode as v, createVNode as m, createTextVNode as w, toDisplayString as T, withDirectives as B, isRef as E, withKeys as h, vShow as V, vModelText as K, nextTick as N } from "vue";
+import R from "../typography/v4/Typography.vue.js";
+import z from "../icon/v4/IconV4.vue.js";
 import "../icon/v4/IconFlag.vue.js";
-import j from "../chip/v4/ChipV4.vue.js";
-const q = { class: "chip-content" }, A = ["placeholder", "onKeyup"], X = /* @__PURE__ */ V({
+import D from "../chip/v4/ChipV4.vue.js";
+const M = { class: "chip-content" }, S = ["onKeyup"], j = /* @__PURE__ */ k({
   __name: "TagsFieldChip",
   props: {
     label: { default: "" },
     isInvalid: { type: Boolean, default: !1 },
-    testId: { default: "" },
-    size: { default: "small" },
-    rounded: { type: Boolean, default: !0 },
-    disabled: { type: Boolean, default: !1 },
-    removable: { type: Boolean, default: !0 },
-    color: { default: "default" },
-    iconColor: { default: "var(--action-active)" },
-    variant: { default: "filled" },
-    placeholder: { default: "" }
+    testId: { default: "" }
   },
-  emits: ["update:label", "remove", "stopEditing"],
-  setup(e, { emit: r }) {
-    const i = e, a = d(!1), l = b({
-      get: () => i.label,
-      set: (h) => {
-        r("update:label", h);
+  emits: ["update:label", "remove"],
+  setup(l, { emit: n }) {
+    const b = l, i = p(!1), e = x({
+      get: () => b.label,
+      set: (d) => {
+        n("update:label", d);
       }
-    }), p = d(null), E = () => p.value?.focus(), M = async () => {
-      i.disabled || (a.value = !0, await k(), E());
-    }, R = () => {
-      r("stopEditing"), c();
-    }, c = () => {
-      a.value = !1, !l.value && !i.placeholder && r("remove");
-    }, v = d(null), f = d(void 0);
-    N(
-      () => [l.value, i.placeholder, a.value],
-      async () => {
-        await k(), a.value && v.value ? f.value = v.value.offsetWidth + "px" : f.value = void 0;
-      },
-      { immediate: !0 }
-    );
-    const m = {
-      default: "var(--default-outlined-border)",
-      primary: "var(--primary-main)",
-      info: "var(--info-dark)",
-      error: "var(--error-main)",
-      warning: "var(--warning-main)",
-      success: "var(--success-main)",
-      dark: "var(--common-divider)"
-    }, T = b(() => a.value && i.variant !== "outlined" ? {
-      "--outline-color": i.isInvalid ? m.error : m[i.color] || "var(--default-outlined-border)"
-    } : {});
-    return (h, o) => (u(), g(t(j), {
-      class: s({
-        "rounded-chip": e.rounded,
-        "tags-field-chip--editing": a.value && e.variant !== "outlined"
-        // outlined chips have an outline
-      }),
-      label: t(l),
-      "test-id": e.testId,
-      color: e.isInvalid ? "error" : e.color,
-      size: e.size,
-      variant: e.variant,
-      disabled: e.disabled,
-      style: w(t(T)),
-      onClick: n(M, ["stop"])
+    }), r = p(null), g = () => r.value?.focus(), y = async () => {
+      i.value = !0, await N(), g();
+    }, o = () => {
+      i.value = !1, e.value || n("remove");
+    };
+    return (d, a) => (C(), I(t(D), {
+      class: c(["tags-field-chip", {
+        "tags-field-chip--editing": i.value,
+        "tags-field-chip--invalid": l.isInvalid
+      }]),
+      label: t(e),
+      "test-id": l.testId,
+      color: l.isInvalid ? "error" : "default",
+      onClick: s(y, ["stop"])
     }, {
-      default: C(() => [
-        S("div", q, [
-          a.value ? x((u(), I("input", {
-            key: 1,
+      default: f(() => [
+        v("div", M, [
+          m(t(R), {
+            variant: "chipLabel",
+            class: c(["chip-label", { "chip-label--hidden": i.value }])
+          }, {
+            default: f(() => [
+              w(T(t(e)), 1)
+            ]),
+            _: 1
+          }, 8, ["class"]),
+          B(v("input", {
             ref_key: "inputRef",
-            ref: p,
-            "onUpdate:modelValue": o[0] || (o[0] = (y) => D(l) ? l.value = y : null),
-            placeholder: e.placeholder,
-            class: s(["chip-input", { "chip-input-outline": e.variant === "outlined" }]),
+            ref: r,
+            "onUpdate:modelValue": a[0] || (a[0] = (u) => E(e) ? e.value = u : null),
+            class: "chip-input",
             spellcheck: "false",
-            style: w({ width: f.value }),
-            onBlur: R,
+            onBlur: o,
             onKeyup: [
-              B(n(c, ["prevent"]), ["enter"]),
-              B(n(c, ["prevent"]), ["esc"])
+              h(s(o, ["prevent"]), ["enter"]),
+              h(s(o, ["prevent"]), ["esc"])
             ]
-          }, null, 46, A)), [
+          }, null, 40, S), [
+            [V, i.value],
             [
-              F,
-              t(l),
+              K,
+              t(e),
               void 0,
               { trim: !0 }
             ]
-          ]) : (u(), g(t(U), {
-            key: 0,
-            variant: "chipLabel",
-            class: s(["chip-label", { "chip-label--placeholder": !t(l) && e.placeholder }])
-          }, {
-            default: C(() => [
-              K(z(t(l) || e.placeholder), 1)
-            ]),
-            _: 1
-          }, 8, ["class"])),
-          a.value ? (u(), I("span", {
-            key: 2,
-            ref_key: "sizerRef",
-            ref: v,
-            class: "chip-input-sizer"
-          }, z(t(l) || e.placeholder || ""), 513)) : O("", !0)
+          ])
         ]),
-        x(W(t($), {
-          class: s(["clear-button", { "clear-button--invalid": e.isInvalid }]),
+        m(t(z), {
+          class: c(["clear-button", { "clear-button--invalid": l.isInvalid }]),
           name: "x-circle",
           size: "16px",
           type: "fill",
-          color: e.isInvalid ? "var(--error-dark)" : e.iconColor,
-          onMousedown: o[1] || (o[1] = n(() => {
-          }, ["prevent"])),
-          onClick: o[2] || (o[2] = n((y) => r("remove"), ["stop"]))
-        }, null, 8, ["class", "color"]), [
-          [L, e.removable]
-        ])
+          onClick: a[1] || (a[1] = s((u) => n("remove"), ["stop"]))
+        }, null, 8, ["class"])
       ]),
       _: 1
-    }, 8, ["class", "label", "test-id", "color", "size", "variant", "disabled", "style", "onClick"]));
+    }, 8, ["class", "label", "test-id", "color", "onClick"]));
   }
 });
 export {
-  X as default
+  j as default
 };