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

package/es/components/assets-svg-icon/request.mjs

@@ -0,0 +1,51 @@
+import { isSvgDataUrl, isEncodedDataUrl, validateContent } from './validate.mjs';
+
+const ioniconContent = /* @__PURE__ */ new Map();
+const requests = /* @__PURE__ */ new Map();
+let parser;
+function safeFallback(url) {
+  const svg = "";
+  ioniconContent.set(url, svg);
+  return svg;
+}
+const getSvgContent = (url, sanitize) => {
+  const req = requests.get(url);
+  if (req) {
+    return req;
+  }
+  if (typeof fetch !== "undefined" && typeof document !== "undefined") {
+    if (isSvgDataUrl(url) && isEncodedDataUrl(url)) {
+      return Promise.resolve(getSvgByUrl(url));
+    }
+    return fetchSvg(url, sanitize);
+  }
+  return Promise.resolve(safeFallback(url));
+};
+function getSvgByUrl(url) {
+  if (!parser) {
+    parser = new DOMParser();
+  }
+  const doc = parser.parseFromString(url, "text/html");
+  const svg = doc.querySelector("svg");
+  if (svg) {
+    ioniconContent.set(url, svg.outerHTML);
+    return svg.outerHTML;
+  }
+  throw new Error(`Could not parse svg from ${url}`);
+}
+function fetchSvg(url, sanitize) {
+  const req = fetch(url).then((rsp) => {
+    return rsp.text().then((svgContent) => {
+      if (svgContent && sanitize !== false) {
+        svgContent = validateContent(svgContent);
+      }
+      const svg = svgContent || "";
+      ioniconContent.set(url, svg);
+      return svg;
+    }).catch(() => safeFallback(url));
+  }).catch(() => safeFallback(url));
+  requests.set(url, req);
+  return req;
+}
+
+export { getSvgContent, ioniconContent };

package/es/components/assets-svg-icon/utils.d.ts

@@ -0,0 +1,9 @@
+export declare const isStr: (val: any) => val is string;
+export declare const isSrc: (str: string) => boolean;
+export declare const getSrc: (src: string | undefined) => string | null;
+/**
+ * Returns `true` if the document or host element
+ * has a `dir` set to `rtl`. The host value will always
+ * take priority over the root document value.
+ */
+export declare const isRTL: (hostEl?: Pick<HTMLElement, "dir">) => boolean;

package/es/components/assets-svg-icon/utils.mjs

@@ -0,0 +1,21 @@
+const isStr = (val) => typeof val === "string";
+const isSrc = (str) => str.length > 0 && /(\/|\.)/.test(str);
+const getSrc = (src) => {
+  if (isStr(src)) {
+    src = src.trim();
+    if (isSrc(src)) {
+      return src;
+    }
+  }
+  return null;
+};
+const isRTL = (hostEl) => {
+  if (hostEl) {
+    if (hostEl.dir !== "") {
+      return hostEl.dir.toLowerCase() === "rtl";
+    }
+  }
+  return document?.dir.toLowerCase() === "rtl";
+};
+
+export { getSrc, isRTL, isSrc, isStr };

package/es/components/assets-svg-icon/validate.d.ts

@@ -0,0 +1,4 @@
+export declare const validateContent: (svgContent: string) => string;
+export declare const isValid: (elm: HTMLElement) => boolean;
+export declare const isSvgDataUrl: (url: string) => boolean;
+export declare const isEncodedDataUrl: (url: string) => boolean;

package/es/components/assets-svg-icon/validate.mjs

