@tagplus/components 5.2.18 → 5.3.0

package/dist/es/src/components/Tip/Tip.vue.mjs

@@ -0,0 +1,160 @@
+import { resolveComponent, createBlock, openBlock, normalizeClass, withCtx, createVNode, createElementVNode, toDisplayString, createElementBlock } from "vue";
+/* empty css          */
+import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
+const _sfc_main = {
+  name: "TpTip",
+  props: {
+    id: {
+      type: String,
+      required: false,
+      default: null
+    },
+    text: {
+      type: String,
+      required: true,
+      default: ""
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    type: {
+      type: String,
+      default: "default"
+    }
+  },
+  data() {
+    return {
+      closed: true
+    };
+  },
+  computed: {
+    _id() {
+      return this.id || this.$options.name;
+    },
+    tptipclasses() {
+      const classes = ["grid-content", "pa-3"];
+      if (this.type === "error") {
+        classes.push("tp-tip-error");
+      }
+      if (this.type === "warning") {
+        classes.push("tp-tip-warning");
+      }
+      if (this.type === "success") {
+        classes.push("tp-tip-success");
+      }
+      return classes;
+    }
+  }
+};
+const _hoisted_1 = ["id", "innerHTML"];
+const _hoisted_2 = { class: "tp-title" };
+const _hoisted_3 = ["id", "innerHTML"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_el_col = resolveComponent("el-col");
+  const _component_el_row = resolveComponent("el-row");
+  return !$props.title ? (openBlock(), createBlock(_component_el_row, {
+    key: 0,
+    id: `${$options._id}`,
+    align: "middle",
+    class: normalizeClass([$options.tptipclasses, "text-black"])
+  }, {
+    default: withCtx(() => [
+      createVNode(_component_el_col, {
+        xs: 3,
+        sm: 1,
+        class: "icone"
+      }, {
+        default: withCtx(() => _cache[2] || (_cache[2] = [
+          createElementVNode("em", { class: "far fa-lightbulb-on" }, null, -1)
+        ])),
+        _: 1
+      }),
+      createVNode(_component_el_col, {
+        xs: 21,
+        sm: 23
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            id: `${$options._id}-text`,
+            innerHTML: $props.text
+          }, null, 8, _hoisted_1)
+        ]),
+        _: 1
+      })
+    ]),
+    _: 1
+  }, 8, ["id", "class"])) : (openBlock(), createBlock(_component_el_row, {
+    key: 1,
+    id: `${$options._id}`,
+    align: "middle",
+    justify: "center",
+    class: normalizeClass([$options.tptipclasses, "text-black"])
+  }, {
+    default: withCtx(() => [
+      createVNode(_component_el_col, {
+        xs: 3,
+        sm: 1
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_el_row, { justify: "start" }, {
+            default: withCtx(() => _cache[3] || (_cache[3] = [
+              createElementVNode("em", { class: "far fa-lightbulb-on" }, null, -1)
+            ])),
+            _: 1
+          })
+        ]),
+        _: 1
+      }),
+      createVNode(_component_el_col, {
+        xs: 18,
+        sm: 22
+      }, {
+        default: withCtx(() => [
+          createElementVNode("b", _hoisted_2, toDisplayString($props.title), 1)
+        ]),
+        _: 1
+      }),
+      createVNode(_component_el_col, {
+        xs: 3,
+        sm: 1
+      }, {
+        default: withCtx(() => [
+          createVNode(_component_el_row, { justify: "end" }, {
+            default: withCtx(() => [
+              $data.closed ? (openBlock(), createElementBlock("em", {
+                key: 0,
+                class: "fa fa-plus tp-close-button",
+                onClick: _cache[0] || (_cache[0] = ($event) => $data.closed = !$data.closed)
+              })) : (openBlock(), createElementBlock("em", {
+                key: 1,
+                class: "fa fa-minus tp-close-button",
+                onClick: _cache[1] || (_cache[1] = ($event) => $data.closed = !$data.closed)
+              }))
+            ]),
+            _: 1
+          })
+        ]),
+        _: 1
+      }),
+      createVNode(_component_el_col, {
+        xs: 18,
+        sm: 22,
+        class: normalizeClass("tp-text " + ($data.closed ? "tp-vanish" : ""))
+      }, {
+        default: withCtx(() => [
+          createElementVNode("div", {
+            id: `${$options._id}-text`,
+            innerHTML: $props.text
+          }, null, 8, _hoisted_3)
+        ]),
+        _: 1
+      }, 8, ["class"])
+    ]),
+    _: 1
+  }, 8, ["id", "class"]));
+}
+const Tip = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__scopeId", "data-v-2861430a"]]);
+export {
+  Tip as default
+};

