@gct-paas/core-web 0.1.4-dev.8 → 0.1.5-dev.0

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

@@ -0,0 +1,45 @@
+import target_loading_default from "./target-loading.vue.mjs";
+import { createVNode, defineComponent, h, reactive, render } from "vue";
+//#region src/modules/target-loading/src/createLoading.ts
+function createLoading(props, target, wait = false) {
+	let vm = null;
+	const data = reactive({
+		tip: "",
+		loading: true,
+		...props
+	});
+	vm = createVNode(defineComponent({ render() {
+		return h(target_loading_default, { ...data });
+	} }));
+	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(target = document.body) {
+		if (!vm || !vm.el) return;
+		target.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;
+		}
+	};
+}
+//#endregion
+export { createLoading };

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,7 @@
+import _plugin_vue_export_helper_default from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import target_loading_vue_vue_type_script_setup_true_name_target_loading_lang_default from "./target-loading.vue_vue_type_script_setup_true_name_target-loading_lang.mjs";
+import './target-loading.vue_vue_type_style_index_0_scoped_d448466c_lang.css';/* empty css                                                                     */
+//#region src/modules/target-loading/src/target-loading.vue
+var target_loading_default = /* @__PURE__ */ _plugin_vue_export_helper_default(target_loading_vue_vue_type_script_setup_true_name_target_loading_lang_default, [["__scopeId", "data-v-d448466c"]]);
+//#endregion
+export { target_loading_default as default };

package/es/modules/target-loading/src/target-loading.vue_vue_type_script_setup_true_name_target-loading_lang.mjs

@@ -0,0 +1,55 @@
+import { createElementBlock, createVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, unref, vShow, withDirectives } from "vue";
+import { SizeEnum } from "@gct-paas/core";
+import { Spin } from "ant-design-vue";
+//#region src/modules/target-loading/src/target-loading.vue?vue&type=script&setup=true&name=target-loading&lang.ts
+var target_loading_vue_vue_type_script_setup_true_name_target_loading_lang_default = /* @__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]]);
+		};
+	}
+});
+//#endregion
+export { target_loading_vue_vue_type_script_setup_true_name_target_loading_lang_default as default };

package/es/modules/target-loading/src/target-loading.vue_vue_type_style_index_0_scoped_d448466c_lang.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/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/modules/target-loading/src/useLoading.mjs

@@ -0,0 +1,2 @@
+import "./createLoading.mjs";
+import "vue";

package/es/setup-app.d.ts

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

package/es/setup-app.mjs

@@ -0,0 +1,4 @@
+//#region src/setup-app.ts
+function coreWebSetupApp() {}
+//#endregion
+export { coreWebSetupApp };

package/es/types/index.d.ts

@@ -1 +1,201 @@
 import '@gct-paas/core/types';
+
+import { EditorRegister, FormItemRegister } from '../modules/gct-form';
+import { TableEditorRegister } from '../modules/gct-table';
+
+import type { CSSProperties, VNode } from 'vue';
+import type { ButtonProps } from 'ant-design-vue/es/button/buttonTypes';
+import type { ModalWrapperProps } from '@/modules/global-modal';
+
+declare module '@gct-paas/core' {
+  interface IGlobalRegister {
+    editor: EditorRegister;
+    tableEditor: TableEditorRegister;
+    formItem: FormItemRegister;
+  }
+
+  interface IModalOptions {
+    visible?: boolean;
+    /**
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:05
+     * @type {boolean}
+     */
+    scrollTop?: boolean;
+    height?: number | string;
+    minHeight?: number;
+    /**
+     * open drag
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:18
+     * @type {boolean}
+     */
+    draggable?: boolean;
+    centered?: boolean;
+    /**
+     *
+     * @default sys.cancelText
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:39
+     * @type {string}
+     */
+    cancelText?: string;
+    /**
+     *
+     * @default sys.okText
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:23
+     * @type {string}
+     */
+    okText?: string;
+
+    closeFunc?: () => Promise<boolean>;
+    defaultFullscreen?: boolean;
+    /**
+     * Can it be full screen
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:48
+     * @type {boolean}
+     */
+    canFullscreen?: boolean;
+    /**
+     * After enabling the wrapper, the bottom can be increased in height
+     *
+     * @default 0
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:06
+     * @type number
+     */
+    wrapperFooterOffset?: number;
+    // Warm reminder message
+    helpMessage?: string | string[];
+    /**
+     * Whether to setting wrapper
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:35
+     * @type {boolean}
+     */
+    useWrapper?: boolean;
+    loading?: boolean;
+    loadingTip?: string;
+    /**
+     * Show close button
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:55
+     * @type {boolean}
+     */
+    showCancelBtn?: boolean;
+    /**
+     * 显示关闭按钮
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-06-04 09:06:11
+     * @type {boolean}
+     */
+    showCloseBtn?: boolean;
+    /**
+     * Show confirmation button
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:06
+     * @type {boolean}
+     */
+    showOkBtn?: boolean;
+
+    wrapperProps?: Partial<ModalWrapperProps>;
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+    afterClose?: Function;
+
+    bodyStyle?: CSSProperties;
+
+    /**
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:21
+     * @type {boolean}
+     */
+    closable?: boolean;
+
+    closeIcon?: VNode;
+
+    confirmLoading?: boolean;
+
+    destroyOnClose?: boolean;
+
+    footer?: VNode | null;
+
+    /**
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:34
+     * @type {boolean}
+     */
+    mask?: boolean;
+
+    /**
+     *
+     * @default false
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:51
+     * @type {boolean}
+     */
+    maskClosable?: boolean;
+
+    /**
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:56
+     * @type {boolean}
+     */
+    keyboard?: boolean;
+
+    maskStyle?: CSSProperties;
+
+    /**
+     *
+     * @default 'primary'
+     * @author zhanghanrui
+     * @date 2024-03-20 10:03:48
+     * @type string
+     */
+    okType?: string;
+
+    okButtonProps?: ButtonProps;
+
+    cancelButtonProps?: ButtonProps;
+
+    title?: string;
+
+    width?: string | number;
+
+    wrapClassName?: string;
+
+    zIndex?: number;
+
+    /**
+     * 是否显示底部
+     *
+     * @default true
+     * @author zhanghanrui
+     * @date 2024-04-07 18:04:17
+     * @type {boolean}
+     */
+    showFooter?: boolean;
+  }
+}

