@ironsource/shared-ui 1.4.2-rc.6 → 1.4.2-test.1

package/components/table/TableHeaderSorter.vue2.js

@@ -0,0 +1,23 @@
+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/index.d.ts

@@ -1,4 +1,266 @@
-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<{
+            isLoading: boolean;
+            sections: import("./Table.types").Section[];
+            isSticky: boolean;
+            emptyStateTitle: string;
+            emptyStateSubtitle: string;
+            isInfiniteScroll: boolean;
+            infiniteScrollThreshold: number;
+            rowHeight: number | ((index: number) => number);
+            loadingRowCount: 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;
+            };
+            columns: {
+                type: import("vue").PropType<import("./Table.types").Column[]>;
+                required: true;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            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;
+            };
+            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;
+            };
+        }>> & {
+            "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, "isLoading" | "sections" | "isSticky" | "emptyStateTitle" | "emptyStateSubtitle" | "isInfiniteScroll" | "infiniteScrollThreshold" | "rowHeight" | "loadingRowCount">;
+        $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: "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;
+            };
+            columns: {
+                type: import("vue").PropType<import("./Table.types").Column[]>;
+                required: true;
+            };
+            isLoading: {
+                type: import("vue").PropType<boolean>;
+                default: boolean;
+            };
+            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;
+            };
+            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;
+            };
+        }>> & {
+            "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;
+            saveRow: (payload_0: {
+                value: unknown;
+                confirm: () => void;
+                rowIndex: number;
+                cellIndex: number;
+            }) => void;
+            loadMore: () => void;
+        }, string, {
+            isLoading: boolean;
+            sections: import("./Table.types").Section[];
+            isSticky: boolean;
+            emptyStateTitle: string;
+            emptyStateSubtitle: string;
+            isInfiniteScroll: boolean;
+            infiniteScrollThreshold: number;
+            rowHeight: number | ((index: number) => number);
+            loadingRowCount: 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;
+        };
+        columns: {
+            type: import("vue").PropType<import("./Table.types").Column[]>;
+            required: true;
+        };
+        isLoading: {
+            type: import("vue").PropType<boolean>;
+            default: boolean;
+        };
+        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;
+        };
+        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;
+        };
+    }>> & {
+        "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;
@@ -13,126 +275,44 @@ declare const TableTypes: () => (import("vue").InjectionKey<import("./TableConte
     };
     isLoading: {
         type: import("vue").PropType<boolean>;
-    } & {
         default: boolean;
     };
-    isSticky: {
-        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;
-    };
     rows: {
         type: import("vue").PropType<unknown[][]>;
         required: true;
     };
-}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    "update:sort": (newSort: import("./Table.types").Sort) => 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;
-    };
-    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;
     };
-    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;
     };
-    rows: {
-        type: import("vue").PropType<unknown[][]>;
-        required: true;
-    };
 }>> & {
     "onUpdate:sort"?: (newSort: import("./Table.types").Sort) => any;
     onSaveRow?: (args_0: {
@@ -142,17 +322,45 @@ 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;
+    saveRow: (payload_0: {
+        value: unknown;
+        confirm: () => void;
+        rowIndex: number;
+        cellIndex: number;
+    }) => void;
+    loadMore: () => void;
+}, string, {
     isLoading: boolean;
-    isSticky: boolean;
     sections: import("./Table.types").Section[];
+    isSticky: boolean;
     emptyStateTitle: string;
     emptyStateSubtitle: string;
     isInfiniteScroll: boolean;
     infiniteScrollThreshold: number;
     rowHeight: number | ((index: number) => number);
     loadingRowCount: number;
-}>)[];
+}, {}, string> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {
+        column: import("./Table.types").Column;
+    }) => any>> & Partial<Record<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,45 +1,65 @@
-declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<{
-    cell?: string;
-    isEditing?: boolean;
-    validateFunction?: (value: unknown) => string | boolean;
-    isLoading?: boolean;
-    rowIndex: number;
-    cellIndex: number;
-}>, {
-    cell: string;
-    isLoading: boolean;
-    isEditing: boolean;
-    validateFunction: () => false;
-}>, {}, 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;
-    isLoading?: boolean;
-    rowIndex: number;
-    cellIndex: number;
-}>, {
-    cell: string;
-    isLoading: boolean;
-    isEditing: boolean;
-    validateFunction: () => false;
-}>>>, {
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    cell: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    isLoading: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    isEditing: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    validateFunction: {
+        type: import("vue").PropType<(value: unknown) => string | boolean>;
+        default: () => false;
+    };
+    rowIndex: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    cellIndex: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    cell: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    isLoading: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    isEditing: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    validateFunction: {
+        type: import("vue").PropType<(value: unknown) => string | boolean>;
+        default: () => false;
+    };
+    rowIndex: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+    cellIndex: {
+        type: import("vue").PropType<number>;
+        required: true;
+    };
+}>>, {
     cell: string;
     isLoading: boolean;
     isEditing: boolean;
     validateFunction: (value: unknown) => string | boolean;
+}>, {
+    input?(_: {}): any;
+    content?(_: {}): any;
 }>;
 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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
     };
 };