package/dist/es/src/components/Tip/index.mjs

@@ -0,0 +1,4 @@
+import Tip from "./Tip.vue.mjs";
+export {
+  Tip as default
+};

package/dist/es/src/components/index.mjs

@@ -0,0 +1,32 @@
+import { default as default2 } from "./Autosuggest/Autosuggest.vue.mjs";
+import { default as default3 } from "./Inline/Inline.vue.mjs";
+import { default as default4 } from "./Money/Money.vue.mjs";
+import { default as default5 } from "./Percent/Percent.vue.mjs";
+import { default as default6 } from "./OptionsList/OptionsList.vue.mjs";
+import { default as default7 } from "./OptionsListItem/OptionsListItem.vue.mjs";
+import { default as default8 } from "./Loader/Loader.vue.mjs";
+import { default as default9 } from "./Skeleton/Skeleton.vue.mjs";
+import { default as default10 } from "./Tip/Tip.vue.mjs";
+import { default as default11 } from "./Autosuggest/Multisuggest.vue.mjs";
+import { default as default12 } from "./Step/Step.vue.mjs";
+import { default as default13 } from "./Steps/Steps.vue.mjs";
+import { default as default14 } from "./InputNumber/InputNumber.vue.mjs";
+import { ElDialog } from "element-plus";
+ElDialog.name = "TpDialog";
+const Dialog = ElDialog;
+export {
+  default2 as Autosuggest,
+  Dialog,
+  default3 as Inline,
+  default14 as InputNumber,
+  default8 as Loader,
+  default4 as Money,
+  default11 as Multisuggest,
+  default6 as OptionsList,
+  default7 as OptionsListItem,
+  default5 as Percent,
+  default9 as Skeleton,
+  default12 as Step,
+  default13 as Steps,
+  default10 as Tip
+};

package/dist/es/src/locale/i18nCreator.mjs

@@ -0,0 +1,93 @@
+import { createI18n } from "vue-i18n";
+import { reactive } from "vue";
+let i18n;
+const loadedLanguages = [];
+const i18nHelper = {
+  global: false,
+  importLangFile: false,
+  /**
+   * Eventos que podem ser observados com watch
+   */
+  hooks: reactive({
+    onLanguageChanged: ""
+  })
+};
+const importLangFiles = async function(filename) {
+  let langsCustom = {};
+  if (i18nHelper.importLangFile && typeof i18nHelper.importLangFile === "function") {
+    langsCustom = await i18nHelper.importLangFile(filename);
+    if (!(Object.keys(langsCustom).length === 1 && langsCustom.default)) {
+      langsCustom.default = langsCustom;
+    }
+  }
+  return langsCustom;
+};
+i18nHelper.onLanguageSet = function(locale) {
+  throw new Error("Implemente a função onLanguageSet na definição do plugin i18n");
+};
+i18nHelper.setI18nLanguage = function(locale) {
+  if (i18n.mode === "legacy") {
+    i18n.global.locale = locale;
+  } else {
+    i18n.global.locale.value = locale;
+  }
+  i18nHelper.hooks.onLanguageChanged = locale;
+  document.querySelector("html").setAttribute("lang", locale);
+  i18nHelper.onLanguageSet(locale);
+  return locale;
+};
+i18nHelper.loadLanguageAsync = async function(locale) {
+  if (loadedLanguages.includes(locale)) {
+    return locale;
+  }
+  const messages = await importLangFiles(locale);
+  i18n.global.setLocaleMessage(locale, messages.default);
+  loadedLanguages.push(locale);
+  return locale;
+};
+async function setupI18n(options = {}) {
+  if (!i18n) {
+    const locale = options.locale || "pt-br";
+    i18n = createI18n({
+      legacy: false,
+      locale,
+      missing: (locale2, key) => {
+        console.warn(`translation missing: locale=${locale2}, key=${key}`);
+      },
+      ...options
+    });
+    await i18nHelper.loadLanguageAsync(locale);
+    i18nHelper.setI18nLanguage(locale);
+  }
+  return i18n;
+}
+const i18nCreator = async (options = {}, postInstall = (app, options2, i18nHelper2) => {
+}) => {
+  const keys = Object.keys(options).filter((key) => !["i18nHelper", "i18nOptions"].includes(key));
+  if (keys.length) {
+    throw new Error(`Invalid options: ${keys.join(", ")}, expected { i18nOptions, i18nHelper }`);
+  }
+  if (options.i18nHelper && typeof options.i18nHelper.importLangFile === "function") {
+    i18nHelper.importLangFile = options.i18nHelper.importLangFile;
+  }
+  if (options.i18nHelper && typeof options.i18nHelper.onLanguageSet === "function") {
+    i18nHelper.onLanguageSet = options.i18nHelper.onLanguageSet;
+  }
+  let i18nOptions = {};
+  if (options.i18nOptions && typeof options.i18nOptions === "object") {
+    i18nOptions = options.i18nOptions;
+  }
+  i18n = await setupI18n(i18nOptions);
+  i18nHelper.global = i18n.global;
+  return {
+    install: (app, opts) => {
+      i18n.install(app, i18nOptions);
+      if (typeof postInstall === "function") {
+        postInstall(app, options, i18nHelper);
+      }
+    }
+  };
+};
+export {
+  i18nCreator as default
+};

