@agrotools1/at-components 1.0.0 → 1.0.2

package/dist/DataTable/DataTable.d.ts

@@ -0,0 +1,345 @@
+import { PropType } from 'vue';
+
+type TableData = Array<{
+    [key: string]: unknown;
+}>;
+declare const _default: import('vue').DefineComponent<{
+    value: {
+        type: PropType<TableData>;
+        required: true;
+    };
+    withEditableFields: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    withSelection: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    withDefaultSelectedItems: {
+        type: PropType<string[]>;
+        required: false;
+        default: () => undefined;
+    };
+    withPaginator: {
+        type: PropType<{
+            total: number;
+            pageSize: number;
+            onUpdatePage: (page: number) => void;
+        } | undefined>;
+        default: undefined;
+    };
+    keyExtractor: {
+        type: PropType<(item: any) => string>;
+        default: (item: any) => any;
+    };
+    columnsClasses: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    alignColumns: {
+        type: PropType<"center" | "left" | "right">;
+        default: string;
+    };
+    isLoading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    loadingRowsLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    disableWithoutCSS: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    stickHeader: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, {
+    reactiveIsLoading: import('vue').ComputedRef<boolean>;
+    tableData: import('vue').Ref<{
+        [key: string]: unknown;
+    }[]>;
+    activeTableData: import('vue').Ref<{
+        [key: string]: unknown;
+    }[]>;
+    columns: string[];
+    updateColumn: (column: string) => void;
+    internalUpdateColumn: (column: string) => void;
+    internalColumns: string[];
+    lastHoveredTr: import('vue').Ref<{
+        element: HTMLTableRowElement;
+        item: any;
+    } | null>;
+    getEntries: (item: any) => [string, unknown][];
+    extractKey: (item: any) => string | undefined;
+    updateOnKeyDown: (event: KeyboardEvent, field: string) => void;
+    handleTrClick: (event: MouseEvent, field: string) => void;
+    paginatorRef: import('vue').Ref<({
+        $: import('vue').ComponentInternalInstance;
+        $data: {};
+        $props: {
+            disable?: boolean | undefined;
+            disableWithoutCSS?: boolean | undefined;
+            class?: unknown;
+            key?: string | number | symbol | undefined;
+            ref?: import('vue').VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeMounted?: ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUpdate?: ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUpdated?: ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>, oldVNode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeBeforeUnmount?: ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            onVnodeUnmounted?: ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void) | ((vnode: import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+                [key: string]: any;
+            }>) => void)[] | undefined;
+            style?: unknown;
+            "onUpdate:activePage"?: ((page: number) => any) | undefined;
+            readonly total: number;
+            readonly pageSize: number;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import('vue').Slot<any> | undefined;
+        }>;
+        $root: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $parent: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null;
+        $emit: (event: "update:activePage", page: number) => void;
+        $el: any;
+        $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            total: {
+                type: NumberConstructor;
+                required: true;
+            };
+            pageSize: {
+                type: NumberConstructor;
+                required: true;
+            };
+            disable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disableWithoutCSS: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            "onUpdate:activePage"?: ((page: number) => any) | undefined;
+        }, {
+            activePage: import('vue').Ref<number>;
+            activeChunk: import('vue').Ref<number>;
+            pageChunks: import('vue').ComputedRef<number[][]>;
+            isDisabled: import('vue').ComputedRef<boolean>;
+            isDisabledWithoutCSS: import('vue').ComputedRef<boolean>;
+            pages: import('vue').ComputedRef<number[]>;
+            icons: {
+                arrowLeft: string;
+                arrowRight: string;
+                doubleLeft: string;
+                doubleRight: string;
+            };
+            nextChunk: () => void;
+            nextPage: () => void;
+            previousPage: () => void;
+            previousChunk: () => void;
+        }, unknown, {}, {
+            setPage(page: number): void;
+        }, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            "update:activePage": (page: number) => boolean;
+        }, string, {
+            disable: boolean;
+            disableWithoutCSS: boolean;
+        }, {}, string, {}> & {
+            beforeCreate?: ((() => void) | (() => void)[]) | undefined;
+            created?: ((() => void) | (() => void)[]) | undefined;
+            beforeMount?: ((() => void) | (() => void)[]) | undefined;
+            mounted?: ((() => void) | (() => void)[]) | undefined;
+            beforeUpdate?: ((() => void) | (() => void)[]) | undefined;
+            updated?: ((() => void) | (() => void)[]) | undefined;
+            activated?: ((() => void) | (() => void)[]) | undefined;
+            deactivated?: ((() => void) | (() => void)[]) | undefined;
+            beforeDestroy?: ((() => void) | (() => void)[]) | undefined;
+            beforeUnmount?: ((() => void) | (() => void)[]) | undefined;
+            destroyed?: ((() => void) | (() => void)[]) | undefined;
+            unmounted?: ((() => void) | (() => void)[]) | undefined;
+            renderTracked?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            renderTriggered?: (((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[]) | undefined;
+            errorCaptured?: (((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import('vue').ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}>, {}, {}> | null, info: string) => boolean | void)[]) | undefined;
+        };
+        $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> | undefined): import('vue').WatchStopHandle;
+    } & Readonly<import('vue').ExtractPropTypes<{
+        total: {
+            type: NumberConstructor;
+            required: true;
+        };
+        pageSize: {
+            type: NumberConstructor;
+            required: true;
+        };
+        disable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disableWithoutCSS: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {
+        "onUpdate:activePage"?: ((page: number) => any) | undefined;
+    } & import('vue').ShallowUnwrapRef<{
+        activePage: import('vue').Ref<number>;
+        activeChunk: import('vue').Ref<number>;
+        pageChunks: import('vue').ComputedRef<number[][]>;
+        isDisabled: import('vue').ComputedRef<boolean>;
+        isDisabledWithoutCSS: import('vue').ComputedRef<boolean>;
+        pages: import('vue').ComputedRef<number[]>;
+        icons: {
+            arrowLeft: string;
+            arrowRight: string;
+            doubleLeft: string;
+            doubleRight: string;
+        };
+        nextChunk: () => void;
+        nextPage: () => void;
+        previousPage: () => void;
+        previousChunk: () => void;
+    }> & {} & {
+        setPage(page: number): void;
+    } & import('vue').ComponentCustomProperties & {}) | undefined>;
+}, unknown, {}, {
+    setPage(page: number): void;
+}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:selected-items": (items: Array<any>) => boolean;
+    "update:table-data": (data: TableData) => boolean;
+    "update:table-cell": (data: {
+        field: string;
+        value: string | number | boolean;
+    }) => boolean;
+}, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
+    value: {
+        type: PropType<TableData>;
+        required: true;
+    };
+    withEditableFields: {
+        type: PropType<string[]>;
+        default: undefined;
+    };
+    withSelection: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    withDefaultSelectedItems: {
+        type: PropType<string[]>;
+        required: false;
+        default: () => undefined;
+    };
+    withPaginator: {
+        type: PropType<{
+            total: number;
+            pageSize: number;
+            onUpdatePage: (page: number) => void;
+        } | undefined>;
+        default: undefined;
+    };
+    keyExtractor: {
+        type: PropType<(item: any) => string>;
+        default: (item: any) => any;
+    };
+    columnsClasses: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    alignColumns: {
+        type: PropType<"center" | "left" | "right">;
+        default: string;
+    };
+    isLoading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    loadingRowsLength: {
+        type: NumberConstructor;
+        default: number;
+    };
+    disable: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    disableWithoutCSS: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    stickHeader: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:selected-items"?: ((items: any[]) => any) | undefined;
+    "onUpdate:table-data"?: ((data: TableData) => any) | undefined;
+    "onUpdate:table-cell"?: ((data: {
+        field: string;
+        value: string | number | boolean;
+    }) => any) | undefined;
+}, {
+    isLoading: boolean;
+    disable: boolean;
+    disableWithoutCSS: boolean;
+    alignColumns: "center" | "left" | "right";
+    withEditableFields: string[];
+    withSelection: boolean;
+    withDefaultSelectedItems: string[];
+    withPaginator: {
+        total: number;
+        pageSize: number;
+        onUpdatePage: (page: number) => void;
+    } | undefined;
+    keyExtractor: (item: any) => string;
+    columnsClasses: string[];
+    loadingRowsLength: number;
+    stickHeader: boolean;
+}, {}>;
+export default _default;

