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

package/es/modules/category/category-modal.vue_vue_type_script_setup_true_name_category-modal_lang.mjs

@@ -0,0 +1,53 @@
+import { createElementBlock, createVNode, defineComponent, normalizeClass, openBlock, reactive, ref, resolveComponent, unref, withCtx } from "vue";
+import { pickBy } from "lodash-es";
+import { t, useModal, useNamespace } from "@gct-paas/core";
+//#region src/modules/category/category-modal.vue?vue&type=script&setup=true&name=category-modal&lang.ts
+var category_modal_vue_vue_type_script_setup_true_name_category_modal_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "category-modal",
+	props: {
+		data: { default: () => ({}) },
+		module: {}
+	},
+	setup(__props) {
+		const ns = useNamespace("category-modal");
+		const formData = reactive({ ...__props.data });
+		const formRef = ref();
+		useModal(async () => {
+			await formRef.value.validate();
+			return {
+				ok: true,
+				data: [pickBy(formData, (v) => v !== void 0)]
+			};
+		});
+		return (_ctx, _cache) => {
+			const _component_a_input = resolveComponent("a-input");
+			const _component_a_form_item = resolveComponent("a-form-item");
+			const _component_a_form = resolveComponent("a-form");
+			return openBlock(), createElementBlock("div", { class: normalizeClass(unref(ns).b()) }, [createVNode(_component_a_form, {
+				ref_key: "formRef",
+				ref: formRef,
+				model: formData,
+				"label-col": { span: 6 },
+				"wrapper-col": { span: 16 },
+				autocomplete: "off"
+			}, {
+				default: withCtx(() => [createVNode(_component_a_form_item, {
+					label: `${unref(t)("sys.category")}${unref(t)("sys.name")}`,
+					name: "name",
+					rules: [{ required: true }]
+				}, {
+					default: withCtx(() => [createVNode(_component_a_input, {
+						value: formData.name,
+						"onUpdate:value": _cache[0] || (_cache[0] = ($event) => formData.name = $event),
+						"show-count": "",
+						maxlength: 100
+					}, null, 8, ["value"])]),
+					_: 1
+				}, 8, ["label"])]),
+				_: 1
+			}, 8, ["model"])], 2);
+		};
+	}
+});
+//#endregion
+export { category_modal_vue_vue_type_script_setup_true_name_category_modal_lang_default as default };

package/es/modules/category/category-modal.vue_vue_type_style_index_0_scoped_b560615c_lang.css

@@ -0,0 +1,67 @@
+@charset "UTF-8";
+/* stylelint-disable scss/no-global-function-names */
+/* bem('block', 'element', 'modifier') => 'ibiz-block__element--modifier' */
+/**
+ * 定义 Block 块
+ * @param {String} $block - Block 块名称
+ * @example
+ *   @include b('button') {
+ *     padding: 10px;
+ *   }
+ */
+/**
+ * 定义 Element 元素
+ * @param {String|List} $element - Element 元素名称，支持单个或多个
+ * @example
+ *   @include b('button') {
+ *     @include e('text') {
+ *       color: #000;
+ *     }
+ *   }
+ *   // 或传入多个元素
+ *   @include b('button') {
+ *     @include e(('text', 'icon')) {
+ *       margin: 5px;
+ *     }
+ *   }
+ */
+/**
+ * 定义 Modifier 修饰符
+ * @param {String|List} $modifier - Modifier 修饰符名称，支持单个或多个
+ * @example
+ *   @include b('button') {
+ *     @include m('primary') {
+ *       background: blue;
+ *     }
+ *   }
+ *   // 或传入多个修饰符
+ *   @include b('button') {
+ *     @include m(('primary', 'large')) {
+ *       background: blue;
+ *       font-size: 16px;
+ *     }
+ *   }
+ */
+/**
+ * 定义状态选择器
+ * @param {String} $state - 状态名称
+ * @example
+ *   @include b('button') {
+ *     @include when('disabled') {
+ *       opacity: 0.5;
+ *     }
+ *   }
+ */
+/**
+ * 深色主题样式
+ * @param {String} $block - Block 块名称
+ * @example
+ *   @include dark('button') {
+ *     background: #333;
+ *     color: #fff;
+ *   }
+ */
+/* stylelint-disable scss/no-global-function-names */
+.gct-category-modal[data-v-b560615c] {
+  padding-top: 12px;
+}