package/dist/es/src/locale/lang/pt-br.mjs

@@ -0,0 +1,21 @@
+const ptbrLocale = {
+  locale: {
+    // locale name equals filename reference
+    name: "pt-br",
+    // IANA.ORG convetions according to W3C
+    prefix: "pt-BR",
+    number: {
+      decimal: ",",
+      thousands: ".",
+      prefix: "",
+      suffix: "",
+      precision: 2
+    },
+    date: {
+      format: "DD/MM/YYYY"
+    }
+  }
+};
+export {
+  ptbrLocale as default
+};

package/dist/es/src/main.mjs

@@ -0,0 +1,17 @@
+import * as index from "./components/index.mjs";
+import Currency from "./plugins/currency.mjs";
+import i18nCreator from "./locale/i18nCreator.mjs";
+const install = function(app) {
+  app.use(Currency);
+  for (const componentName in index) {
+    const component = index[componentName];
+    app.component(component.name, component);
+  }
+};
+if (typeof window !== "undefined" && window.Vue) {
+  install(window.Vue);
+}
+const main = { ...index, install, i18nCreator };
+export {
+  main as default
+};

package/dist/es/src/mixins/floatFormatter.mjs

@@ -0,0 +1,42 @@
+const floatFormatterMixin = {
+  inject: ["formatMoney"],
+  data() {
+    return {
+      formattedValue: this.modelValue
+    };
+  },
+  props: {
+    allowEmpty: {
+      type: Boolean,
+      default: false
+    },
+    customPrecision: {
+      default: false
+    }
+  },
+  watch: {
+    modelValue: {
+      immediate: true,
+      handler(newValue, oldValue) {
+        if (newValue === "" && this.allowEmpty) {
+          this.formattedValue = "";
+          return;
+        }
+        this.formattedValue = this.formatMoney(newValue, true, this.locale, this.customPrecision);
+      }
+    }
+  },
+  methods: {
+    input(evt) {
+      this.formattedValue = this.formatMoney(evt, true, this.locale, this.customPrecision);
+      const moneyFormatado = this.formatMoney(evt, false, this.locale, this.customPrecision);
+      this.$emit("input", moneyFormatado);
+    },
+    handleChange(evt) {
+      this.$emit("change", this.formatMoney(evt, false, this.locale, this.customPrecision));
+    }
+  }
+};
+export {
+  floatFormatterMixin as default
+};

package/dist/es/src/plugins/currency.mjs

