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

package/es/modules/global-modal/src/props.d.ts

@@ -0,0 +1,156 @@
+import { PropType, CSSProperties, VNode } from 'vue';
+import { ModalWrapperProps } from './typing';
+import { ButtonProps, ButtonType } from 'ant-design-vue/es/button/buttonTypes';
+export declare const modalProps: {
+    visible: {
+        type: BooleanConstructor;
+    };
+    scrollTop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    outHeight: {
+        type: NumberConstructor;
+    };
+    minHeight: {
+        type: NumberConstructor;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    centered: {
+        type: BooleanConstructor;
+    };
+    cancelText: {
+        type: StringConstructor;
+        default: string;
+    };
+    okText: {
+        type: StringConstructor;
+        default: string;
+    };
+    closeFunc: PropType<() => Promise<boolean>>;
+};
+export declare const basicProps: {
+    visible: {
+        type: BooleanConstructor;
+    };
+    scrollTop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    outHeight: {
+        type: NumberConstructor;
+    };
+    minHeight: {
+        type: NumberConstructor;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    centered: {
+        type: BooleanConstructor;
+    };
+    cancelText: {
+        type: StringConstructor;
+        default: string;
+    };
+    okText: {
+        type: StringConstructor;
+        default: string;
+    };
+    closeFunc: PropType<() => Promise<boolean>>;
+} & {
+    defaultFullscreen: {
+        type: BooleanConstructor;
+    };
+    canFullscreen: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wrapperFooterOffset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    helpMessage: PropType<string | string[]>;
+    useWrapper: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+    };
+    loadingTip: {
+        type: StringConstructor;
+    };
+    /**
+     * @description: Show close button
+     */
+    showCancelBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    /**
+     * @description: Show confirmation button
+     */
+    showOkBtn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    wrapperProps: PropType<Partial<ModalWrapperProps>>;
+    afterClose: FunctionConstructor;
+    bodyStyle: PropType<CSSProperties>;
+    closable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeIcon: PropType<VNode>;
+    confirmLoading: {
+        type: BooleanConstructor;
+    };
+    destroyOnClose: {
+        type: BooleanConstructor;
+    };
+    footer: PropType<VNode>;
+    getContainer: PropType<() => IObject>;
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskClosable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    keyboard: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maskStyle: PropType<CSSProperties>;
+    okType: {
+        type: PropType<ButtonType>;
+        default: string;
+    };
+    okButtonProps: PropType<ButtonProps>;
+    cancelButtonProps: PropType<ButtonProps>;
+    title: {
+        type: StringConstructor;
+    };
+    visible: {
+        type: BooleanConstructor;
+    };
+    width: PropType<string | number>;
+    wrapClassName: {
+        type: StringConstructor;
+    };
+    zIndex: {
+        type: NumberConstructor;
+    };
+};

package/es/modules/global-modal/src/props.mjs

@@ -0,0 +1,57 @@
+const modalProps = {
+  visible: { type: Boolean },
+  scrollTop: { type: Boolean, default: true },
+  height: { type: Number },
+  outHeight: { type: Number },
+  minHeight: { type: Number },
+  // open drag
+  draggable: { type: Boolean, default: true },
+  centered: { type: Boolean },
+  cancelText: { type: String, default: "sys.cancelText" },
+  okText: { type: String, default: "sys.okText" },
+  closeFunc: Function
+};
+const basicProps = Object.assign({}, modalProps, {
+  defaultFullscreen: { type: Boolean },
+  // Can it be full screen
+  canFullscreen: { type: Boolean, default: true },
+  // After enabling the wrapper, the bottom can be increased in height
+  wrapperFooterOffset: { type: Number, default: 0 },
+  // Warm reminder message
+  helpMessage: [String, Array],
+  // Whether to setting wrapper
+  useWrapper: { type: Boolean, default: true },
+  loading: { type: Boolean },
+  loadingTip: { type: String },
+  /**
+   * @description: Show close button
+   */
+  showCancelBtn: { type: Boolean, default: true },
+  /**
+   * @description: Show confirmation button
+   */
+  showOkBtn: { type: Boolean, default: true },
+  wrapperProps: Object,
+  afterClose: Function,
+  bodyStyle: Object,
+  closable: { type: Boolean, default: true },
+  closeIcon: Object,
+  confirmLoading: { type: Boolean },
+  destroyOnClose: { type: Boolean },
+  footer: Object,
+  getContainer: Function,
+  mask: { type: Boolean, default: true },
+  maskClosable: { type: Boolean, default: false },
+  keyboard: { type: Boolean, default: true },
+  maskStyle: Object,
+  okType: { type: String, default: "primary" },
+  okButtonProps: Object,
+  cancelButtonProps: Object,
+  title: { type: String },
+  visible: { type: Boolean },
+  width: [String, Number],
+  wrapClassName: { type: String },
+  zIndex: { type: Number }
+});
+
+export { basicProps, modalProps };

package/es/modules/global-modal/src/typing.d.ts

@@ -0,0 +1,174 @@
+import { ButtonProps } from 'ant-design-vue/lib/button/buttonTypes';
+import { CSSProperties, VNodeChild, ComputedRef } from 'vue';
+import { JSX } from 'vue/jsx-runtime';
+/**
+ * @description: 弹窗对外暴露的方法
+ */
+export interface ModalMethods {
+    setModalProps: (props: Partial<ModalProps>) => void;
+    emitVisible?: (visible: boolean, uid: number) => void;
+    redoModalHeight?: () => void;
+}
+export type RegisterFn = (modalMethods: ModalMethods, uuid?: string) => void;
+export interface ReturnMethods extends ModalMethods {
+    openModal: <T = IObject>(props?: boolean, data?: T, openOnSet?: boolean) => void;
+    closeModal: () => void;
+    getVisible?: ComputedRef<boolean>;
+}
+export type UseModalReturnType = [RegisterFn, ReturnMethods];
+export interface ReturnInnerMethods extends ModalMethods {
+    closeModal: () => void;
+    changeLoading: (loading: boolean) => void;
+    changeOkLoading: (loading: boolean) => void;
+    getVisible?: ComputedRef<boolean>;
+    redoModalHeight: () => void;
+}
+export type UseModalInnerReturnType = [RegisterFn, ReturnInnerMethods];
+export interface ModalProps {
+    minHeight?: number;
+    height?: number;
+    wrapperFooterOffset?: number;
+    draggable?: boolean;
+    scrollTop?: boolean;
+    canFullscreen?: boolean;
+    defaultFullscreen?: boolean;
+    visible?: boolean;
+    helpMessage: string | string[];
+    useWrapper: boolean;
+    loading: boolean;
+    loadingTip?: string;
+    wrapperProps: Omit<ModalWrapperProps, 'loading'>;
+    showOkBtn: boolean;
+    showCancelBtn: boolean;
+    closeFunc: () => Promise<any>;
+    /**
+     * Specify a function that will be called when modal is closed completely.
+     * @type Function
+     */
+    afterClose?: () => any;
+    /**
+     * Body style for modal body element. Such as height, padding etc.
+     * @default {}
+     * @type object
+     */
+    bodyStyle?: CSSProperties;
+    /**
+     * Text of the Cancel button
+     * @default 'cancel'
+     * @type string
+     */
+    cancelText?: string;
+    /**
+     * Centered Modal
+     * @default false
+     * @type boolean
+     */
+    centered?: boolean;
+    /**
+     * Whether a close (x) button is visible on top right of the modal dialog or not
+     * @default true
+     * @type boolean
+     */
+    closable?: boolean;
+    /**
+     * Whether a close (x) button is visible on top right of the modal dialog or not
+     */
+    closeIcon?: VNodeChild | JSX.Element;
+    /**
+     * Whether to apply loading visual effect for OK button or not
+     * @default false
+     * @type boolean
+     */
+    confirmLoading?: boolean;
+    /**
+     * Whether to unmount child components on onClose
+     * @default false
+     * @type boolean
+     */
+    destroyOnClose?: boolean;
+    /**
+     * Footer content, set as :footer="null" when you don't need default buttons
+     * @default OK and Cancel buttons
+     * @type any (string | slot)
+     */
+    footer?: VNodeChild | JSX.Element;
+    /**
+     * Return the mount node for Modal
+     * @default () => document.body
+     * @type Function
+     */
+    getContainer?: (instance: any) => HTMLElement;
+    /**
+     * Whether show mask or not.
+     * @default true
+     * @type boolean
+     */
+    mask?: boolean;
+    /**
+     * Whether to close the modal dialog when the mask (area outside the modal) is clicked
+     * @default true
+     * @type boolean
+     */
+    maskClosable?: boolean;
+    /**
+     * Style for modal's mask element.
+     * @default {}
+     * @type object
+     */
+    maskStyle?: CSSProperties;
+    /**
+     * Text of the OK button
+     * @default 'OK'
+     * @type string
+     */
+    okText?: string;
+    /**
+     * Button type of the OK button
+     * @default 'primary'
+     * @type string
+     */
+    okType?: 'primary' | 'danger' | 'dashed' | 'ghost' | 'default';
+    /**
+     * The ok button props, follow jsx rules
+     * @type object
+     */
+    okButtonProps?: ButtonProps;
+    /**
+     * The cancel button props, follow jsx rules
+     * @type object
+     */
+    cancelButtonProps?: ButtonProps;
+    /**
+     * The modal dialog's title
+     * @type any (string | slot)
+     */
+    title?: VNodeChild | JSX.Element;
+    /**
+     * Width of the modal dialog
+     * @default 520
+     * @type string | number
+     */
+    width?: string | number;
+    /**
+     * The class name of the container of the modal dialog
+     * @type string
+     */
+    wrapClassName?: string;
+    /**
+     * The z-index of the Modal
+     * @default 1000
+     * @type number
+     */
+    zIndex?: number;
+}
+export interface ModalWrapperProps {
+    footerOffset?: number;
+    loading: boolean;
+    modalHeaderHeight: number;
+    modalFooterHeight: number;
+    minHeight: number;
+    height: number;
+    visible: boolean;
+    fullScreen: boolean;
+    useWrapper: boolean;
+}

package/es/modules/target-loading/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Loading } from './src/target-loading.vue';
+export { Loading };
+export { useLoading } from './src/useLoading';
+export { createLoading } from './src/createLoading';