package/es/utils/index.d.ts

@@ -1 +1,4 @@
-export { withInstall } from './with-install';
+export { MessageUtil } from './message-util/message-util';
+export * from './monaco-loader/monaco-loader';
+export { OverlayController, overlay, } from './overlay-controller/overlay-controller';
+export { withInstall, type CustomComponent, type WithInstall, } from './with-install';

package/es/utils/index.mjs

@@ -0,0 +1,4 @@
+import "./message-util/message-util.mjs";
+import "./monaco-loader/monaco-loader.mjs";
+import "./overlay-controller/overlay-controller.mjs";
+import "./with-install.mjs";

package/es/utils/message-util/message-util.d.ts

@@ -0,0 +1,7 @@
+import { IMessageParams, IMessageUtil } from '@gct-paas/core';
+export declare class MessageUtil implements IMessageUtil {
+    info(msg: string, params?: IMessageParams): Promise<void>;
+    success(msg: string, params?: IMessageParams): Promise<void>;
+    warning(msg: string, params?: IMessageParams): Promise<void>;
+    error(msg: string, params?: IMessageParams): Promise<void>;
+}

package/es/utils/message-util/message-util.mjs

@@ -0,0 +1,26 @@
+import { message } from "ant-design-vue";
+//#region src/utils/message-util/message-util.ts
+var MessageUtil = class {
+	info(msg, params) {
+		return new Promise((resolve) => {
+			message.info(msg, params?.duration, resolve);
+		});
+	}
+	success(msg, params) {
+		return new Promise((resolve) => {
+			message.success(msg, params?.duration, resolve);
+		});
+	}
+	warning(msg, params) {
+		return new Promise((resolve) => {
+			message.warning(msg, params?.duration, resolve);
+		});
+	}
+	error(msg, params) {
+		return new Promise((resolve) => {
+			message.error(msg, params?.duration, resolve);
+		});
+	}
+};
+//#endregion
+export { MessageUtil };