@@ -0,0 +1,69 @@
+import ptbrLocale from "../locale/lang/pt-br.mjs";
+let defaults;
+function setDefaults(app) {
+  defaults = app.$i18n ? app.$i18n.t("locale.number") : ptbrLocale.locale;
+}
+function formatMoney(input, toString = false, locale = defaults, customPrecision = false) {
+  var _a, _b;
+  let inputString = `${input}`;
+  if (inputString.slice(-1).match(/[.,]/)) {
+    inputString = inputString.substring(0, inputString.length - 1);
+  }
+  const negative = inputString.indexOf("-") >= 0 ? -1 : 1;
+  if (toString) {
+    input = completeZeros(customPrecision, inputString, locale);
+  }
+  const precision = customPrecision || locale.number.precision;
+  const numbers = onlyNumbers(input);
+  const currency = numbersToCurrency(numbers, precision);
+  if (toString) {
+    let num = negative === -1 ? `-${currency}` : `${currency}`;
+    if ((_a = locale == null ? void 0 : locale.number) == null ? void 0 : _a.decimal) {
+      const decimalChar = (_b = locale == null ? void 0 : locale.number) == null ? void 0 : _b.decimal;
+      num = num.replaceAll(",", decimalChar).replaceAll(".", decimalChar);
+    }
+    return num;
+  }
+  return currency * negative;
+}
+function completeZeros(customPrecision, input, locale) {
+  var _a, _b;
+  const precision = customPrecision || ((_a = locale == null ? void 0 : locale.number) == null ? void 0 : _a.precision) || defaults.precision;
+  const decimal = ((_b = locale == null ? void 0 : locale.number) == null ? void 0 : _b.decimal) || defaults.decimal;
+  let i = input.lastIndexOf(".");
+  const j = input.lastIndexOf(",");
+  i = i > j ? i : j;
+  const qntDecimais = i ? input.length - i - 1 : 0;
+  if (i === -1) {
+    input = input + decimal + "0".repeat(precision);
+  } else if (i && qntDecimais < precision) {
+    input += "0".repeat(precision - qntDecimais);
+  }
+  return input;
+}
+function onlyNumbers(input) {
+  return toStr(input).replace(/\D+/g, "") || "0";
+}
+function fixed(precision = defaults.precision) {
+  return between(0, precision, 20);
+}
+function between(min, n, max) {
+  return Math.max(min, Math.min(n, max));
+}
+function numbersToCurrency(numbers, precision) {
+  const exp = Math.pow(10, precision);
+  const float = parseFloat(numbers) / exp;
+  return float.toFixed(fixed(precision));
+}
+function toStr(value) {
+  return value ? value.toString() : "";
+}
+const Currency = {
+  install: (app, options) => {
+    setDefaults(app);
+    app.provide("formatMoney", formatMoney);
+  }
+};
+export {
+  Currency as default
+};

package/dist/es/src/utils/constants.mjs

@@ -0,0 +1,6 @@
+const formContextKey = Symbol("formContextKey");
+const formItemContextKey = Symbol("formItemContextKey");
+export {
+  formContextKey,
+  formItemContextKey
+};

package/dist/es/src/utils/error.mjs

@@ -0,0 +1,22 @@
+import { isString } from "../../node_modules/@vue/shared/dist/shared.esm-bundler.mjs";
+import "lodash-es";
+import "vue";
+class ElementPlusError extends Error {
+  constructor(m) {
+    super(m);
+    this.name = "ElementPlusError";
+  }
+}
+function throwError(scope, m) {
+  throw new ElementPlusError(`[${scope}] ${m}`);
+}
+function debugWarn(scope, message) {
+  if (process.env.NODE_ENV !== "production") {
+    const error = isString(scope) ? new ElementPlusError(`[${scope}] ${message}`) : scope;
+    console.warn(error);
+  }
+}
+export {
+  debugWarn,
+  throwError
+};

package/dist/es/src/utils/i18n.mjs

@@ -0,0 +1,4 @@
+const isKorean = (text) => /([\uAC00-\uD7AF\u3130-\u318F])+/gi.test(text);
+export {
+  isKorean
+};

package/dist/es/src/utils/icon.mjs

@@ -0,0 +1,9 @@
+import { CircleClose as circle_close_default, CircleCheck as circle_check_default, Loading as loading_default } from "../../node_modules/@element-plus/icons-vue/dist/index.mjs";
+const ValidateComponentsMap = {
+  validating: loading_default,
+  success: circle_check_default,
+  error: circle_close_default
+};
+export {
+  ValidateComponentsMap
+};

package/dist/es/src/utils/index.mjs

@@ -0,0 +1,11 @@
+import "lodash-es";
+import { isVNode } from "vue";
+const UPDATE_MODEL_EVENT = "update:modelValue";
+const CHANGE_EVENT = "change";
+const INPUT_EVENT = "input";
+export {
+  CHANGE_EVENT,
+  INPUT_EVENT,
+  UPDATE_MODEL_EVENT,
+  isVNode
+};

package/dist/es/src/utils/runtime.mjs

