@tagplus/components 5.3.4 → 5.3.6

package/dist/lib/src/components/Inline/Inline.vue.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index = require("../../../node_modules/@element-plus/icons-vue/dist/index.js");
+const elementPlus = require("element-plus");
+;/* empty css             */
+const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const _sfc_main = vue.defineComponent({
+  name: "TpInline",
+  components: {
+    ElButton: elementPlus.ElButton,
+    ElInput: elementPlus.ElInput
+  },
+  props: {
+    id: {
+      type: String,
+      required: false,
+      default: null
+    },
+    value: {
+      type: [Number, String],
+      default: ""
+    },
+    readonly: {
+      type: Boolean,
+      default: false
+    },
+    inputHidden: {
+      type: Boolean,
+      default: true
+    },
+    buttonText: {
+      type: String,
+      default: "Ok"
+    }
+  },
+  emits: ["input", "change", "blur"],
+  data() {
+    return {
+      hideInput: true,
+      ElIconCheck: index.Check
+    };
+  },
+  computed: {
+    _id() {
+      return this.id || this.$options.name;
+    }
+  },
+  mounted() {
+    this.hideInput = this.inputHidden;
+  },
+  methods: {
+    toggleInput() {
+      const status = !this.hideInput;
+      if (this.readonly) {
+        this.hideInput = true;
+      } else if (!this.readonly) {
+        this.hideInput = status;
+        if (!this.hideInput) {
+          this.$nextTick(function() {
+            this.$refs.inlineInput.focus();
+          });
+        }
+      }
+    },
+    input(event) {
+      this.$emit("input", event);
+    },
+    blur(event) {
+      this.$emit("blur", event);
+    }
+  }
+});
+const _hoisted_1 = ["id"];
+const _hoisted_2 = {
+  key: 0,
+  "data-tid": "inline-span"
+};
+const _hoisted_3 = ["id"];
+const _hoisted_4 = { "data-tid": "inline-value" };
+const _hoisted_5 = {
+  key: 0,
+  class: "el-icon-edit"
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_button = vue.resolveComponent("el-button");
+  const _component_el_input = vue.resolveComponent("el-input");
+  return vue.openBlock(), vue.createElementBlock("div", {
+    id: `${_ctx._id}-wrapper`,
+    class: "tp-inline"
+  }, [
+    _ctx.hideInput || _ctx.readonly ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2, [
+      vue.createElementVNode("a", {
+        id: `${_ctx._id}-toggle`,
+        tabindex: "0",
+        onClick: _cache[0] || (_cache[0] = (...args) => _ctx.toggleInput && _ctx.toggleInput(...args)),
+        onKeypress: _cache[1] || (_cache[1] = vue.withKeys((...args) => _ctx.toggleInput && _ctx.toggleInput(...args), ["enter"]))
+      }, [
+        vue.createElementVNode("span", _hoisted_4, vue.toDisplayString(_ctx.value), 1),
+        !_ctx.readonly ? (vue.openBlock(), vue.createElementBlock("small", _hoisted_5)) : vue.createCommentVNode("", true)
+      ], 40, _hoisted_3)
+    ])) : (vue.openBlock(), vue.createBlock(_component_el_input, {
+      key: 1,
+      id: `${_ctx._id}-input`,
+      ref: "inlineInput",
+      "model-value": _ctx.value,
+      "data-tid": "inline-input",
+      onInput: _ctx.input,
+      onBlur: _ctx.blur,
+      onKeypress: vue.withKeys(_ctx.toggleInput, ["enter"])
+    }, {
+      append: vue.withCtx(() => [
+        vue.createVNode(_component_el_button, {
+          id: `${_ctx._id}-btn`,
+          icon: _ctx.ElIconCheck,
+          "data-tid": "inline-button",
+          onClick: _ctx.toggleInput
+        }, {
+          default: vue.withCtx(() => [
+            vue.createTextVNode(vue.toDisplayString(_ctx.buttonText), 1)
+          ]),
+          _: 1
+        }, 8, ["id", "icon", "onClick"])
+      ]),
+      _: 1
+    }, 8, ["id", "model-value", "onInput", "onBlur", "onKeypress"]))
+  ], 8, _hoisted_1);
+}
+const Inline = /* @__PURE__ */ _pluginVue_exportHelper.default(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-e30c0e2a"]]);
+exports.default = Inline;

package/dist/lib/src/components/Inline/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Inline = require("./Inline.vue.js");
+exports.default = Inline.default;

package/dist/lib/src/components/InputNumber/InputNumber.vue.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const lodashEs = require("lodash-es");
+const types = require("../../utils/types.js");
+const error = require("../../utils/error.js");
+const useFormItem = require("../../utils/use-form-item.js");
+const useFormCommonProps = require("../../utils/use-form-common-props.js");
+const elementPlus = require("element-plus");
+const index$2 = require("../../../node_modules/@element-plus/icons-vue/dist/index.js");
+const inputNumber = require("./input-number.js");
+const index = require("../../../node_modules/element-plus/es/hooks/use-locale/index.js");
+const index$1 = require("../../../node_modules/element-plus/es/hooks/use-namespace/index.js");
+const shared_esmBundler = require("../../../node_modules/@vue/shared/dist/shared.esm-bundler.js");
+const _hoisted_1 = ["aria-label"];
+const _hoisted_2 = ["aria-label"];
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const CHANGE_EVENT = "change";
+const INPUT_EVENT = "input";
+const _sfc_main = /* @__PURE__ */ Object.assign({
+  name: "TpInputNumber"
+}, {
+  __name: "InputNumber",
+  props: inputNumber.inputNumberProps,
+  emits: inputNumber.inputNumberEmits,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { t } = index.useLocale();
+    const ns = index$1.useNamespace("input-number");
+    const input = vue.ref();
+    const vm = vue.getCurrentInstance().proxy;
+    const key = vue.ref(1);
+    const data = vue.reactive({
+      currentValue: props.modelValue,
+      userInput: null
+    });
+    const { formItem } = useFormItem.useFormItem();
+    const minDisabled = vue.computed(
+      () => types.isNumber(props.modelValue) && props.modelValue <= props.min
+    );
+    const maxDisabled = vue.computed(
+      () => types.isNumber(props.modelValue) && props.modelValue >= props.max
+    );
+    const numPrecision = vue.computed(() => {
+      const stepPrecision = getPrecision(props.step);
+      if (!types.isUndefined(props.precision)) {
+        if (stepPrecision > props.precision) {
+          error.debugWarn(
+            "InputNumber",
+            "precision should not be less than the decimal places of step"
+          );
+        }
+        return props.precision;
+      } else {
+        return Math.max(getPrecision(props.modelValue), stepPrecision);
+      }
+    });
+    const controlsAtRight = vue.computed(() => {
+      return props.controls && props.controlsPosition === "right";
+    });
+    const inputNumberSize = useFormCommonProps.useFormSize();
+    const inputNumberDisabled = useFormCommonProps.useFormDisabled();
+    const displayValue = vue.computed(() => {
+      if (data.userInput !== null) {
+        return data.userInput;
+      }
+      let currentValue = data.currentValue;
+      const fallbackValue = props.stringDefaultsZero ? 0 : "";
+      if (props.modelValue === "" || lodashEs.isNil(currentValue) || currentValue === "") {
+        return fallbackValue;
+      }
+      if (types.isNumber(currentValue)) {
+        if (Number.isNaN(currentValue)) return fallbackValue;
+        if (!types.isUndefined(props.precision)) {
+          currentValue = currentValue.toFixed(props.precision);
+        }
+      }
+      return currentValue;
+    });
+    const displayFormatter = vue.computed(() => {
+      const decimalChar = vm.$t("locale.number.decimal");
+      const thousandsChar = vm.$t("locale.number.thousands");
+      return (value) => {
+        const noLetters = value.replaceAll(/[a-zA-Z]/g, "");
+        const res = noLetters.replace(".", decimalChar).replace(/\B(?=(\d{3})+(?!\d))/g, thousandsChar);
+        return res;
+      };
+    });
+    const inputParser = vue.computed(() => {
+      const decimalChar = vm.$t("locale.number.decimal");
+      const thousandsChar = vm.$t("locale.number.thousands");
+      return (value) => {
+        const regexThou = `/$s?|(${thousandsChar}*)/g`;
+        const res = value.replace(regexThou, "").replace(decimalChar, ".");
+        return res;
+      };
+    });
+    const toPrecision = (num, pre) => {
+      if (types.isUndefined(pre)) pre = numPrecision.value;
+      if (pre === 0) return Math.round(num);
+      let snum = String(num);
+      const pointPos = snum.indexOf(".");
+      if (pointPos === -1) return num;
+      const nums = snum.replace(".", "").split("");
+      const datum = nums[pointPos + pre];
+      if (!datum) return num;
+      const length = snum.length;
+      if (snum.charAt(length - 1) === "5") {
+        snum = `${snum.slice(0, Math.max(0, length - 1))}6`;
+      }
+      return Number.parseFloat(Number(snum).toFixed(pre));
+    };
+    const getPrecision = (value) => {
+      if (lodashEs.isNil(value)) return 0;
+      const valueString = value.toString();
+      const dotPosition = valueString.indexOf(".");
+      let precision = 0;
+      if (dotPosition !== -1) {
+        precision = valueString.length - dotPosition - 1;
+      }
+      return precision;
+    };
+    const ensurePrecision = (val, coefficient = 1) => {
+      if (!types.isNumber(val)) return data.currentValue;
+      return toPrecision(val + props.step * coefficient);
+    };
+    const increase = () => {
+      if (props.readonly || inputNumberDisabled.value || maxDisabled.value) return;
+      const value = Number(displayValue.value) || 0;
+      const newVal = ensurePrecision(value);
+      setCurrentValue(newVal);
+      emit(INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const decrease = () => {
+      if (props.readonly || inputNumberDisabled.value || minDisabled.value) return;
+      const value = Number(displayValue.value) || 0;
+      const newVal = ensurePrecision(value, -1);
+      setCurrentValue(newVal);
+      emit(INPUT_EVENT, data.currentValue);
+      setCurrentValueToModelValue();
+    };
+    const verifyValue = (value, update) => {
+      const { max, min, step, precision, stepStrictly, valueOnClear } = props;
+      if (max < min) {
+        error.throwError("InputNumber", "min should not be greater than max.");
+      }
+      let newVal = Number(value);
+      if (lodashEs.isNil(value) || Number.isNaN(newVal)) {
+        return null;
+      }
+      if (value === "") {
+        if (valueOnClear === null) {
+          return null;
+        }
+        newVal = shared_esmBundler.isString(valueOnClear) ? { min, max }[valueOnClear] : valueOnClear;
+      }
+      if (stepStrictly) {
+        newVal = toPrecision(Math.round(newVal / step) * step, precision);
+      }
+      if (!types.isUndefined(precision)) {
+        newVal = toPrecision(newVal, precision);
+      }
+      if (newVal > max || newVal < min) {
+        newVal = newVal > max ? max : min;
+        update && emit(UPDATE_MODEL_EVENT, newVal);
+      }
+      return newVal;
+    };
+    const setCurrentValue = (value, emitChange = true) => {
+      var _a;
+      const oldVal = data.currentValue;
+      const newVal = verifyValue(value);
+      if (!emitChange) {
+        emit(UPDATE_MODEL_EVENT, newVal);
+        return;
+      }
+      if (oldVal === newVal) return;
+      data.userInput = null;
+      emit(UPDATE_MODEL_EVENT, newVal);
+      emit(CHANGE_EVENT, newVal, oldVal);
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => error.debugWarn(err));
+      }
+      data.currentValue = newVal;
+    };
+    const handleInput = (value) => {
+      data.userInput = value;
+      const newVal = value === "" ? null : Number(value);
+      emit(INPUT_EVENT, newVal);
+      setCurrentValue(newVal, false);
+    };
+    const handleInputChange = (value) => {
+      const newVal = value !== "" ? Number(value) : "";
+      if (types.isNumber(newVal) && !Number.isNaN(newVal) || value === "") {
+        setCurrentValue(newVal);
+      }
+      setCurrentValueToModelValue();
+      data.userInput = null;
+    };
+    const focus = () => {
+      var _a, _b;
+      (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+    };
+    const blur = () => {
+      var _a, _b;
+      (_b = (_a = input.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
+    };
+    const handleFocus = (event) => {
+      emit("focus", event);
+    };
+    const handleBlur = (event) => {
+      var _a;
+      data.userInput = null;
+      emit("blur", event);
+      if (props.validateEvent) {
+        (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => error.debugWarn(err));
+      }
+    };
+    const setCurrentValueToModelValue = () => {
+      if (data.currentValue !== props.modelValue) {
+        data.currentValue = props.modelValue;
+      }
+    };
+    vue.watch(
+      () => props.modelValue,
+      (value, oldValue) => {
+        const newValue = verifyValue(value, true);
+        if (data.userInput === null && newValue !== oldValue) {
+          data.currentValue = newValue;
+        }
+      },
+      { immediate: true }
+    );
+    vue.watch(
+      () => vm.$i18nHelper.hooks.onLanguageChanged,
+      (value, oldValue) => {
+        key.value++;
+      }
+    );
+    vue.onMounted(() => {
+      var _a;
+      const { min, max, modelValue } = props;
+      const innerInput = (_a = input.value) == null ? void 0 : _a.input;
+      innerInput.setAttribute("role", "spinbutton");
+      if (Number.isFinite(max)) {
+        innerInput.setAttribute("aria-valuemax", String(max));
+      } else {
+        innerInput.removeAttribute("aria-valuemax");
+      }
+      if (Number.isFinite(min)) {
+        innerInput.setAttribute("aria-valuemin", String(min));
+      } else {
+        innerInput.removeAttribute("aria-valuemin");
+      }
+      innerInput.setAttribute(
+        "aria-valuenow",
+        data.currentValue || data.currentValue === 0 ? String(data.currentValue) : ""
+      );
+      innerInput.setAttribute("aria-disabled", String(inputNumberDisabled.value));
+      if (!types.isNumber(modelValue) && modelValue != null) {
+        let val = Number(modelValue);
+        if (Number.isNaN(val)) {
+          val = null;
+        }
+        emit(UPDATE_MODEL_EVENT, val);
+      }
+    });
+    vue.onUpdated(() => {
+      var _a;
+      const innerInput = (_a = input.value) == null ? void 0 : _a.input;
+      innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${data.currentValue ?? ""}`);
+    });
+    __expose({
+      /** @description get focus the input component */
+      focus,
+      /** @description remove focus the input component */
+      blur
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          vue.unref(ns).b(),
+          vue.unref(ns).m(vue.unref(inputNumberSize)),
+          vue.unref(ns).is("disabled", vue.unref(inputNumberDisabled)),
+          vue.unref(ns).is("without-controls", !_ctx.controls),
+          vue.unref(ns).is("controls-right", controlsAtRight.value)
+        ]),
+        onDragstart: _cache[1] || (_cache[1] = vue.withModifiers(() => {
+        }, ["prevent"]))
+      }, [
+        _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+          key: 0,
+          role: "button",
+          "aria-label": vue.unref(t)("el.inputNumber.decrease"),
+          class: vue.normalizeClass([vue.unref(ns).e("decrease"), vue.unref(ns).is("disabled", minDisabled.value)]),
+          onKeydown: vue.withKeys(decrease, ["enter"])
+        }, [
+          vue.createVNode(vue.unref(elementPlus.ElIcon), null, {
+            default: vue.withCtx(() => [
+              controlsAtRight.value ? (vue.openBlock(), vue.createBlock(vue.unref(index$2.ArrowDown), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(index$2.Minus), { key: 1 }))
+            ]),
+            _: 1
+          })
+        ], 42, _hoisted_1)), [
+          [vue.unref(elementPlus.vRepeatClick), decrease]
+        ]) : vue.createCommentVNode("", true),
+        _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+          key: 1,
+          role: "button",
+          "aria-label": vue.unref(t)("el.inputNumber.increase"),
+          class: vue.normalizeClass([vue.unref(ns).e("increase"), vue.unref(ns).is("disabled", maxDisabled.value)]),
+          onKeydown: vue.withKeys(increase, ["enter"])
+        }, [
+          vue.createVNode(vue.unref(elementPlus.ElIcon), null, {
+            default: vue.withCtx(() => [
+              controlsAtRight.value ? (vue.openBlock(), vue.createBlock(vue.unref(index$2.ArrowUp), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(index$2.Plus), { key: 1 }))
+            ]),
+            _: 1
+          })
+        ], 42, _hoisted_2)), [
+          [vue.unref(elementPlus.vRepeatClick), increase]
+        ]) : vue.createCommentVNode("", true),
+        (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElInput), {
+          id: _ctx.id,
+          ref_key: "input",
+          ref: input,
+          key: key.value,
+          step: _ctx.step,
+          "model-value": displayValue.value,
+          formatter: displayFormatter.value,
+          parser: inputParser.value,
+          placeholder: _ctx.placeholder,
+          readonly: _ctx.readonly,
+          disabled: vue.unref(inputNumberDisabled),
+          size: vue.unref(inputNumberSize),
+          max: _ctx.max,
+          min: _ctx.min,
+          name: _ctx.name,
+          label: _ctx.label,
+          "validate-event": false,
+          onWheel: _cache[0] || (_cache[0] = vue.withModifiers(() => {
+          }, ["prevent"])),
+          onKeydown: [
+            vue.withKeys(vue.withModifiers(increase, ["prevent"]), ["up"]),
+            vue.withKeys(vue.withModifiers(decrease, ["prevent"]), ["down"])
+          ],
+          onBlur: handleBlur,
+          onFocus: handleFocus,
+          onInput: handleInput,
+          onChange: handleInputChange
+        }, null, 8, ["id", "step", "model-value", "formatter", "parser", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "label", "onKeydown"]))
+      ], 34);
+    };
+  }
+});
+exports.default = _sfc_main;

package/dist/lib/src/components/InputNumber/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const InputNumber = require("./InputNumber.vue.js");
+exports.default = InputNumber.default;

package/dist/lib/src/components/InputNumber/input-number.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const lodashEs = require("lodash-es");
+const index = require("../../utils/index.js");
+const runtime = require("../../utils/runtime.js");
+const index$1 = require("../../../node_modules/element-plus/es/hooks/use-size/index.js");
+const types = require("../../utils/types.js");
+const inputNumberProps = runtime.buildProps({
+  /**
+   * @description same as `id` in native input
+   */
+  id: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * @description incremental step
+   */
+  step: {
+    type: Number,
+    default: 1
+  },
+  /**
+   * @description whether input value can only be multiple of step
+   */
+  stepStrictly: Boolean,
+  /**
+   * @description the maximum allowed value
+   */
+  max: {
+    type: Number,
+    default: Number.POSITIVE_INFINITY
+  },
+  /**
+   * @description the minimum allowed value
+   */
+  min: {
+    type: Number,
+    default: Number.NEGATIVE_INFINITY
+  },
+  /**
+   * @description binding value
+   */
+  modelValue: {
+    type: [Number, String],
+    default: null
+  },
+  /**
+   * @description same as `readonly` in native input
+   */
+  readonly: Boolean,
+  /**
+   * @description whether the component is disabled
+   */
+  disabled: Boolean,
+  /**
+   * @description size of the component
+   */
+  size: index$1.useSizeProp,
+  /**
+   * @description whether to enable the control buttons
+   */
+  controls: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * @description position of the control buttons
+   */
+  controlsPosition: {
+    type: String,
+    default: "",
+    values: ["", "right"]
+  },
+  /**
+   * @description value should be set when input box is cleared
+   */
+  valueOnClear: {
+    type: [String, Number, null],
+    validator: (val) => val === null || types.isNumber(val) || ["min", "max"].includes(val),
+    default: null
+  },
+  /**
+   * @description same as `name` in native input
+   */
+  name: String,
+  /**
+   * @description same as `label` in native input
+   */
+  label: String,
+  /**
+   * @description same as `placeholder` in native input
+   */
+  placeholder: String,
+  /**
+   * @tagplus default 2
+   * @description precision of input value
+   */
+  precision: {
+    type: Number,
+    default: 2,
+    validator: (val) => val >= 0 && val === Number.parseInt(`${val}`, 10)
+  },
+  /**
+   * @description whether to trigger form validation
+   */
+  validateEvent: {
+    type: Boolean,
+    default: true
+  },
+  /**
+   * @tagplus
+   * Se false permite campo vazio
+   **/
+  stringDefaultsZero: {
+    type: Boolean,
+    default: true
+  }
+});
+const inputNumberEmits = {
+  [index.CHANGE_EVENT]: (cur, prev) => prev !== cur,
+  blur: (e) => e instanceof FocusEvent,
+  focus: (e) => e instanceof FocusEvent,
+  [index.INPUT_EVENT]: (val) => types.isNumber(val) || lodashEs.isNil(val),
+  [index.UPDATE_MODEL_EVENT]: (val) => types.isNumber(val) || lodashEs.isNil(val)
+};
+exports.inputNumberEmits = inputNumberEmits;
+exports.inputNumberProps = inputNumberProps;

package/dist/lib/src/components/Loader/Loader.vue.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+;/* empty css             */
+const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const _sfc_main = vue.defineComponent({
+  name: "TpLoader",
+  props: {
+    // Lista contendo as classes de icones a serem exibidos no loader
+    icons: {
+      type: Array,
+      required: false,
+      default: () => [
+        "fa-solid fa-badge-percent",
+        "fa-solid fa-box-usd",
+        "fa-solid fa-credit-card-front",
+        "fa-solid fa-cart-shopping",
+        "fa-solid fa-gift",
+        "fa-solid fa-dolly-flatbed-alt",
+        "fa-solid fa-receipt",
+        "fa-solid fa-chart-pie-alt",
+        "fa-solid fa-badge-percent",
+        "fa-solid fa-box-usd",
+        "fa-solid fa-credit-card-front",
+        "fa-solid fa-cart-shopping",
+        "fa-solid fa-gift",
+        "fa-solid fa-dolly-flatbed-alt",
+        "fa-solid fa-receipt",
+        "fa-solid fa-chart-pie-alt"
+      ]
+    }
+  }
+});
+const _hoisted_1 = { class: "tp-loader" };
+const _hoisted_2 = { class: "wrapper" };
+const _hoisted_3 = { class: "icones" };
+const _hoisted_4 = { class: "texto" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    vue.createElementVNode("div", _hoisted_2, [
+      _cache[0] || (_cache[0] = vue.createStaticVNode('<svg xmlns="http://www.w3.org/2000/svg" width="150px" height="150px" data-v-719fb911><mask id="mascara" data-v-719fb911><rect x="0" y="0" width="100%" height="100%" fill="white" data-v-719fb911></rect><circle id="circulo-interno" class="circulo" cx="45" cy="50" r="40" fill="black" data-v-719fb911></circle></mask><g id="bola" fill="none" fill-rule="evenodd" transform="translate(30 30)" data-v-719fb911><circle id="circulo" class="circulo" cx="45" cy="50" r="40" fill="#1F7DE7" mask="url(#mascara)" data-v-719fb911></circle><g fill="none" fill-rule="evenodd" data-v-719fb911><circle class="residuo top center" cx="45" cy="9" r="15" fill="#FFCB05" data-v-719fb911></circle><circle class="residuo top right" cx="72" cy="21" r="8.5" fill="#1F7DE7" data-v-719fb911></circle><circle class="residuo middle right" cx="81" cy="45" r="12" fill="#1F7DE7" data-v-719fb911></circle><circle class="residuo bottom right" cx="71" cy="70" r="8.5" fill="none" stroke="#FFCB05" stroke-width="3" data-v-719fb911></circle><circle class="residuo bottom center" cx="45" cy="81" r="8.5" fill="none" stroke="#1F7DE7" stroke-width="3" data-v-719fb911></circle><circle class="residuo bottom left" cx="19" cy="70" r="8.5" fill="#1F7DE7" data-v-719fb911></circle><circle class="residuo middle left" cx="9" cy="45" r="10" fill="#FFCB05" data-v-719fb911></circle><circle class="residuo top left" cx="18" cy="21" r="8.5" fill="none" stroke="#1F7DE7" stroke-width="3" data-v-719fb911></circle></g></g></svg>', 1)),
+      vue.createElementVNode("div", _hoisted_3, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.icons, (icon, k) => {
+          return vue.openBlock(), vue.createElementBlock("i", {
+            key: k,
+            class: vue.normalizeClass(icon),
+            style: vue.normalizeStyle(`--iconsItem:${k}`)
+          }, null, 6);
+        }), 128))
+      ]),
+      vue.createElementVNode("div", _hoisted_4, [
+        vue.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ])
+    ]),
+    _cache[1] || (_cache[1] = vue.createElementVNode("div", { class: "overlay" }, null, -1))
+  ]);
+}
+const Loader = /* @__PURE__ */ _pluginVue_exportHelper.default(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-719fb911"]]);
+exports.default = Loader;

package/dist/lib/src/components/Loader/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Loader = require("./Loader.vue.js");
+exports.default = Loader.default;