@gct-paas/core-web 0.1.5-dev.5 → 0.1.5-dev.7

package/es/components/field-tree-select/index.d.ts

@@ -0,0 +1,307 @@
+export declare const gctFieldTreeSelect: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    fieldMap: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    groupOptions: {
+        type: {
+            (arrayLength: number): IObject[];
+            (...items: IObject[]): IObject[];
+            new (arrayLength: number): IObject[];
+            new (...items: IObject[]): IObject[];
+            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: () => never[];
+    };
+    fieldNames: {
+        type: ObjectConstructor;
+        default: () => {
+            children: string;
+            title: string;
+            key: string;
+        };
+    };
+    maxLevel: {
+        type: NumberConstructor;
+        default: number;
+    };
+    getLabelByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    getFieldTypeByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    setLabelByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    fieldMap: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    groupOptions: {
+        type: {
+            (arrayLength: number): IObject[];
+            (...items: IObject[]): IObject[];
+            new (arrayLength: number): IObject[];
+            new (...items: IObject[]): IObject[];
+            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: () => never[];
+    };
+    fieldNames: {
+        type: ObjectConstructor;
+        default: () => {
+            children: string;
+            title: string;
+            key: string;
+        };
+    };
+    maxLevel: {
+        type: NumberConstructor;
+        default: number;
+    };
+    getLabelByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    getFieldTypeByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    setLabelByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    fieldMap: Record<string, any>;
+    groupOptions: IObject[];
+    fieldNames: Record<string, any>;
+    maxLevel: number;
+    getLabelByFun: Function;
+    getFieldTypeByFun: Function;
+    setLabelByFun: Function;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    treeRef: unknown;
+    editorInput: unknown;
+}, any>;
+export declare const gctFieldSortPopover: {
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        fieldMap: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        groupOptions: {
+            type: {
+                (arrayLength: number): IObject[];
+                (...items: IObject[]): IObject[];
+                new (arrayLength: number): IObject[];
+                new (...items: IObject[]): IObject[];
+                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: () => never[];
+        };
+        fieldNames: {
+            type: ObjectConstructor;
+            default: () => {
+                children: string;
+                title: string;
+                key: string;
+            };
+        };
+        getLabelByFun: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        getFieldTypeByFun: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        getFieldHiddenByFun: {
+            type: FunctionConstructor;
+            default: (data: IObject) => any;
+        };
+        changeFieldHiddenByFun: {
+            type: FunctionConstructor;
+            default: (data: IObject, v: boolean) => void;
+        };
+    }>> & Readonly<{
+        onChange?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        change: (...args: any[]) => void;
+    }, import('vue').PublicProps, {
+        fieldMap: Record<string, any>;
+        groupOptions: IObject[];
+        fieldNames: Record<string, any>;
+        getLabelByFun: Function;
+        getFieldTypeByFun: Function;
+        getFieldHiddenByFun: Function;
+        changeFieldHiddenByFun: Function;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        fieldMap: {
+            type: ObjectConstructor;
+            default: () => {};
+        };
+        groupOptions: {
+            type: {
+                (arrayLength: number): IObject[];
+                (...items: IObject[]): IObject[];
+                new (arrayLength: number): IObject[];
+                new (...items: IObject[]): IObject[];
+                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: () => never[];
+        };
+        fieldNames: {
+            type: ObjectConstructor;
+            default: () => {
+                children: string;
+                title: string;
+                key: string;
+            };
+        };
+        getLabelByFun: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        getFieldTypeByFun: {
+            type: FunctionConstructor;
+            default: () => void;
+        };
+        getFieldHiddenByFun: {
+            type: FunctionConstructor;
+            default: (data: IObject) => any;
+        };
+        changeFieldHiddenByFun: {
+            type: FunctionConstructor;
+            default: (data: IObject, v: boolean) => void;
+        };
+    }>> & Readonly<{
+        onChange?: ((...args: any[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {
+        fieldMap: Record<string, any>;
+        groupOptions: IObject[];
+        fieldNames: Record<string, any>;
+        getLabelByFun: Function;
+        getFieldTypeByFun: Function;
+        getFieldHiddenByFun: Function;
+        changeFieldHiddenByFun: Function;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+    fieldMap: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    groupOptions: {
+        type: {
+            (arrayLength: number): IObject[];
+            (...items: IObject[]): IObject[];
+            new (arrayLength: number): IObject[];
+            new (...items: IObject[]): IObject[];
+            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: () => never[];
+    };
+    fieldNames: {
+        type: ObjectConstructor;
+        default: () => {
+            children: string;
+            title: string;
+            key: string;
+        };
+    };
+    getLabelByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    getFieldTypeByFun: {
+        type: FunctionConstructor;
+        default: () => void;
+    };
+    getFieldHiddenByFun: {
+        type: FunctionConstructor;
+        default: (data: IObject) => any;
+    };
+    changeFieldHiddenByFun: {
+        type: FunctionConstructor;
+        default: (data: IObject, v: boolean) => void;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+}, string, {
+    fieldMap: Record<string, any>;
+    groupOptions: IObject[];
+    fieldNames: Record<string, any>;
+    getLabelByFun: Function;
+    getFieldTypeByFun: Function;
+    getFieldHiddenByFun: Function;
+    changeFieldHiddenByFun: Function;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+});

package/es/components/field-tree-select/index.mjs

@@ -0,0 +1,7 @@
+import field_tree_select_default from "./field-tree-select.vue.mjs";
+import field_sort_popover_default from "./field-sort-popover.vue.mjs";
+//#region src/components/field-tree-select/index.ts
+var gctFieldTreeSelect = field_tree_select_default;
+var gctFieldSortPopover = field_sort_popover_default;
+//#endregion
+export { gctFieldSortPopover, gctFieldTreeSelect };

package/es/components/icon-next-picker/icon-next-picker.vue_vue_type_script_setup_true_name_IconNextPicker_lang.mjs

@@ -1,8 +1,8 @@
 import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, nextTick, normalizeClass, normalizeStyle, openBlock, ref, renderList, resolveComponent, toDisplayString, unref, vModelText, withCtx, withDirectives } from "vue";
 import { cloneDeep, debounce } from "lodash-es";
 import { usePlatformConfigStore } from "@gct-paas/core";
-import { IconNamespaceEnum, IconNext, useIconAsset, useIconPark, useIconPlatform } from "@gct-paas/core-components";
 import { Empty, Form } from "ant-design-vue";
+import { IconNamespaceEnum, IconNext, useIconAsset, useIconPark, useIconPlatform } from "@gct-paas/core-components";
 import "overlayscrollbars-vue";
 //#region src/components/icon-next-picker/icon-next-picker.vue?vue&type=script&setup=true&name=IconNextPicker&lang.ts
 var _hoisted_1 = { class: "icon-picker-next" };

package/es/components/index.d.ts

@@ -6,13 +6,18 @@ import { default as CopyModuleKey } from './copy-module-key/copy-module-key.vue'
 import { ImageUpload } from './image-upload';
 import { FieldUpload } from './field-upload';
 import { default as PaasBpmnLog } from './paas-bpmn-log/paas-bpmn-log.vue';
-export { BaseButton, BasicButton, DoubleInput, CopyModuleKey, ImageUpload, FieldUpload, PaasBpmnLog, };
+import { default as FullScreen } from './FullScreen/full-screen.vue';
+export { BaseButton, BasicButton, DoubleInput, CopyModuleKey, ImageUpload, FieldUpload, PaasBpmnLog, FullScreen, };
 export { CodeEditor } from './code-editor/code-editor';
 export { ViewContainer } from './layout/view-container/view-container';
 export { Vue3GridDndItem } from './vue3-grid-dnd-item/vue3-grid-dnd-item';
+export { FieldCascader } from './field-cascader';
 export * from './UserPick';
 export * from './BpmnRuntime';
 export * from './I18nSelect';
+export * from './serial-number';
+export * from './field-tree-select';
+export { default as NumberRange } from './number-range/number-range.vue';
 declare const _default: {
     install(app: App): void;
 };

package/es/components/index.mjs

@@ -5,9 +5,12 @@ import "./copy-module-key/copy-module-key.vue.mjs";
 import "./image-upload/index.mjs";
 import "./field-upload/index.mjs";
 import "./paas-bpmn-log/paas-bpmn-log.vue.mjs";
+import "./FullScreen/full-screen.vue.mjs";
 import "./code-editor/code-editor.mjs";
 import "./layout/view-container/view-container.mjs";
 import "./vue3-grid-dnd-item/vue3-grid-dnd-item.mjs";
+import "./field-cascader/src/FieldCascader.vue.mjs";
+import "./field-cascader/index.mjs";
 import "./UserPick/src/constants/index.mjs";
 import "./UserPick/index.mjs";
 import "./BpmnRuntime/paas/paas-bpmn-runtime.vue.mjs";
@@ -20,6 +23,10 @@ import "./I18nSelect/src/i18n-select-input-form.vue.mjs";
 import "./I18nSelect/src/i18n-select-textarea.vue.mjs";
 import "./I18nSelect/src/i18n-select-textarea-form.vue.mjs";
 import "./I18nSelect/index.mjs";
+import "./serial-number/serial-number-container.vue.mjs";
+import "./serial-number/index.mjs";
+import "./field-tree-select/index.mjs";
+import "./number-range/number-range.vue.mjs";
 import { defineAsyncComponent } from "vue";
 //#region src/components/index.ts
 var components_default = { install(app) {

package/es/components/number-range/number-range.vue.d.ts

@@ -0,0 +1,85 @@
+import { PropType } from 'vue';
+type RangeNumber = number | undefined;
+type MaxObjProp = IObject | undefined;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'middle-text'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    rangeMin: {
+        type: PropType<RangeNumber>;
+        default: undefined;
+    };
+    rangeMax: {
+        type: PropType<RangeNumber>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxObj: {
+        type: PropType<MaxObjProp>;
+        default: undefined;
+    };
+    placeholderType: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:rangeMax": (...args: any[]) => void;
+    "update:rangeMin": (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    rangeMin: {
+        type: PropType<RangeNumber>;
+        default: undefined;
+    };
+    rangeMax: {
+        type: PropType<RangeNumber>;
+        default: undefined;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxObj: {
+        type: PropType<MaxObjProp>;
+        default: undefined;
+    };
+    placeholderType: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:rangeMax"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:rangeMin"?: ((...args: any[]) => any) | undefined;
+}>, {
+    rangeMin: RangeNumber;
+    rangeMax: RangeNumber;
+    disabled: boolean;
+    precision: number;
+    maxObj: MaxObjProp;
+    placeholderType: 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/number-range/number-range.vue.mjs

@@ -0,0 +1,7 @@
+import _plugin_vue_export_helper_default from "../../_virtual/_plugin-vue_export-helper.mjs";
+import number_range_vue_vue_type_script_setup_true_lang_default from "./number-range.vue_vue_type_script_setup_true_lang.mjs";
+import './number-range.vue_vue_type_style_index_0_scoped_283a5280_lang.css';/* empty css                                                                   */
+//#region src/components/number-range/number-range.vue
+var number_range_default = /* @__PURE__ */ _plugin_vue_export_helper_default(number_range_vue_vue_type_script_setup_true_lang_default, [["__scopeId", "data-v-283a5280"]]);
+//#endregion
+export { number_range_default as default };

package/es/components/number-range/number-range.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,91 @@
+import { computed, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, openBlock, renderSlot, resolveComponent, toDisplayString, unref } from "vue";
+import { t } from "@gct-paas/core";
+//#region src/components/number-range/number-range.vue?vue&type=script&setup=true&lang.ts
+var _hoisted_1 = { class: "range-box" };
+var _hoisted_2 = { class: "text" };
+var number_range_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "number-range",
+	props: {
+		rangeMin: {
+			type: [Number, void 0],
+			default: void 0
+		},
+		rangeMax: {
+			type: [Number, void 0],
+			default: void 0
+		},
+		disabled: {
+			type: Boolean,
+			default: false
+		},
+		precision: {
+			type: Number,
+			default: 0
+		},
+		maxObj: {
+			type: [Object, void 0],
+			default: void 0
+		},
+		placeholderType: {
+			type: String,
+			default: t("sys.model.value")
+		}
+	},
+	emits: [
+		"update:rangeMin",
+		"update:rangeMax",
+		"change"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const startMax = computed(() => {
+			return props.maxObj ? props.maxObj["start"] : void 0;
+		});
+		const endMax = computed(() => {
+			return props.maxObj ? props.maxObj["end"] : void 0;
+		});
+		const handleMinChange = (val) => {
+			emit("update:rangeMin", val);
+			emit("change", val);
+		};
+		const handleMaxChange = (val) => {
+			emit("update:rangeMax", val);
+			emit("change", val);
+		};
+		const emit = __emit;
+		return (_ctx, _cache) => {
+			const _component_a_input_number = resolveComponent("a-input-number");
+			return openBlock(), createElementBlock("div", _hoisted_1, [
+				createVNode(_component_a_input_number, {
+					value: __props.rangeMin,
+					min: 0,
+					max: startMax.value,
+					precision: __props.precision,
+					placeholder: `${unref(t)("sys.model.pleaseInputMin")}${__props.placeholderType}`,
+					onChange: handleMinChange
+				}, null, 8, [
+					"value",
+					"max",
+					"precision",
+					"placeholder"
+				]),
+				createElementVNode("div", _hoisted_2, [renderSlot(_ctx.$slots, "middle-text", {}, () => [createTextVNode(toDisplayString(_ctx.$t("sys.webRender.to")), 1)], true)]),
+				createVNode(_component_a_input_number, {
+					value: __props.rangeMax,
+					min: 0,
+					max: endMax.value,
+					precision: __props.precision,
+					placeholder: `${unref(t)("sys.model.pleaseInputMax")}${__props.placeholderType}`,
+					onChange: handleMaxChange
+				}, null, 8, [
+					"value",
+					"max",
+					"precision",
+					"placeholder"
+				])
+			]);
+		};
+	}
+});
+//#endregion
+export { number_range_vue_vue_type_script_setup_true_lang_default as default };

package/es/components/number-range/number-range.vue_vue_type_style_index_0_scoped_283a5280_lang.css

@@ -0,0 +1,8 @@
+.range-box[data-v-283a5280] {
+  display: flex;
+  align-items: center;
+}
+.range-box .text[data-v-283a5280] {
+  width: 90px;
+  text-align: center;
+}

package/es/components/overlay-scrollbars/gct-overlay-scrollbars.css

@@ -0,0 +1,72 @@
+@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 */
+[data-gct-os] .os-scrollbar {
+  transition: opacity 0.3s ease, visibility 0.3s ease;
+}
+[data-gct-os][data-gct-color] .os-scrollbar {
+  --os-handle-bg: var(--gct-h-bg);
+  --os-handle-bg-hover: color-mix(in srgb, var(--gct-h-bg) 80%, #000);
+  --os-handle-bg-active: color-mix(in srgb, var(--gct-h-bg) 60%, #000);
+}