@@ -0,0 +1,50 @@
+import { warn } from "vue";
+import { fromPairs } from "lodash-es";
+import { isObject, hasOwn } from "../../node_modules/@vue/shared/dist/shared.esm-bundler.mjs";
+const epPropKey = "__epPropKey";
+const isEpProp = (val) => isObject(val) && !!val[epPropKey];
+const buildProp = (prop, key) => {
+  if (!isObject(prop) || isEpProp(prop)) return prop;
+  const { values, required, default: defaultValue, type, validator } = prop;
+  const _validator = values || validator ? (val) => {
+    let valid = false;
+    let allowedValues = [];
+    if (values) {
+      allowedValues = Array.from(values);
+      if (hasOwn(prop, "default")) {
+        allowedValues.push(defaultValue);
+      }
+      valid || (valid = allowedValues.includes(val));
+    }
+    if (validator) valid || (valid = validator(val));
+    if (!valid && allowedValues.length > 0) {
+      const allowValuesText = [...new Set(allowedValues)].map((value) => JSON.stringify(value)).join(", ");
+      warn(
+        `Invalid prop: validation failed${key ? ` for prop "${key}"` : ""}. Expected one of [${allowValuesText}], got value ${JSON.stringify(
+          val
+        )}.`
+      );
+    }
+    return valid;
+  } : void 0;
+  const epProp = {
+    type,
+    required: !!required,
+    validator: _validator,
+    [epPropKey]: true
+  };
+  if (hasOwn(prop, "default")) epProp.default = defaultValue;
+  return epProp;
+};
+const buildProps = (props) => fromPairs(
+  Object.entries(props).map(([key, option]) => [
+    key,
+    buildProp(option, key)
+  ])
+);
+export {
+  buildProp,
+  buildProps,
+  epPropKey,
+  isEpProp
+};

package/dist/es/src/utils/scroll.mjs

@@ -0,0 +1,28 @@
+import "lodash-es";
+import "vue";
+import { isClient } from "../../node_modules/@vueuse/shared/index.mjs";
+function scrollIntoView(container, selected) {
+  if (!isClient) return;
+  if (!selected) {
+    container.scrollTop = 0;
+    return;
+  }
+  const offsetParents = [];
+  let pointer = selected.offsetParent;
+  while (pointer !== null && container !== pointer && container.contains(pointer)) {
+    offsetParents.push(pointer);
+    pointer = pointer.offsetParent;
+  }
+  const top = selected.offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
+  const bottom = top + selected.offsetHeight;
+  const viewRectTop = container.scrollTop;
+  const viewRectBottom = viewRectTop + container.clientHeight;
+  if (top < viewRectTop) {
+    container.scrollTop = top;
+  } else if (bottom > viewRectBottom) {
+    container.scrollTop = bottom - container.clientHeight;
+  }
+}
+export {
+  scrollIntoView
+};

package/dist/es/src/utils/strings.mjs

@@ -0,0 +1,4 @@
+const escapeStringRegexp = (string = "") => string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+export {
+  escapeStringRegexp
+};

package/dist/es/src/utils/types.mjs

@@ -0,0 +1,9 @@
+import "lodash-es";
+import { isVNode } from "vue";
+const isUndefined = (val) => val === void 0;
+const isNumber = (val) => typeof val === "number";
+export {
+  isNumber,
+  isUndefined,
+  isVNode
+};

package/dist/es/src/utils/use-derived-namespace.mjs

@@ -0,0 +1,15 @@
+import { getCurrentInstance, inject, ref, computed, unref } from "vue";
+const defaultNamespace = "el";
+const namespaceContextKey = Symbol("namespaceContextKey");
+const useGetDerivedNamespace = (namespaceOverrides) => {
+  const derivedNamespace = getCurrentInstance() ? inject(namespaceContextKey, ref(defaultNamespace)) : ref(defaultNamespace);
+  const namespace = computed(() => {
+    return unref(derivedNamespace) || defaultNamespace;
+  });
+  return namespace;
+};
+export {
+  defaultNamespace,
+  namespaceContextKey,
+  useGetDerivedNamespace
+};

package/dist/es/src/utils/use-form-common-props.mjs

@@ -0,0 +1,25 @@
+import { ref, inject, computed, unref } from "vue";
+import { formContextKey, formItemContextKey } from "./constants.mjs";
+import { useProp } from "../../node_modules/element-plus/es/hooks/use-prop/index.mjs";
+import { useGlobalSize } from "../../node_modules/element-plus/es/hooks/use-size/index.mjs";
+const useFormSize = (fallback, ignore = {}) => {
+  const emptyRef = ref(void 0);
+  const size = ignore.prop ? emptyRef : useProp("size");
+  const globalConfig = ignore.global ? emptyRef : useGlobalSize();
+  const form = ignore.form ? { size: void 0 } : inject(formContextKey, void 0);
+  const formItem = ignore.formItem ? { size: void 0 } : inject(formItemContextKey, void 0);
+  return computed(
+    () => size.value || unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig.value || ""
+  );
+};
+const useFormDisabled = (fallback) => {
+  const disabled = useProp("disabled");
+  const form = inject(formContextKey, void 0);
+  return computed(
+    () => disabled.value || unref(fallback) || (form == null ? void 0 : form.disabled) || false
+  );
+};
+export {
+  useFormDisabled,
+  useFormSize
+};