package/es/utils/monaco-loader/monaco-loader.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Monaco Editor 懒加载工具
+ * 统一管理 Monaco Editor 的加载和配置
+ * 使用 @monaco-editor/loader 实现按需加载
+ */
+import type * as Monaco from 'monaco-editor';
+/**
+ * Monaco Editor 加载器类
+ * 单例模式，统一管理 Monaco Editor 的加载和配置
+ */
+declare class MonacoLoader {
+    private _monacoInstance;
+    private _loadingPromise;
+    constructor();
+    /**
+     * 配置 Monaco Editor 加载器
+     */
+    private _configureLoader;
+    /**
+     * 加载 Monaco Editor
+     * 返回 Monaco Editor 的实例
+     * 该函数会缓存加载结果，多次调用只会加载一次
+     */
+    loadMonaco(): Promise<typeof Monaco>;
+    /**
+     * 获取已加载的 Monaco 实例
+     * 如果尚未加载，返回 null
+     */
+    getMonaco(): typeof Monaco | null;
+    /**
+     * 判断 Monaco 是否已加载
+     */
+    isMonacoLoaded(): boolean;
+    /**
+     * 创建 Monaco Editor 实例的辅助函数
+     * @param container DOM 容器
+     * @param options 编辑器配置选项
+     */
+    createMonacoEditor(container: HTMLElement, options?: Monaco.editor.IStandaloneEditorConstructionOptions): Promise<Monaco.editor.IStandaloneCodeEditor>;
+    /**
+     * 创建 Monaco Diff Editor 实例的辅助函数
+     * @param container DOM 容器
+     * @param options 编辑器配置选项
+     */
+    createMonacoDiffEditor(container: HTMLElement, options?: Monaco.editor.IStandaloneDiffEditorConstructionOptions): Promise<Monaco.editor.IStandaloneDiffEditor>;
+    /**
+     * 创建 Monaco Model 的辅助函数
+     * @param value 文本内容
+     * @param language 语言类型
+     * @param uri 资源标识符
+     */
+    createMonacoModel(value: string, language?: string, uri?: Monaco.Uri): Promise<Monaco.editor.ITextModel>;
+}
+export declare const monacoLoader: MonacoLoader;
+export type { Monaco };
+export type IMonacoLoader = MonacoLoader;
+export type IMonacoEditor = Monaco.editor.IStandaloneCodeEditor;
+export type IMonacoDiffEditor = Monaco.editor.IStandaloneDiffEditor;
+export type IMonacoITextModel = Monaco.editor.ITextModel;

package/es/utils/monaco-loader/monaco-loader.mjs

@@ -0,0 +1,84 @@
+import loader from "@monaco-editor/loader";
+//#region src/utils/monaco-loader/monaco-loader.ts
+/**
+* Monaco Editor 懒加载工具
+* 统一管理 Monaco Editor 的加载和配置
+* 使用 @monaco-editor/loader 实现按需加载
+*/
+/**
+* Monaco Editor 加载器类
+* 单例模式，统一管理 Monaco Editor 的加载和配置
+*/
+var MonacoLoader = class {
+	_monacoInstance = null;
+	_loadingPromise = null;
+	constructor() {
+		this._configureLoader();
+	}
+	/**
+	* 配置 Monaco Editor 加载器
+	*/
+	_configureLoader() {
+		loader.config({ paths: { vs: location.origin + "/extras/monaco-editor/0.55.1/min/vs" } });
+	}
+	/**
+	* 加载 Monaco Editor
+	* 返回 Monaco Editor 的实例
+	* 该函数会缓存加载结果，多次调用只会加载一次
+	*/
+	async loadMonaco() {
+		if (this._monacoInstance) return this._monacoInstance;
+		if (this._loadingPromise) return this._loadingPromise;
+		this._loadingPromise = loader.init();
+		try {
+			this._monacoInstance = await this._loadingPromise;
+			console.info("✓ Monaco Editor loaded successfully");
+			return this._monacoInstance;
+		} catch (error) {
+			console.error("✗ Failed to load Monaco Editor:", error);
+			this._loadingPromise = null;
+			throw error;
+		}
+	}
+	/**
+	* 获取已加载的 Monaco 实例
+	* 如果尚未加载，返回 null
+	*/
+	getMonaco() {
+		return this._monacoInstance;
+	}
+	/**
+	* 判断 Monaco 是否已加载
+	*/
+	isMonacoLoaded() {
+		return this._monacoInstance !== null;
+	}
+	/**
+	* 创建 Monaco Editor 实例的辅助函数
+	* @param container DOM 容器
+	* @param options 编辑器配置选项
+	*/
+	async createMonacoEditor(container, options) {
+		return (await this.loadMonaco()).editor.create(container, options);
+	}
+	/**
+	* 创建 Monaco Diff Editor 实例的辅助函数
+	* @param container DOM 容器
+	* @param options 编辑器配置选项
+	*/
+	async createMonacoDiffEditor(container, options) {
+		return (await this.loadMonaco()).editor.createDiffEditor(container, options);
+	}
+	/**
+	* 创建 Monaco Model 的辅助函数
+	* @param value 文本内容
+	* @param language 语言类型
+	* @param uri 资源标识符
+	*/
+	async createMonacoModel(value, language, uri) {
+		return (await this.loadMonaco()).editor.createModel(value, language, uri);
+	}
+};
+var monacoLoader = new MonacoLoader();
+//#endregion
+export { monacoLoader };