package/es/modules/target-loading/src/createLoading.d.ts

@@ -0,0 +1,13 @@
+import { VNode } from 'vue';
+import { LoadingProps } from './typing';
+export declare function createLoading(props?: Partial<LoadingProps>, target?: HTMLElement, wait?: boolean): {
+    vm: VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    close: () => void;
+    open: (target?: HTMLElement) => void;
+    setTip: (tip: string) => void;
+    setLoading: (loading: boolean) => void;
+    readonly loading: boolean;
+    readonly $el: HTMLElement;
+};

package/es/modules/target-loading/src/createLoading.mjs

@@ -0,0 +1,57 @@
+import { reactive, defineComponent, h, createVNode, render } from 'vue';
+import Loading from './target-loading.vue3.mjs';
+
+function createLoading(props, target, wait = false) {
+  let vm = null;
+  const data = reactive({
+    tip: "",
+    loading: true,
+    ...props
+  });
+  const LoadingWrap = defineComponent({
+    render() {
+      return h(Loading, { ...data });
+    }
+  });
+  vm = createVNode(LoadingWrap);
+  if (wait) {
+    setTimeout(() => {
+      render(vm, document.createElement("div"));
+    }, 0);
+  } else {
+    render(vm, document.createElement("div"));
+  }
+  function close() {
+    if (vm?.el && vm.el.parentNode) {
+      vm.el.parentNode.removeChild(vm.el);
+    }
+  }
+  function open(target2 = document.body) {
+    if (!vm || !vm.el) {
+      return;
+    }
+    target2.appendChild(vm.el);
+  }
+  if (target) {
+    open(target);
+  }
+  return {
+    vm,
+    close,
+    open,
+    setTip: (tip) => {
+      data.tip = tip;
+    },
+    setLoading: (loading) => {
+      data.loading = loading;
+    },
+    get loading() {
+      return data.loading;
+    },
+    get $el() {
+      return vm?.el;
+    }
+  };
+}
+
+export { createLoading };