-type __VLS_WithDefaults<P, D> = {
-    [K in keyof Pick<P, keyof P>]: K extends keyof D ? P[K] & {
-        default: D[K];
-    } : P[K];
-};

package/components/table-cells/Editable.vue.js

@@ -1,89 +1,6 @@
-import { defineComponent, ref, provide, openBlock, createElementBlock, createElementVNode, renderSlot, createVNode, withCtx, createTextVNode, toDisplayString } from 'vue';
-import Text from '../typography/Text.vue.js';
-import { EditableContext } from './EditableContext.vue.js';
-import { onClickOutside } from '@vueuse/core';
-import { useTableContext } from '../table/TableContext.vue.js';
-/* empty css                                                          */import _export_sfc from '../../_virtual/plugin-vue_export-helper.vue.js';
-
-import "../../Editable.vue_vue_type_style_index_0_scoped_true_lang.css";
-const _hoisted_1 = { class: "editable-container" };
-const _hoisted_2 = {
-  key: 1,
-  class: "editable-content"
+import o from "./Editable.vue2.js";
+/* empty css               */import t from "../../_virtual/_plugin-vue_export-helper.js";
+const r = /* @__PURE__ */ t(o, [["__scopeId", "data-v-e6ea7f1f"]]);
+export {
+  r as default
 };
-const _sfc_main = /* @__PURE__ */ defineComponent({
-  __name: "Editable",
-  props: {
-    cell: { default: "" },
-    isEditing: { type: Boolean, default: false },
-    validateFunction: { type: Function, default: () => false },
-    isLoading: { type: Boolean, default: false },
-    rowIndex: null,
-    cellIndex: null
-  },
-  setup(__props) {
-    const props = __props;
-    const isEditing = ref(false);
-    const value = ref(props.cell);
-    const target = ref(null);
-    const api = useTableContext("Editable");
-    const errorRef = ref(null);
-    provide(EditableContext, {
-      focusable: true,
-      value,
-      error: errorRef,
-      confirmable: true,
-      onChange(val) {
-        value.value = val;
-        errorRef.value = props.validateFunction?.(value.value);
-      },
-      onClose: () => {
-        const error = props.validateFunction?.(value.value);
-        errorRef.value = error;
-        if (error) {
-          return;
-        }
-        api.onClose({
-          rowIndex: props.rowIndex,
-          cellIndex: props.cellIndex,
-          value: value.value
-        });
-        isEditing.value = false;
-      }
-    });
-    const onEdit = () => {
-      if (isEditing.value) {
-        return;
-      }
-      isEditing.value = !isEditing.value;
-    };
-    onClickOutside(target, () => {
-      isEditing.value = false;
-      api.onClose();
-    });
-    return (_ctx, _cache) => {
-      return openBlock(), createElementBlock("div", {
-        ref_key: "target",
-        ref: target,
-        class: "container",
-        onClick: onEdit
-      }, [
-        createElementVNode("div", _hoisted_1, [
-          isEditing.value ? renderSlot(_ctx.$slots, "input", { key: 0 }, void 0, true) : (openBlock(), createElementBlock("div", _hoisted_2, [
-            renderSlot(_ctx.$slots, "content", {}, () => [
-              createVNode(Text, { size: "sm" }, {
-                default: withCtx(() => [
-                  createTextVNode(toDisplayString(__props.cell), 1)
-                ]),
-                _: 1
-              })
-            ], true)
-          ]))
-        ])
-      ], 512);
-    };
-  }
-});
-var Editable = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-20f632f8"]]);
-
-export { Editable as default };