package/es/utils/overlay-controller/overlay-controller.d.ts

@@ -0,0 +1,18 @@
+import { IModalData, IModalOptions, IOverlayContainer, IOverlayController } from '@gct-paas/core';
+/**
+ * 用不同呈现方式绘制组件的通用工具类
+ *
+ * @author zhanghanrui
+ * @date 2024-03-19 19:03:34
+ * @export
+ * @class OverlayController
+ * @implements {IOverlayController}
+ */
+export declare class OverlayController implements IOverlayController {
+    modal<T = IModalData>(component: unknown, props?: IParams, opts?: IModalOptions): Promise<T>;
+    createModal(component: unknown, props?: IParams, opts?: IModalOptions): IOverlayContainer;
+}
+/**
+ * 唯一界面绘制控制器
+ */
+export declare const overlay: OverlayController;

package/es/utils/overlay-controller/overlay-controller.mjs

@@ -0,0 +1,32 @@
+import { createModal } from "../../components/app-modal/app-modal-component.mjs";
+import { h, resolveComponent } from "vue";
+import { isFunction, isString } from "lodash-es";
+//#region src/utils/overlay-controller/overlay-controller.ts
+function resolveComponentOrStr(component) {
+	return isString(component) ? resolveComponent(component) : component;
+}
+/**
+* 用不同呈现方式绘制组件的通用工具类
+*
+* @author zhanghanrui
+* @date 2024-03-19 19:03:34
+* @export
+* @class OverlayController
+* @implements {IOverlayController}
+*/
+var OverlayController = class {
+	async modal(component, props, opts) {
+		const modal = this.createModal(component, props, opts);
+		modal.present();
+		return modal.onWillDismiss();
+	}
+	createModal(component, props, opts) {
+		return createModal(isFunction(component) ? component : () => h(resolveComponentOrStr(component), { ...props }), opts);
+	}
+};
+/**
+* 唯一界面绘制控制器
+*/
+var overlay = new OverlayController();
+//#endregion
+export { OverlayController, overlay };

package/es/utils/with-install.mjs

@@ -1,13 +1,12 @@
-const withInstall = (component, alias) => {
-  component.install = (app) => {
-    const compName = component.name || component.displayName;
-    if (!compName) return;
-    app.component(compName, component);
-    if (alias) {
-      app.config.globalProperties[alias] = component;
-    }
-  };
-  return component;
+//#region src/utils/with-install.ts
+var withInstall = (component, alias) => {
+	component.install = (app) => {
+		const compName = component.name || component.displayName;
+		if (!compName) return;
+		app.component(compName, component);
+		if (alias) app.config.globalProperties[alias] = component;
+	};
+	return component;
 };
-
+//#endregion
 export { withInstall };