@@ -0,0 +1,43 @@
+import { isStr } from './utils.mjs';
+
+const validateContent = (svgContent) => {
+  const div = document.createElement("div");
+  div.innerHTML = svgContent;
+  for (let i = div.childNodes.length - 1; i >= 0; i--) {
+    if (div.childNodes[i].nodeName.toLowerCase() !== "svg") {
+      div.removeChild(div.childNodes[i]);
+    }
+  }
+  const svgElm = div.firstElementChild;
+  if (svgElm && svgElm.nodeName.toLowerCase() === "svg") {
+    const svgClass = svgElm.getAttribute("class") || "";
+    svgElm.setAttribute("class", (svgClass + " s-ion-icon").trim());
+    if (isValid(svgElm)) {
+      return div.innerHTML;
+    }
+  }
+  return "";
+};
+const isValid = (elm) => {
+  if (elm.nodeType === 1) {
+    if (elm.nodeName.toLowerCase() === "script") {
+      return false;
+    }
+    for (let i = 0; i < elm.attributes.length; i++) {
+      const name = elm.attributes[i].name;
+      if (isStr(name) && name.toLowerCase().indexOf("on") === 0) {
+        return false;
+      }
+    }
+    for (let i = 0; i < elm.childNodes.length; i++) {
+      if (!isValid(elm.childNodes[i])) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+const isSvgDataUrl = (url) => url.startsWith("data:image/svg+xml");
+const isEncodedDataUrl = (url) => url.indexOf(";utf8,") !== -1;
+
+export { isEncodedDataUrl, isSvgDataUrl, isValid, validateContent };

package/es/components/base-button/base-button.css

@@ -0,0 +1,74 @@
+.ant-btn[data-v-5375ec2b] {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.ant-btn.btn-font-color[data-v-5375ec2b] {
+  color: var(--v8d035854) !important;
+}
+.ant-btn.btn-bg-style[data-v-5375ec2b] {
+  border-color: var(--e376d652) !important;
+  background: var(--v4ee5fd6d) !important;
+}
+.square[data-v-5375ec2b] {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  width: 72px;
+  height: 72px;
+  padding: 0;
+  border-radius: 4px;
+}
+.square .icon-next[data-v-5375ec2b] {
+  margin: 0 !important;
+}
+.square .btn-title[data-v-5375ec2b] {
+  width: inherit;
+  padding: 0 8px;
+}
+.square.ant-btn-sm[data-v-5375ec2b] {
+  width: 72px;
+  height: 64px;
+  font-size: 14px;
+}
+.square.ant-btn-sm .btn-title[data-v-5375ec2b] {
+  padding: 0 4px;
+}
+.square.ant-btn-lg[data-v-5375ec2b] {
+  width: 80px;
+  height: 88px;
+}
+.squaref[data-v-5375ec2b] {
+  min-width: 72px;
+  height: 56px;
+  padding: 0;
+}
+.line[data-v-5375ec2b] {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+[data-v-5375ec2b] .group .ant-btn {
+  height: 100%;
+}
+[data-v-5375ec2b] .ant-btn-loading-icon {
+  width: 0;
+  height: 0;
+  line-height: 0;
+}
+[data-v-5375ec2b] .ant-btn-icon-only {
+  vertical-align: -2px;
+}
+.gct-text-overflow-2[data-v-5375ec2b] {
+  display: -webkit-inline-box;
+  display: -moz-inline-box;
+  display: inline-flexbox;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  -webkit-line-clamp: 2;
+  line-clamp: 2;
+  -webkit-box-orient: vertical;
+  -moz-box-orient: vertical;
+  box-orient: 2;
+}

package/es/components/base-button/base-button.vue.d.ts

@@ -0,0 +1,173 @@
+import { PropType } from 'vue';
+import { ButtonSize, ButtonStyle } from '@gct-paas/core';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: PropType<ButtonSize>;
+        default: string;
+    };
+    icon: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    hasIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    danger: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    buttonStyle: {
+        type: PropType<ButtonStyle>;
+        default: string;
+    };
+    i18nConfig: {
+        type: StringConstructor;
+        default: string;
+    };
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    confirm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    confirmText: {
+        type: StringConstructor;
+        default: string;
+    };
+    enableCustomColor: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fontColor: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    block: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: PropType<ButtonSize>;
+        default: string;
+    };
+    icon: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    hasIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    danger: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    buttonStyle: {
+        type: PropType<ButtonStyle>;
+        default: string;
+    };
+    i18nConfig: {
+        type: StringConstructor;
+        default: string;
+    };
+    hidden: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    confirm: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    confirmText: {
+        type: StringConstructor;
+        default: string;
+    };
+    enableCustomColor: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    backgroundColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fontColor: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    hidden: boolean;
+    size: ButtonSize;
+    type: string;
+    title: string;
+    icon: string;
+    disabled: boolean;
+    loading: boolean;
+    block: boolean;
+    hasIcon: boolean;
+    hasText: boolean;
+    danger: boolean;
+    buttonStyle: ButtonStyle;
+    i18nConfig: string;
+    confirm: boolean;
+    confirmText: string;
+    enableCustomColor: boolean;
+    backgroundColor: string;
+    fontColor: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+export default _default;

package/es/components/base-button/base-button.vue.mjs

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

package/es/components/base-button/base-button.vue3.mjs

@@ -0,0 +1,179 @@
+import { defineComponent, useCssVars, computed, resolveComponent, openBlock, createElementBlock, createVNode, normalizeClass, unref, withCtx, toDisplayString, createCommentVNode, createBlock, normalizeStyle } from 'vue';
+import { Modal } from 'ant-design-vue';
+import { debounce } from 'lodash-es';
+import { ButtonStyle, ButtonSize, t } from '@gct-paas/core';
+
+const _hoisted_1 = { class: "inline-block align-middle" };
+const _hoisted_2 = {
+  key: 0,
+  class: "btn-title gct-text-overflow whitespace-nowrap"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "base-button",
+  props: {
+    block: {
+      type: Boolean,
+      default: false
+    },
+    disabled: {
+      type: Boolean,
+      default: false
+    },
+    loading: {
+      type: Boolean,
+      default: false
+    },
+    title: {
+      type: String,
+      default: ""
+    },
+    size: {
+      type: String,
+      default: "default"
+    },
+    icon: {
+      type: String,
+      default: ""
+    },
+    type: {
+      type: String,
+      default: ""
+    },
+    hasIcon: {
+      type: Boolean,
+      default: false
+    },
+    hasText: {
+      type: Boolean,
+      default: true
+    },
+    danger: {
+      type: Boolean,
+      default: false
+    },
+    buttonStyle: {
+      type: String,
+      default: ""
+    },
+    i18nConfig: {
+      type: String,
+      default: ""
+    },
+    hidden: {
+      type: Boolean,
+      default: false
+    },
+    confirm: {
+      type: Boolean,
+      default: false
+    },
+    confirmText: {
+      type: String,
+      default: ""
+    },
+    enableCustomColor: {
+      type: Boolean,
+      default: false
+    },
+    backgroundColor: {
+      type: String,
+      default: ""
+    },
+    fontColor: {
+      type: String,
+      default: ""
+    }
+  },
+  emits: ["click"],
+  setup(__props, { emit: __emit }) {
+    useCssVars((_ctx) => ({
+      "v8d035854": props.fontColor,
+      "e376d652": props.backgroundColor,
+      "v4ee5fd6d": props.type === "primary" ? props.backgroundColor : "transparent"
+    }));
+    const props = __props;
+    const emit = __emit;
+    const getVertivalAlign = computed(() => {
+      if (!props.hasText) return "text-top";
+      else return "text-top";
+    });
+    const debonceClick = debounce(function() {
+      emit("click");
+    }, 300);
+    const clickEvent = async (evt) => {
+      const isAppRun = /\/web-render|\/web\/|web-single\/|dev-single\/|test-single\//.test(
+        location.pathname
+      );
+      let target = evt.target;
+      if (target.nodeName == "SPAN") {
+        target = target.parentNode;
+      }
+      target.blur();
+      if (props.confirm && isAppRun) {
+        await new Promise((res, rej) => {
+          Modal.confirm({
+            content: props.confirmText || t("sys.pageDesigner.confirmTodo"),
+            onOk() {
+              res("onOk");
+            },
+            onCancel() {
+              rej("onCancel");
+            }
+          });
+        });
+        emit("click");
+        return;
+      }
+      debonceClick();
+    };
+    return (_ctx, _cache) => {
+      const _component_IconNext = resolveComponent("IconNext");
+      const _component_a_button = resolveComponent("a-button");
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createVNode(_component_a_button, {
+          size: __props.size,
+          type: __props.type,
+          danger: __props.danger,
+          loading: __props.loading,
+          block: __props.block,
+          disabled: __props.disabled,
+          class: normalizeClass([
+            __props.enableCustomColor && __props.fontColor ? "btn-font-color" : "",
+            __props.enableCustomColor && __props.backgroundColor ? "btn-bg-style" : "",
+            { square: __props.buttonStyle === unref(ButtonStyle).SQUARE }
+          ]),
+          title: __props.title,
+          onClick: clickEvent
+        }, {
+          icon: withCtx(() => [
+            __props.hasIcon ? (openBlock(), createBlock(_component_IconNext, {
+              key: 0,
+              size: __props.buttonStyle === unref(ButtonStyle).SQUARE ? 20 : 16,
+              value: __props.icon,
+              style: normalizeStyle({
+                "--color": "inherit",
+                lineHeight: "1",
+                verticalAlign: getVertivalAlign.value
+              })
+            }, null, 8, ["size", "value", "style"])) : createCommentVNode("", true),
+            __props.icon && __props.hasText ? (openBlock(), createElementBlock("div", {
+              key: 1,
+              class: normalizeClass({
+                "h-6px": __props.hasIcon && __props.hasText && __props.buttonStyle === unref(ButtonStyle).SQUARE && __props.size !== unref(ButtonSize).SMALL,
+                "h-4px": __props.hasIcon && __props.hasText && __props.buttonStyle === unref(ButtonStyle).SQUARE && __props.size === unref(ButtonSize).SMALL,
+                "w-6px": __props.hasIcon && __props.hasText && __props.buttonStyle === unref(ButtonStyle).ORDINARY && __props.size !== unref(ButtonSize).SMALL,
+                "w-4px": __props.hasIcon && __props.hasText && __props.buttonStyle === unref(ButtonStyle).ORDINARY && __props.size === unref(ButtonSize).SMALL
+              })
+            }, null, 2)) : createCommentVNode("", true)
+          ]),
+          default: withCtx(() => [
+            __props.hasText ? (openBlock(), createElementBlock("span", _hoisted_2, toDisplayString(__props.hasText ? __props.title : ""), 1)) : createCommentVNode("", true)
+          ]),
+          _: 1
+        }, 8, ["size", "type", "danger", "loading", "block", "disabled", "class", "title"])
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/components/basic-button/basic-button.css

@@ -0,0 +1,25 @@
+.square[data-v-1dbcb2fa] {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-width: 72px;
+  height: 72px;
+  padding: 0;
+}
+.squaref[data-v-1dbcb2fa] {
+  min-width: 72px;
+  height: 72px;
+  padding: 0;
+}
+.line[data-v-1dbcb2fa] {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+[data-v-1dbcb2fa] .group .ant-btn {
+  height: 100%;
+}
+[data-v-1dbcb2fa] .ant-btn-loading-icon {
+  height: 0;
+}

package/es/components/basic-button/basic-button.vue.d.ts

@@ -0,0 +1,100 @@
+import { PropType } from 'vue';
+import { ButtonStyle as buttonEnum, ButtonColorType } from '@gct-paas/core';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+        default?(_: {}): any;
+        icon?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    buttonType: {
+        type: PropType<ButtonColorType>;
+        default: string;
+    };
+    buttonTheme: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    icon: {
+        type: StringConstructor;
+        default: string;
+    };
+    iconColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    buttonStyle: {
+        type: PropType<buttonEnum>;
+        default: string;
+    };
+    dropdown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    dropdown: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    buttonType: {
+        type: PropType<ButtonColorType>;
+        default: string;
+    };
+    buttonTheme: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    icon: {
+        type: StringConstructor;
+        default: string;
+    };
+    iconColor: {
+        type: StringConstructor;
+        default: string;
+    };
+    buttonStyle: {
+        type: PropType<buttonEnum>;
+        default: string;
+    };
+    dropdown: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onDropdown?: ((...args: any[]) => any) | undefined;
+}>, {
+    icon: string;
+    disabled: boolean;
+    loading: boolean;
+    buttonStyle: buttonEnum;
+    dropdown: boolean;
+    buttonType: ButtonColorType;
+    buttonTheme: string;
+    iconColor: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/es/components/basic-button/basic-button.vue.mjs

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