package/dist/DataTable/DataTable.vue.js

@@ -0,0 +1,119 @@
+import S from "./DataTable.vue2.js";
+import { resolveComponent as p, openBlock as t, createElementBlock as o, Fragment as i, createElementVNode as l, mergeProps as C, createBlock as c, createCommentVNode as u, renderSlot as P, withDirectives as A, renderList as d, normalizeClass as g, withKeys as $, toDisplayString as f, resolveDynamicComponent as w, vShow as D, createVNode as I, pushScopeId as T, popScopeId as E } from "vue";
+import "./DataTable.vue3.js";
+import K from "../_virtual/_plugin-vue_export-helper.js";
+const k = (e) => (T("data-v-1c491103"), e = e(), E(), e), z = ["data-align-columns"], L = ["data-isStick"], B = {
+  role: "row",
+  class: "thead-row"
+}, F = {
+  key: 1,
+  role: "rowgroup"
+}, N = /* @__PURE__ */ k(() => /* @__PURE__ */ l("tr", { class: "empty-space" }, null, -1)), U = ["onmouseenter"], V = ["data-key", "onClick"], H = { class: "td-container" }, R = ["id", "value", "onKeydown"], j = { key: 1 }, O = {
+  key: 2,
+  class: "item-as-array"
+}, W = { key: 0 }, q = /* @__PURE__ */ k(() => /* @__PURE__ */ l("tr", { class: "empty-space" }, null, -1)), G = {
+  key: 0,
+  class: "d-flex flex-column gap-2 w-100"
+}, J = { class: "table-skeleton" }, M = {
+  key: 1,
+  style: { display: "flex", "justify-content": "flex-end", "margin-top": "16px" }
+};
+function Q(e, X, Y, Z, x, ee) {
+  var h;
+  const b = p("AtColumn"), v = p("AtText"), _ = p("AtPaginator");
+  return t(), o(i, null, [
+    l("table", C(e.$attrs, {
+      role: "table",
+      class: "table-content",
+      "data-align-columns": e.alignColumns
+    }), [
+      l("thead", {
+        role: "rowgroup",
+        "data-isStick": e.stickHeader
+      }, [
+        l("tr", B, [
+          e.withSelection ? (t(), c(b, {
+            key: 0,
+            field: "selection",
+            label: "Selecione"
+          })) : u("", !0),
+          P(e.$slots, "default", {}, void 0, !0)
+        ])
+      ], 8, L),
+      !e.value || !e.value.length ? (t(), c(v, {
+        key: 0,
+        as: "h6"
+      })) : A((t(), o("tbody", F, [
+        N,
+        (t(!0), o(i, null, d(e.activeTableData, (r) => (t(), o("tr", {
+          key: e.extractKey(r),
+          class: g([...e.columnsClasses, "tbody-tr"]),
+          role: "row",
+          tabindex: "-1",
+          onmouseenter: (s) => {
+            e.lastHoveredTr = {
+              element: s.target,
+              item: r
+            };
+          }
+        }, [
+          (t(!0), o(i, null, d(e.getEntries(r), ([s, a]) => {
+            var y, m;
+            return t(), o("td", {
+              key: s,
+              "data-key": s,
+              role: "cell",
+              class: g(`tbody-row ${(y = e.withEditableFields) != null && y.includes(s) ? "with-focus" : ""} `),
+              "aria-selected": "false",
+              onClick: (n) => e.handleTrClick(n, s)
+            }, [
+              l("div", H, [
+                (m = e.withEditableFields) != null && m.includes(s) ? (t(), o("input", {
+                  key: 0,
+                  id: s,
+                  placeholder: "",
+                  value: a,
+                  onKeydown: $((n) => e.updateOnKeyDown(n, s), ["enter"])
+                }, null, 40, R)) : typeof a == "number" || typeof a == "string" ? (t(), o("span", j, f(a), 1)) : Array.isArray(a) ? (t(), o("div", O, [
+                  (t(!0), o(i, null, d(a, (n) => (t(), o("div", { key: n }, [
+                    typeof n == "number" || typeof n == "string" ? (t(), o("span", W, f(n), 1)) : (t(), c(w(typeof n == "function" ? n() : n), { key: 1 }))
+                  ]))), 128))
+                ])) : (t(), c(w(typeof a == "function" ? a() : a), { key: 3 }))
+              ])
+            ], 10, V);
+          }), 128))
+        ], 10, U))), 128)),
+        q
+      ], 512)), [
+        [D, !e.reactiveIsLoading]
+      ])
+    ], 16, z),
+    e.reactiveIsLoading ? (t(), o("div", G, [
+      l("div", J, [
+        (t(!0), o(i, null, d(e.loadingRowsLength, (r) => (t(), o("div", {
+          key: r,
+          class: "skeleton-row"
+        }, [
+          (t(!0), o(i, null, d(e.columns, (s) => (t(), o("div", {
+            key: s,
+            class: "skeleton-cell"
+          }))), 128))
+        ]))), 128))
+      ])
+    ])) : u("", !0),
+    e.withPaginator ? (t(), o("div", M, [
+      I(_, {
+        ref: "paginatorRef",
+        "page-size": e.withPaginator.pageSize,
+        total: e.withPaginator.total,
+        disable: e.disable,
+        "disable-without-c-s-s": e.disableWithoutCSS,
+        "onUpdate:activePage": (h = e.withPaginator) == null ? void 0 : h.onUpdatePage
+      }, null, 8, ["page-size", "total", "disable", "disable-without-c-s-s", "onUpdate:activePage"])
+    ])) : u("", !0)
+  ], 64);
+}
+const ae = /* @__PURE__ */ K(S, [["render", Q], ["__scopeId", "data-v-1c491103"]]);
+export {
+  ae as default
+};