package/es/modules/target-loading/src/target-loading.css

@@ -0,0 +1,18 @@
+.full-loading[data-v-d448466c] {
+  display: flex;
+  position: fixed;
+  z-index: 200;
+  top: 0;
+  left: 0;
+  align-items: center;
+  justify-content: center;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(240, 242, 245, 0.4);
+}
+.full-loading.absolute[data-v-d448466c] {
+  position: absolute;
+  z-index: 300;
+  top: 0;
+  left: 0;
+}

package/es/modules/target-loading/src/target-loading.vue.d.ts

@@ -0,0 +1,57 @@
+import { PropType } from 'vue';
+import { SizeEnum } from '@gct-paas/core';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    tip: {
+        type: PropType<string>;
+        default: string;
+    };
+    size: {
+        type: PropType<SizeEnum>;
+        default: SizeEnum;
+        validator: (v: SizeEnum) => boolean;
+    };
+    absolute: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    loading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    background: {
+        type: PropType<string>;
+    };
+    theme: {
+        type: PropType<"dark" | "light">;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    tip: {
+        type: PropType<string>;
+        default: string;
+    };
+    size: {
+        type: PropType<SizeEnum>;
+        default: SizeEnum;
+        validator: (v: SizeEnum) => boolean;
+    };
+    absolute: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    loading: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    background: {
+        type: PropType<string>;
+    };
+    theme: {
+        type: PropType<"dark" | "light">;
+    };
+}>> & Readonly<{}>, {
+    size: SizeEnum;
+    loading: boolean;
+    absolute: boolean;
+    tip: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLElement>;
+export default _default;

package/es/modules/target-loading/src/target-loading.vue.mjs

@@ -0,0 +1,52 @@
+import { defineComponent, withDirectives, openBlock, createElementBlock, normalizeStyle, normalizeClass, createVNode, unref, mergeProps, vShow } from 'vue';
+import { Spin } from 'ant-design-vue';
+import { SizeEnum } from '@gct-paas/core';
+
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "target-loading",
+  props: {
+    tip: {
+      type: String,
+      default: ""
+    },
+    size: {
+      type: String,
+      default: SizeEnum.LARGE,
+      validator: (v) => {
+        return [SizeEnum.DEFAULT, SizeEnum.SMALL, SizeEnum.LARGE].includes(v);
+      }
+    },
+    absolute: {
+      type: Boolean,
+      default: false
+    },
+    loading: {
+      type: Boolean,
+      default: false
+    },
+    background: {
+      type: String
+    },
+    theme: {
+      type: String
+    }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return withDirectives((openBlock(), createElementBlock("section", {
+        class: normalizeClass(["full-loading", { absolute: __props.absolute, [__props.theme]: !!__props.theme }]),
+        style: normalizeStyle([__props.background ? `background-color: ${__props.background}` : ""])
+      }, [
+        createVNode(unref(Spin), mergeProps(_ctx.$attrs, {
+          tip: __props.tip,
+          size: __props.size,
+          spinning: __props.loading
+        }), null, 16, ["tip", "size", "spinning"])
+      ], 6)), [
+        [vShow, __props.loading]
+      ]);
+    };
+  }
+});
+
+export { _sfc_main as default };

package/es/modules/target-loading/src/target-loading.vue3.mjs

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

package/es/modules/target-loading/src/typing.d.ts

@@ -0,0 +1,9 @@
+import { SizeEnum } from '@gct-paas/core';
+export interface LoadingProps {
+    tip: string;
+    size: SizeEnum;
+    absolute: boolean;
+    loading: boolean;
+    background: string;
+    theme: 'dark' | 'light';
+}

package/es/modules/target-loading/src/useLoading.d.ts

@@ -0,0 +1,9 @@
+import { LoadingProps } from './typing';
+import { Ref } from 'vue';
+export interface UseLoadingOptions {
+    target?: HTMLElement | Ref<HTMLElement>;
+    props?: Partial<LoadingProps>;
+}
+type Fn = () => void;
+export declare function useLoading(props: Partial<LoadingProps> | Partial<UseLoadingOptions>): [Fn, Fn, (str: string) => void];
+export {};

package/es/setup-app.d.ts

@@ -0,0 +1 @@
+export declare function coreWebSetupApp(): void;

package/es/setup-app.mjs

@@ -0,0 +1,4 @@
+function coreWebSetupApp() {
+}
+
+export { coreWebSetupApp };