@cyberpunk-vue/components 1.12.6 → 1.13.1

package/dist/pagination/index.d.ts

@@ -290,7 +290,7 @@ export declare const CpPagination: import('../utils').SFCWithInstall<{
         sizes?(_: {
             pageSize: number;
             pageSizes: number[];
-            options: import('..').DropdownOption[];
+            options: import('..').SelectOption[];
             onChange: (val: string | number) => void;
             disabled: boolean;
             type: import('.').PaginationType;

package/dist/pagination/src/pagination.vue.d.ts

@@ -1,11 +1,11 @@
-import { DropdownOption } from '../../dropdown/src/dropdown';
+import { SelectOption } from '../../select/src/select';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
         sizes?(_: {
             pageSize: number;
             pageSizes: number[];
-            options: DropdownOption[];
+            options: SelectOption[];
             onChange: (val: string | number) => void;
             disabled: boolean;
             type: import('./pagination').PaginationType;

package/dist/segmented/index.d.ts

@@ -10,7 +10,173 @@
  *
  * @see {@link SegmentedProps} 查看所有可用属性
  */
-export declare const CpSegmented: import('../utils').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+export declare const CpSegmented: import('../utils').SFCWithInstall<{
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+        readonly modelValue: {
+            readonly type: import('vue').PropType<import('.').SegmentedValueType>;
+            readonly default: undefined;
+        };
+        readonly options: {
+            readonly type: import('vue').PropType<(string | number | import('.').SegmentedOption)[]>;
+            readonly default: () => never[];
+        };
+        readonly type: {
+            readonly type: import('vue').PropType<import('.').SegmentedType>;
+            readonly default: "default";
+        };
+        readonly variant: {
+            readonly type: import('vue').PropType<import('.').SegmentedVariant>;
+            readonly default: "solid";
+        };
+        readonly size: {
+            readonly type: import('vue').PropType<import('.').SegmentedSize>;
+            readonly default: "md";
+        };
+        readonly shape: {
+            readonly type: import('vue').PropType<import('.').SegmentedShape>;
+            readonly default: "clip";
+        };
+        readonly color: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+        readonly disabled: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly block: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly clearable: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly vertical: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly wrap: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly beforeChange: {
+            readonly type: import('vue').PropType<(next: import('.').SegmentedValueType | undefined, current: import('.').SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void>;
+            readonly default: undefined;
+        };
+    }>> & Readonly<{
+        onClear?: (() => any) | undefined;
+        onChange?: ((value: import('.').SegmentedValueType | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('.').SegmentedValueType | undefined) => any) | undefined;
+    }>, {
+        updateIndicator: () => void;
+        focus: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        clear: () => void;
+        change: (value: import('.').SegmentedValueType | undefined) => void;
+        "update:modelValue": (value: import('.').SegmentedValueType | undefined) => void;
+    }, import('vue').PublicProps, {
+        readonly size: import('@cyberpunk-vue/hooks').Size;
+        readonly type: import('.').SegmentedType;
+        readonly color: string;
+        readonly variant: import('.').SegmentedVariant;
+        readonly disabled: boolean;
+        readonly block: boolean;
+        readonly shape: import('.').SegmentedShape;
+        readonly modelValue: import('.').SegmentedValueType;
+        readonly clearable: boolean;
+        readonly vertical: boolean;
+        readonly wrap: boolean;
+        readonly beforeChange: (next: import('.').SegmentedValueType | undefined, current: import('.').SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void;
+        readonly options: (string | number | import('.').SegmentedOption)[];
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        trackRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('vue').ExtractPropTypes<{
+        readonly modelValue: {
+            readonly type: import('vue').PropType<import('.').SegmentedValueType>;
+            readonly default: undefined;
+        };
+        readonly options: {
+            readonly type: import('vue').PropType<(string | number | import('.').SegmentedOption)[]>;
+            readonly default: () => never[];
+        };
+        readonly type: {
+            readonly type: import('vue').PropType<import('.').SegmentedType>;
+            readonly default: "default";
+        };
+        readonly variant: {
+            readonly type: import('vue').PropType<import('.').SegmentedVariant>;
+            readonly default: "solid";
+        };
+        readonly size: {
+            readonly type: import('vue').PropType<import('.').SegmentedSize>;
+            readonly default: "md";
+        };
+        readonly shape: {
+            readonly type: import('vue').PropType<import('.').SegmentedShape>;
+            readonly default: "clip";
+        };
+        readonly color: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+        readonly disabled: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly block: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly clearable: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly vertical: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly wrap: {
+            readonly type: BooleanConstructor;
+            readonly default: false;
+        };
+        readonly beforeChange: {
+            readonly type: import('vue').PropType<(next: import('.').SegmentedValueType | undefined, current: import('.').SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void>;
+            readonly default: undefined;
+        };
+    }>> & Readonly<{
+        onClear?: (() => any) | undefined;
+        onChange?: ((value: import('.').SegmentedValueType | undefined) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: import('.').SegmentedValueType | undefined) => any) | undefined;
+    }>, {
+        updateIndicator: () => void;
+        focus: () => void;
+    }, {}, {}, {}, {
+        readonly size: import('@cyberpunk-vue/hooks').Size;
+        readonly type: import('.').SegmentedType;
+        readonly color: string;
+        readonly variant: import('.').SegmentedVariant;
+        readonly disabled: boolean;
+        readonly block: boolean;
+        readonly shape: import('.').SegmentedShape;
+        readonly modelValue: import('.').SegmentedValueType;
+        readonly clearable: boolean;
+        readonly vertical: boolean;
+        readonly wrap: boolean;
+        readonly beforeChange: (next: import('.').SegmentedValueType | undefined, current: import('.').SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void;
+        readonly options: (string | number | import('.').SegmentedOption)[];
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
     readonly modelValue: {
         readonly type: import('vue').PropType<import('.').SegmentedValueType>;
         readonly default: undefined;
@@ -51,58 +217,30 @@ export declare const CpSegmented: import('../utils').SFCWithInstall<import('vue'
         readonly type: BooleanConstructor;
         readonly default: false;
     };
-}>, {
-    updateIndicator: () => void;
-}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    clear: () => void;
-    change: (value: import('.').SegmentedValueType | undefined) => void;
-    "update:modelValue": (value: import('.').SegmentedValueType | undefined) => void;
-}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
-    readonly modelValue: {
-        readonly type: import('vue').PropType<import('.').SegmentedValueType>;
-        readonly default: undefined;
-    };
-    readonly options: {
-        readonly type: import('vue').PropType<(string | number | import('.').SegmentedOption)[]>;
-        readonly default: () => never[];
-    };
-    readonly type: {
-        readonly type: import('vue').PropType<import('.').SegmentedType>;
-        readonly default: "default";
-    };
-    readonly variant: {
-        readonly type: import('vue').PropType<import('.').SegmentedVariant>;
-        readonly default: "solid";
-    };
-    readonly size: {
-        readonly type: import('vue').PropType<import('.').SegmentedSize>;
-        readonly default: "md";
-    };
-    readonly shape: {
-        readonly type: import('vue').PropType<import('.').SegmentedShape>;
-        readonly default: "clip";
-    };
-    readonly color: {
-        readonly type: StringConstructor;
-        readonly default: "";
-    };
-    readonly disabled: {
+    readonly vertical: {
         readonly type: BooleanConstructor;
         readonly default: false;
     };
-    readonly block: {
+    readonly wrap: {
         readonly type: BooleanConstructor;
         readonly default: false;
     };
-    readonly clearable: {
-        readonly type: BooleanConstructor;
-        readonly default: false;
+    readonly beforeChange: {
+        readonly type: import('vue').PropType<(next: import('.').SegmentedValueType | undefined, current: import('.').SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void>;
+        readonly default: undefined;
     };
 }>> & Readonly<{
     onClear?: (() => any) | undefined;
     onChange?: ((value: import('.').SegmentedValueType | undefined) => any) | undefined;
     "onUpdate:modelValue"?: ((value: import('.').SegmentedValueType | undefined) => any) | undefined;
 }>, {
+    updateIndicator: () => void;
+    focus: () => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => void;
+    change: (value: import('.').SegmentedValueType | undefined) => void;
+    "update:modelValue": (value: import('.').SegmentedValueType | undefined) => void;
+}, string, {
     readonly size: import('@cyberpunk-vue/hooks').Size;
     readonly type: import('.').SegmentedType;
     readonly color: string;
@@ -112,10 +250,19 @@ export declare const CpSegmented: import('../utils').SFCWithInstall<import('vue'
     readonly shape: import('.').SegmentedShape;
     readonly modelValue: import('.').SegmentedValueType;
     readonly clearable: boolean;
+    readonly vertical: boolean;
+    readonly wrap: boolean;
+    readonly beforeChange: (next: import('.').SegmentedValueType | undefined, current: import('.').SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void;
     readonly options: (string | number | import('.').SegmentedOption)[];
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
-    trackRef: HTMLDivElement;
-}, HTMLDivElement>>;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: {
+        option?(_: {
+            option: import('.').SegmentedOption;
+            index: number;
+            active: boolean;
+        }): any;
+    };
+})>;
 export default CpSegmented;
 export * from './src/segmented';
 export type { SegmentedInstance } from './src/instance';

package/dist/segmented/src/segmented.d.ts

@@ -152,6 +152,38 @@ export declare const segmentedProps: {
         readonly type: BooleanConstructor;
         readonly default: false;
     };
+    /**
+     * 是否纵向排列选项
+     * 启用后选项按列堆叠，键盘导航使用 ↑/↓
+     * @default false
+     */
+    readonly vertical: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /**
+     * 是否允许选项换行（仅横向布局生效）
+     * 启用后空间不足时选项会自动换到下一行，指示器跟随激活项所在行
+     * @default false
+     */
+    readonly wrap: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /**
+     * 切换前钩子
+     *
+     * 返回 `false` 或 reject 的 Promise 会取消本次切换；
+     * 返回 `true`、其他值或 resolve 的 Promise 会执行切换。
+     * 适合在切换前做权限校验、未保存提示等。
+     *
+     * @param next - 即将切换到的目标值（清空时为 `undefined`）
+     * @param current - 当前值
+     */
+    readonly beforeChange: {
+        readonly type: PropType<(next: SegmentedValueType | undefined, current: SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void>;
+        readonly default: undefined;
+    };
 };
 export type SegmentedProps = ExtractPropTypes<typeof segmentedProps>;
 /**

package/dist/segmented/src/segmented.vue.d.ts

@@ -1,5 +1,20 @@
 import { SegmentedOption, SegmentedValueType } from './segmented';
-declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        option?(_: {
+            option: SegmentedOption;
+            index: number;
+            active: boolean;
+        }): any;
+    };
+    refs: {
+        trackRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
     readonly modelValue: {
         readonly type: import('vue').PropType<SegmentedValueType>;
         readonly default: undefined;
@@ -40,9 +55,23 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         readonly type: BooleanConstructor;
         readonly default: false;
     };
+    readonly vertical: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly wrap: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly beforeChange: {
+        readonly type: import('vue').PropType<(next: SegmentedValueType | undefined, current: SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void>;
+        readonly default: undefined;
+    };
 }>, {
     /** @description 更新滑块位置 */
     updateIndicator: () => void;
+    /** @description 聚焦当前激活项（无激活项则聚焦第一个可用项） */
+    focus: () => void;
 }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     clear: () => void;
     change: (value: SegmentedValueType | undefined) => void;
@@ -88,6 +117,18 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
         readonly type: BooleanConstructor;
         readonly default: false;
     };
+    readonly vertical: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly wrap: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly beforeChange: {
+        readonly type: import('vue').PropType<(next: SegmentedValueType | undefined, current: SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void>;
+        readonly default: undefined;
+    };
 }>> & Readonly<{
     onClear?: (() => any) | undefined;
     onChange?: ((value: SegmentedValueType | undefined) => any) | undefined;
@@ -102,8 +143,17 @@ declare const _default: import('vue').DefineComponent<import('vue').ExtractPropT
     readonly shape: import('./segmented').SegmentedShape;
     readonly modelValue: SegmentedValueType;
     readonly clearable: boolean;
+    readonly vertical: boolean;
+    readonly wrap: boolean;
+    readonly beforeChange: (next: SegmentedValueType | undefined, current: SegmentedValueType | undefined) => boolean | Promise<boolean | void> | void;
     readonly options: (string | number | SegmentedOption)[];
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
     trackRef: HTMLDivElement;
 }, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};