@gct-paas/core-web 0.1.4-dev.1 → 0.1.4-dev.11

package/es/components/double-input/double-input.vue.mjs

@@ -0,0 +1,158 @@
+import { defineComponent, ref, computed, resolveComponent, openBlock, createBlock, mergeProps, createSlots, withCtx, renderSlot, resolveDynamicComponent, createCommentVNode } from 'vue';
+import { isNil } from 'lodash-es';
+import { BigNumber } from 'bignumber.js';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "double-input",
+  props: {
+    doubleValue: {},
+    isSeparator: { type: Boolean },
+    onEnter: {},
+    renderScript: {},
+    digits: {},
+    enableStepCounter: { type: Boolean }
+  },
+  emits: ["update:doubleValue"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const inputAttr = ref({});
+    const inputNumberRef = ref();
+    const inputValue = computed({
+      get() {
+        const { val, precision } = getFormatterValue(props.doubleValue);
+        setInputAttr(precision);
+        return val;
+      },
+      set(value) {
+        emit("update:doubleValue", value);
+      }
+    });
+    const countDecimals = (num) => {
+      const str = String(num);
+      const match = str.match(/\.(\d+)/);
+      return match ? match[1].length : 0;
+    };
+    const formatterValue = (inputValue2) => {
+      let value = inputValue2?.toString();
+      if (props.isSeparator && value) {
+        value = value.replace(/\$\s?|(,*)/g, "");
+      }
+      const currentValue = parseFloat(value);
+      if (isNaN(currentValue)) {
+        return {
+          val: null
+        };
+      }
+      if (value.toString().indexOf(".") === 0) {
+        value = `0${value}`;
+      }
+      if (Number.isInteger(currentValue)) {
+        const reg = new RegExp(`^${currentValue}(\\.)`, "g");
+        if (reg.test(value)) {
+          const firstVal = value.replace(
+            new RegExp(`^(${currentValue}(\\.))(.*)`),
+            "$1"
+          );
+          if (firstVal === `${currentValue}.`) {
+            const otherVal = value.replace(reg, "");
+            let dIndex = otherVal.toString().indexOf(".");
+            if (dIndex === 0) {
+              return {
+                val: currentValue
+              };
+            }
+            if (parseFloat(otherVal) === 0) {
+              const decimalValue = otherVal.toString().replace(new RegExp(`^(\\d*)(.*)`), "$1");
+              return {
+                val: `${currentValue}.${decimalValue}`,
+                precision: decimalValue.length
+              };
+            }
+          }
+        }
+        return {
+          val: currentValue
+        };
+      } else {
+        const _val = value.replace(new RegExp(`^(\\d*\\.\\d*)(.*)`), "$1");
+        if (_val === currentValue.toString()) {
+          return {
+            val: _val
+          };
+        }
+        return {
+          val: _val,
+          precision: countDecimals(_val)
+        };
+      }
+    };
+    const getFormatterValue = (inputValue2) => {
+      const res = formatterValue(inputValue2);
+      if (isNil(props.digits)) {
+        return res;
+      }
+      const { val, precision } = res;
+      return {
+        val: val ? Number(new BigNumber(val).toFixed(props.digits, 1)) : val,
+        precision
+      };
+    };
+    const setInputAttr = (precision) => {
+      inputAttr.value = {};
+      if (precision !== void 0 && isNil(props.digits)) {
+        inputAttr.value = {
+          precision
+        };
+      }
+    };
+    const onChangeValue = (event) => {
+      const {
+        target: { value: inputValue2 }
+      } = event || {};
+      const { val, precision } = getFormatterValue(inputValue2);
+      setInputAttr(precision);
+      emit("update:doubleValue", val);
+    };
+    const onPressEnter = (event) => {
+      onChangeValue(event);
+      if (props.onEnter && typeof props.onEnter === "function") {
+        props.onEnter?.(event);
+      }
+    };
+    __expose({
+      input: inputNumberRef,
+      onChangeValue
+    });
+    return (_ctx, _cache) => {
+      const _component_a_input_number = resolveComponent("a-input-number");
+      return openBlock(), createBlock(_component_a_input_number, mergeProps({
+        ref_key: "inputNumberRef",
+        ref: inputNumberRef
+      }, inputAttr.value, {
+        value: inputValue.value,
+        "onUpdate:value": _cache[0] || (_cache[0] = ($event) => inputValue.value = $event),
+        onBlur: onChangeValue,
+        onPressEnter
+      }), createSlots({ _: 2 }, [
+        __props.enableStepCounter ? {
+          name: "addonBefore",
+          fn: withCtx(() => [
+            renderSlot(_ctx.$slots, "step-down")
+          ]),
+          key: "0"
+        } : void 0,
+        __props.enableStepCounter || __props.renderScript ? {
+          name: "addonAfter",
+          fn: withCtx(() => [
+            __props.renderScript ? (openBlock(), createBlock(resolveDynamicComponent(__props.renderScript), { key: 0 })) : createCommentVNode("", true),
+            __props.enableStepCounter ? renderSlot(_ctx.$slots, "step-up", { key: 1 }) : createCommentVNode("", true)
+          ]),
+          key: "1"
+        } : void 0
+      ]), 1040, ["value"]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/components/double-input/double-input.vue2.mjs

@@ -0,0 +1,5 @@
+import _sfc_main from './double-input.vue.mjs';
+
+
+
+export { _sfc_main as default };

package/es/components/icon-next/data/icons.data.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    prefix: string;
+    icons: string[];
+};
+export default _default;

package/es/components/icon-next/hooks/useIconAsset.d.ts

@@ -0,0 +1,16 @@
+export declare function useIconAsset(): {
+    getIconAssetCats: () => Promise<{
+        id: string;
+        name: string;
+        children: {
+            id: string;
+            name: string;
+            icons?: {
+                id: string;
+                name: string;
+                _filter_: string[];
+            }[] | undefined;
+            children?: /*elided*/ any[] | undefined;
+        }[];
+    }[]>;
+};

package/es/components/icon-next/hooks/useIconAsset.mjs

@@ -0,0 +1,48 @@
+import { ref, computed } from 'vue';
+import { IconNamespaceEnum } from '../types/index.mjs';
+
+const iconAssetIcons = ref([]);
+const iconParkCats = computed(() => {
+  return [
+    {
+      id: "IconAsset",
+      name: "资产图标",
+      children: iconAssetIcons.value
+    }
+  ].filter((i) => i.children?.length);
+});
+function useIconAsset() {
+  async function getIconAssetCats() {
+    if (iconAssetIcons.value.length > 0) {
+      return iconParkCats.value;
+    }
+    const params = {
+      assetsModule: "ICON"
+    };
+    const result = await Promise.all([
+      _api.platform.category.getList(params),
+      _api.platform.assets.getList(params)
+    ]).then(([catRes, iconRes]) => {
+      return catRes?.map((c) => {
+        return {
+          id: `${c.id}`,
+          name: c.name,
+          icons: iconRes?.filter((i) => i.categoryId === c.id).map((item) => {
+            Object.assign(item, {
+              id: `${IconNamespaceEnum.Asset}:${item.path}`,
+              _filter_: [item.name]
+            });
+            return item;
+          })
+        };
+      }).filter((i) => i.icons?.length);
+    });
+    iconAssetIcons.value = result;
+    return iconParkCats.value;
+  }
+  return {
+    getIconAssetCats
+  };
+}
+
+export { useIconAsset };

package/es/components/icon-next/hooks/useIconPark.d.ts

@@ -0,0 +1,16 @@
+export declare function useIconPark(): {
+    getIconParkCats: () => {
+        id: string;
+        name: string;
+        children: {
+            id: string;
+            name: string;
+            icons?: {
+                id: string;
+                name: string;
+                _filter_: string[];
+            }[] | undefined;
+            children?: /*elided*/ any[] | undefined;
+        }[];
+    }[];
+};

package/es/components/icon-next/hooks/useIconPark.mjs

@@ -0,0 +1,52 @@
+import { ref, computed } from 'vue';
+import IconParkJson from '@icon-park/vue-next/icons.json';
+import { IconNamespaceEnum } from '../types/index.mjs';
+
+const iconParkIcons = ref([]);
+const iconParkCats = computed(() => {
+  return [
+    {
+      id: "IconPark",
+      name: "IconPark",
+      children: iconParkIcons.value
+    }
+  ];
+});
+function useIconPark() {
+  function getIconParkCats() {
+    if (iconParkIcons.value.length > 0) {
+      return iconParkCats.value;
+    }
+    const cats = [];
+    IconParkJson.forEach((item) => {
+      const icon = {
+        ...item,
+        id: `${IconNamespaceEnum.IconPark}:${item.name}`,
+        _filter_: [...item.tag, item.title, item.name]
+      };
+      let category = cats.find((c) => c.id === icon.category);
+      if (category) {
+        category.icons.push(icon);
+      } else {
+        category = {
+          id: icon.category,
+          name: icon.categoryCN,
+          icons: [icon]
+        };
+        cats.push(category);
+      }
+    });
+    const base = cats.filter((c) => c.id === "Base" /* Base */);
+    const others = cats.filter((c) => c.id === "Others" /* Others */);
+    const middle = cats.filter(
+      (c) => !["Base" /* Base */, "Others" /* Others */].includes(c.id)
+    );
+    iconParkIcons.value = base.concat(middle, others);
+    return iconParkCats.value;
+  }
+  return {
+    getIconParkCats
+  };
+}
+
+export { useIconPark };

package/es/components/icon-next/hooks/useIconPlatform.d.ts

@@ -0,0 +1,8 @@
+import { ICategory } from '../types';
+export declare function useIconPlatform(): {
+    getIconPlatformCats: () => {
+        id: string;
+        name: string;
+        icons: ICategory[];
+    }[];
+};

package/es/components/icon-next/hooks/useIconPlatform.mjs

@@ -0,0 +1,48 @@
+import { computed } from 'vue';
+import { IconNamespaceEnum } from '../types/index.mjs';
+import { iconsNames } from '@gct-paas/platform-icons';
+
+const iconPlatformCats = computed(() => {
+  return [
+    {
+      id: "medicalCare",
+      name: "医疗器械",
+      icons: medicalCareIcons.value
+    },
+    {
+      id: "IconPlatform",
+      name: "平台图标",
+      icons: platformIcons.value
+    }
+  ];
+});
+const platformIcons = computed(() => {
+  const icons = iconsNames.filter((e) => /^(icon-platform)/.test(e)).map((e) => {
+    const iconName = e.replace(/icon-/g, "");
+    return {
+      id: `${IconNamespaceEnum.Platform}:${iconName}`,
+      name: iconName,
+      _filter_: [iconName]
+    };
+  });
+  return icons;
+});
+const medicalCareIcons = computed(() => {
+  const icons = iconsNames.filter((e) => /^(icon-medicalCare)/.test(e)).map((e) => {
+    const iconName = e.replace(/icon-/g, "");
+    return {
+      id: `${IconNamespaceEnum.Platform}:${iconName}`,
+      name: e.replace(/icon-medicalCare-/g, ""),
+      _filter_: [iconName]
+    };
+  });
+  return icons;
+});
+function useIconPlatform() {
+  function getIconPlatformCats() {
+    return iconPlatformCats.value;
+  }
+  return { getIconPlatformCats };
+}
+
+export { useIconPlatform };

package/es/components/icon-next/index.d.ts

@@ -0,0 +1,3 @@
+import { default as IconNext } from './src/IconNext.vue';
+import { default as IconNextPicker } from './src/IconNextPicker.vue';
+export { IconNext, IconNextPicker };

package/es/components/icon-next/src/IconNext.css

@@ -0,0 +1,18 @@
+.icon-next[data-v-c5a83130] {
+  display: inline-flex;
+  align-items: center;
+  color: var(--color);
+  background-color: var(--bg-color);
+  transition: all 0.3s;
+}
+.icon-next > svg[data-v-c5a83130] {
+  transform: translateY(1px);
+}
+i.icon-next[data-v-c5a83130] {
+  height: var(--size);
+  width: var(--size);
+  background-image: var(--bg-image);
+  background-size: contain;
+  background-position: center;
+  background-repeat: no-repeat;
+}

package/es/components/icon-next/src/IconNext.vue.d.ts

@@ -0,0 +1,40 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    background: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    background: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    size: number;
+    background: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/es/components/icon-next/src/IconNext.vue2.mjs

@@ -0,0 +1,7 @@
+import _sfc_main from './IconNext.vue3.mjs';
+import './IconNext.css';/* empty css              */
+import _export_sfc from '../../../_virtual/_plugin-vue_export-helper.mjs';
+
+const IconNext = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-c5a83130"]]);
+
+export { IconNext as default };

package/es/components/icon-next/src/IconNext.vue3.mjs

@@ -0,0 +1,108 @@
+import { defineComponent, computed, unref, openBlock, createBlock, normalizeStyle, createElementBlock, normalizeClass } from 'vue';
+import { IconNamespaceEnum } from '../types/index.mjs';
+import { IconPark } from '@icon-park/vue-next/es/all';
+import _sfc_main$1 from '../../svg-icon/svg-icon.vue.mjs';
+import '../../svg-icon/svg-icon.css';/* empty css                            */
+import { VITE_MINIO_PATH } from '@gct-paas/core';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "IconNext",
+  props: {
+    value: {
+      type: String,
+      required: true
+    },
+    color: {
+      type: String,
+      default: "#FFFFFF"
+    },
+    background: {
+      type: String,
+      default: "transparent"
+    },
+    size: {
+      type: Number,
+      default: 24
+    }
+  },
+  setup(__props) {
+    function fileUrlParser(url) {
+      if (!url) {
+        return url;
+      }
+      return `${VITE_MINIO_PATH}${url.startsWith("/") ? "" : "/"}${url}`;
+    }
+    const props = __props;
+    const namespace = computed(() => {
+      const value = props.value;
+      if (!value) return void 0;
+      if (value.includes(":")) {
+        return value.split(":")[0];
+      } else if (value.startsWith("preset-")) {
+        return IconNamespaceEnum.Preset;
+      }
+      return void 0;
+    });
+    const iconName = computed(() => {
+      const value = props.value;
+      if (!value) return void 0;
+      if (value.includes(":")) {
+        return value.split(":")[1];
+      }
+      return props.value;
+    });
+    const iconBgImage = computed(() => {
+      return `url('${fileUrlParser(iconName.value)}')`;
+    });
+    return (_ctx, _cache) => {
+      return namespace.value === unref(IconNamespaceEnum).IconPark ? (openBlock(), createBlock(unref(IconPark), {
+        key: `${iconName.value}-${__props.size}`,
+        type: iconName.value,
+        style: normalizeStyle({
+          "--color": __props.color,
+          "--bg-color": __props.background
+        }),
+        class: "icon-next",
+        size: __props.size
+      }, null, 8, ["type", "style", "size"])) : namespace.value === unref(IconNamespaceEnum).Preset || namespace.value === unref(IconNamespaceEnum).Platform ? (openBlock(), createBlock(_sfc_main$1, {
+        key: 1,
+        name: iconName.value,
+        style: normalizeStyle({
+          "--color": __props.color,
+          "--bg-color": __props.background
+        }),
+        class: "icon-next",
+        size: __props.size
+      }, null, 8, ["name", "style", "size"])) : namespace.value === unref(IconNamespaceEnum).Asset ? (openBlock(), createElementBlock("i", {
+        key: 2,
+        class: "icon-next",
+        style: normalizeStyle({
+          "--size": __props.size + "px",
+          "--bg-image": iconBgImage.value
+        })
+      }, null, 4)) : namespace.value === unref(IconNamespaceEnum).GctIconFont ? (openBlock(), createElementBlock("i", {
+        key: 3,
+        class: normalizeClass([`gct-iconfont ${iconName.value}`, "icon-next"]),
+        style: normalizeStyle({
+          fontSize: __props.size + "px",
+          lineHeight: 1,
+          "--color": __props.color,
+          "--bg-color": __props.background,
+          "--size": __props.size + "px"
+        })
+      }, null, 6)) : (openBlock(), createElementBlock("i", {
+        key: 4,
+        class: normalizeClass([`iconfont ${iconName.value}`, "icon-next"]),
+        style: normalizeStyle({
+          fontSize: __props.size + "px",
+          lineHeight: 1,
+          "--color": __props.color,
+          "--bg-color": __props.background,
+          "--size": __props.size + "px"
+        })
+      }, null, 6));
+    };
+  }
+});
+
+export { _sfc_main as default };