package/es/modules/category/category-sider.vue.d.ts

@@ -0,0 +1,337 @@
+import { BasicAction } from '@gct-paas/core';
+import { CategoryModuleEnum } from './type';
+import { ITreeNode, TreeExDropEvent } from '../../components';
+type __VLS_Props = {
+    module: CategoryModuleEnum;
+    value?: string;
+    siderTitle: string;
+    readonly: boolean;
+    isTree: boolean;
+    needFolderIcon: boolean;
+    customDelFunc?: Fn;
+    customDelTips?: string;
+    hasTitle?: boolean;
+    draggable?: boolean;
+    ignoreCase?: number;
+    hasPerBtns?: BasicAction[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    getCategoryData: () => ITreeNode[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    changeCategory: (value?: string | undefined) => void;
+    changeValue: (value?: object | undefined) => void;
+    "update:value": (value?: string | undefined) => void;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChangeCategory?: ((value?: string | undefined) => any) | undefined;
+    onChangeValue?: ((value?: object | undefined) => any) | undefined;
+    "onUpdate:value"?: ((value?: string | undefined) => any) | undefined;
+}>, {
+    hasTitle: boolean;
+    draggable: boolean;
+    hasPerBtns: BasicAction[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    treeExRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        draggable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        data: {
+            type: import('vue').PropType<ITreeNode[]>;
+            required: true;
+        };
+        filter: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        selectedKeys: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            };
+            default: undefined;
+        };
+        checkedKeys: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            };
+            default: undefined;
+        };
+        expandedKeys: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            };
+            default: undefined;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        lastSelectionLocked: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkStrictly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoExpandParent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        defaultExpandAll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        showLine: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        ignoreCase: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{
+        onDrop?: ((event: TreeExDropEvent) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((_val: string[]) => any) | undefined;
+    }>, {
+        ns: import('@gct-paas/core').Namespace;
+        selectedKeysValue: import('vue').WritableComputedRef<string[], string[]>;
+        checkedKeysValue: import('vue').WritableComputedRef<string[], string[]>;
+        expandedKeysValue: import('vue').WritableComputedRef<string[] | undefined, string[] | undefined>;
+        actualDraggable: import('vue').ComputedRef<boolean>;
+        filteredTreeData: import('vue').ComputedRef<ITreeNode[]>;
+        handleSelect: (sKeys: (string | number)[], { node }: {
+            node: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        handleCheck: (checked: string[] | {
+            checked: string[];
+            halfChecked: string[];
+        }, info: import('ant-design-vue/es/vc-tree/props').CheckInfo) => void;
+        handleDrop: (info: import('ant-design-vue/es/tree').AntTreeNodeDropEvent) => Promise<void>;
+        collapseAll: () => void;
+        expandAll: () => void;
+        onExpand: (eKeys: (string | number)[], { expanded: _expanded, node: _node, }: {
+            expanded: boolean;
+            node: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        expandNode: (key: string, isExpand?: boolean) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:selectedKeys": (_val: string[]) => boolean;
+        "update:checkedKeys": (_val: string[]) => boolean;
+        "update:expandedKeys": (_val: string[]) => boolean;
+        drop: (event: TreeExDropEvent) => boolean;
+    }, import('vue').PublicProps, {
+        draggable: boolean;
+        filter: string;
+        selectedKeys: string[];
+        checkedKeys: string[];
+        expandedKeys: string[];
+        multiple: boolean;
+        lastSelectionLocked: boolean;
+        checkable: boolean;
+        checkStrictly: boolean;
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        showLine: boolean;
+        ignoreCase: number;
+    }, true, {}, import('vue').SlotsType<{
+        title: {
+            node: ITreeNode;
+        };
+    }>, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        draggable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        data: {
+            type: import('vue').PropType<ITreeNode[]>;
+            required: true;
+        };
+        filter: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        selectedKeys: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            };
+            default: undefined;
+        };
+        checkedKeys: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            };
+            default: undefined;
+        };
+        expandedKeys: {
+            type: {
+                (arrayLength: number): string[];
+                (...items: string[]): string[];
+                new (arrayLength: number): string[];
+                new (...items: string[]): string[];
+                isArray(arg: any): arg is any[];
+                readonly prototype: any[];
+                from<T>(arrayLike: ArrayLike<T>): T[];
+                from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                of<T>(...items: T[]): T[];
+                readonly [Symbol.species]: ArrayConstructor;
+                fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            };
+            default: undefined;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        lastSelectionLocked: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        checkStrictly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        autoExpandParent: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        defaultExpandAll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        showLine: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        ignoreCase: {
+            type: NumberConstructor;
+            default: number;
+        };
+    }>> & Readonly<{
+        onDrop?: ((event: TreeExDropEvent) => any) | undefined;
+        "onUpdate:checkedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:expandedKeys"?: ((_val: string[]) => any) | undefined;
+        "onUpdate:selectedKeys"?: ((_val: string[]) => any) | undefined;
+    }>, {
+        ns: import('@gct-paas/core').Namespace;
+        selectedKeysValue: import('vue').WritableComputedRef<string[], string[]>;
+        checkedKeysValue: import('vue').WritableComputedRef<string[], string[]>;
+        expandedKeysValue: import('vue').WritableComputedRef<string[] | undefined, string[] | undefined>;
+        actualDraggable: import('vue').ComputedRef<boolean>;
+        filteredTreeData: import('vue').ComputedRef<ITreeNode[]>;
+        handleSelect: (sKeys: (string | number)[], { node }: {
+            node: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        handleCheck: (checked: string[] | {
+            checked: string[];
+            halfChecked: string[];
+        }, info: import('ant-design-vue/es/vc-tree/props').CheckInfo) => void;
+        handleDrop: (info: import('ant-design-vue/es/tree').AntTreeNodeDropEvent) => Promise<void>;
+        collapseAll: () => void;
+        expandAll: () => void;
+        onExpand: (eKeys: (string | number)[], { expanded: _expanded, node: _node, }: {
+            expanded: boolean;
+            node: import('ant-design-vue/es/tree').EventDataNode;
+        }) => void;
+        expandNode: (key: string, isExpand?: boolean) => void;
+    }, {}, {}, {}, {
+        draggable: boolean;
+        filter: string;
+        selectedKeys: string[];
+        checkedKeys: string[];
+        expandedKeys: string[];
+        multiple: boolean;
+        lastSelectionLocked: boolean;
+        checkable: boolean;
+        checkStrictly: boolean;
+        autoExpandParent: boolean;
+        defaultExpandAll: boolean;
+        showLine: boolean;
+        ignoreCase: number;
+    }> | null;
+}, HTMLDivElement>;
+export default _default;

package/es/modules/category/category-sider.vue.mjs

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export-helper.mjs";
+import category_sider_vue_vue_type_script_setup_true_name_category_sider_lang_default from "./category-sider.vue_vue_type_script_setup_true_name_category-sider_lang.mjs";
+import './category-sider.vue_vue_type_style_index_0_scoped_5af8c1ba_lang.css';/* empty css                                                                     */
+//#region src/modules/category/category-sider.vue
+var category_sider_default = /* @__PURE__ */ _plugin_vue_export_helper_default(category_sider_vue_vue_type_script_setup_true_name_category_sider_lang_default, [["__scopeId", "data-v-5af8c1ba"]]);
+//#endregion
+export { category_sider_default as default };