package/dist/DataTable/DataTable.vue2.js

@@ -0,0 +1,174 @@
+import { defineComponent as T, ref as d, reactive as K, provide as p, readonly as j, inject as E, watch as x, onMounted as B, watchEffect as w, h as O, computed as P } from "vue";
+import R from "../Checkbox/Checkbox.vue.js";
+import L from "../Paginator/Paginator.vue.js";
+import { AtTipograph as q } from "../Tipograph/index.js";
+import F from "./Column/Column.vue.js";
+const J = T({
+  name: "AtDataTable",
+  components: {
+    AtText: q.Title,
+    AtColumn: F,
+    AtPaginator: L
+  },
+  inheritAttrs: !1,
+  props: {
+    value: {
+      type: Array,
+      required: !0
+    },
+    withEditableFields: {
+      type: Array,
+      default: void 0
+    },
+    withSelection: {
+      type: Boolean,
+      default: !1
+    },
+    withDefaultSelectedItems: {
+      type: Array,
+      required: !1,
+      default: () => {
+      }
+    },
+    withPaginator: {
+      type: Object,
+      default: void 0
+    },
+    keyExtractor: {
+      type: Function,
+      default: (e) => e.id
+    },
+    columnsClasses: {
+      type: Array,
+      default: () => []
+    },
+    alignColumns: {
+      type: String,
+      default: "left"
+    },
+    isLoading: {
+      type: Boolean,
+      default: !1
+    },
+    loadingRowsLength: {
+      type: Number,
+      default: 10
+    },
+    disable: {
+      type: Boolean,
+      default: !1
+    },
+    disableWithoutCSS: {
+      type: Boolean,
+      default: !1
+    },
+    stickHeader: {
+      type: Boolean,
+      default: !1
+    }
+  },
+  emits: {
+    "update:selected-items": (e) => Array.isArray(e),
+    "update:table-data": (e) => Array.isArray(e),
+    "update:table-cell": (e) => typeof e == "object"
+  },
+  setup(e, r) {
+    const i = d(e.value), h = d([...i.value]), f = d([]), A = d(), m = d(
+      null
+    ), c = K([]), y = (t) => {
+      c.includes(t) || c.push(t);
+    };
+    p("columns", {
+      columns: j(c),
+      updateColumn: y
+    }), p("alignColumns", e.alignColumns), p("tableData", i);
+    const g = E("columns", {
+      columns: c,
+      updateColumn: y
+    }), C = (t) => Object.entries(t), s = (t) => {
+      try {
+        return e.keyExtractor(t);
+      } catch (a) {
+        console.warn("AtDataTable: Não foi possível extrair a key: ", a);
+      }
+    }, S = (t, a) => {
+      var l;
+      const o = t.target;
+      if ((l = e.withEditableFields) != null && l.includes(a)) {
+        const n = o.querySelector("input");
+        n == null || n.focus();
+      }
+    }, v = (t) => {
+      f.value = t;
+      const a = [...e.value].filter((o) => {
+        const l = s(o);
+        return [...f.value].includes(l);
+      });
+      if (m.value) {
+        const { element: o, item: l } = m.value, n = a.find(
+          (u) => s(u) === s(l)
+        );
+        o.setAttribute("aria-selected", JSON.stringify(!!n));
+      }
+      r.emit("update:selected-items", Array.from(a));
+    }, D = (t, a) => {
+      var u;
+      const o = t.target, { value: l } = o, n = (u = m.value) == null ? void 0 : u.item;
+      n && (n[a] = l, i.value = i.value.map((b) => {
+        const I = s(b), k = s(n);
+        return I === k ? n : b;
+      }), r.emit("update:table-data", i.value), r.emit("update:table-cell", {
+        field: a,
+        value: l
+      }));
+    };
+    return x(
+      () => e.withDefaultSelectedItems,
+      (t) => {
+        t && v(e.withDefaultSelectedItems ?? []);
+      }
+    ), B(() => {
+      e.withDefaultSelectedItems && v([...e.withDefaultSelectedItems]);
+    }), w(() => {
+      e.withSelection ? i.value = [...e.value].map((t) => ({
+        selection: () => O(R, {
+          modelValue: f.value,
+          "onUpdate:modelValue": (a) => v(a),
+          val: s(t)
+        }),
+        ...t
+      })) : i.value = [...e.value];
+    }), w(() => {
+      const t = [...c], a = [...i.value].map((o) => {
+        const l = {}, n = Object.keys({ ...o });
+        for (const u of t)
+          n.includes(u) && (l[u] = o[u]);
+        return l;
+      });
+      h.value = a;
+    }), {
+      reactiveIsLoading: P(() => e.isLoading),
+      tableData: i,
+      activeTableData: h,
+      columns: g.columns,
+      updateColumn: g.updateColumn,
+      internalUpdateColumn: y,
+      internalColumns: c,
+      lastHoveredTr: m,
+      getEntries: C,
+      extractKey: s,
+      updateOnKeyDown: D,
+      handleTrClick: S,
+      paginatorRef: A
+    };
+  },
+  methods: {
+    setPage(e) {
+      var r;
+      (r = this.paginatorRef) == null || r.setPage(e);
+    }
+  }
+});
+export {
+  J as default
+};

package/dist/DataTable/DataTable.vue3.js

@@ -0,0 +1,4 @@
+const e = "";
+export {
+  e as default
+};