@guodun/antdv 1.0.0

package/dist/types/components/role-selector/src/role.d.ts

@@ -0,0 +1,75 @@
+import { RoleSelectorOption } from './types';
+declare const RoleSelector: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly visible: BooleanConstructor;
+    readonly modelValue: {
+        readonly type: import('vue').PropType<RoleSelectorOption[] | RoleSelectorOption>;
+        readonly default: () => never[];
+    };
+    readonly type: {
+        readonly type: import('vue').PropType<"radio" | "checkbox">;
+        readonly default: "checkbox";
+    };
+    readonly options: {
+        readonly type: import('vue').PropType<RoleSelectorOption[]>;
+        readonly default: () => never[];
+    };
+    readonly isBuiltInRequest: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly http: {
+        readonly type: import('vue').PropType<any>;
+        readonly default: () => void;
+    };
+    readonly prefix: StringConstructor;
+    readonly hideSlot: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    'update:visible': (value: boolean) => boolean;
+    'update:modelValue': (value: RoleSelectorOption[] | RoleSelectorOption) => boolean;
+    confirm: (value: RoleSelectorOption[] | RoleSelectorOption) => boolean;
+    cancel: () => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly visible: BooleanConstructor;
+    readonly modelValue: {
+        readonly type: import('vue').PropType<RoleSelectorOption[] | RoleSelectorOption>;
+        readonly default: () => never[];
+    };
+    readonly type: {
+        readonly type: import('vue').PropType<"radio" | "checkbox">;
+        readonly default: "checkbox";
+    };
+    readonly options: {
+        readonly type: import('vue').PropType<RoleSelectorOption[]>;
+        readonly default: () => never[];
+    };
+    readonly isBuiltInRequest: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    readonly http: {
+        readonly type: import('vue').PropType<any>;
+        readonly default: () => void;
+    };
+    readonly prefix: StringConstructor;
+    readonly hideSlot: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: RoleSelectorOption | RoleSelectorOption[]) => any) | undefined;
+    onCancel?: (() => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onConfirm?: ((value: RoleSelectorOption | RoleSelectorOption[]) => any) | undefined;
+}>, {
+    readonly type: "checkbox" | "radio";
+    readonly visible: boolean;
+    readonly modelValue: RoleSelectorOption | RoleSelectorOption[];
+    readonly options: RoleSelectorOption[];
+    readonly http: any;
+    readonly isBuiltInRequest: boolean;
+    readonly hideSlot: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default RoleSelector;

package/dist/types/components/role-selector/src/types.d.ts

@@ -0,0 +1,55 @@
+import { ExtractPropTypes, PropType } from 'vue';
+export type RoleSelectorOption = {
+    label?: string;
+    value: string;
+};
+export declare const roleSelectorProps: {
+    readonly visible: BooleanConstructor;
+    readonly modelValue: {
+        readonly type: PropType<RoleSelectorOption[] | RoleSelectorOption>;
+        readonly default: () => never[];
+    };
+    readonly type: {
+        readonly type: PropType<"radio" | "checkbox">;
+        readonly default: "checkbox";
+    };
+    readonly options: {
+        readonly type: PropType<RoleSelectorOption[]>;
+        readonly default: () => never[];
+    };
+    /**
+     * 是否使用内置请求，内置请求会走用户中心即
+     * ${prefix}security/company/role/page?pageNum=1&pageSize=1000
+     */
+    readonly isBuiltInRequest: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+    /**
+     * axios 实例
+     */
+    readonly http: {
+        readonly type: PropType<any>;
+        readonly default: () => void;
+    };
+    /**
+     * 请求前缀，如 qy-user-service
+     */
+    readonly prefix: StringConstructor;
+    /**
+     * 是否隐藏插槽，只使用 modal
+     */
+    readonly hideSlot: {
+        readonly type: BooleanConstructor;
+        readonly default: false;
+    };
+};
+export declare const GTE_OPTIONS_URL = "/security/company/role/page?pageNum=1&pageSize=1000";
+export declare const roleSelectorEmits: {
+    'update:visible': (value: boolean) => boolean;
+    'update:modelValue': (value: RoleSelectorOption[] | RoleSelectorOption) => boolean;
+    confirm: (value: RoleSelectorOption[] | RoleSelectorOption) => boolean;
+    cancel: () => boolean;
+};
+export type RoleSelectorProps = ExtractPropTypes<typeof roleSelectorProps>;
+export type RoleSelectorEmits = typeof roleSelectorEmits;

package/dist/types/components/scale-virtual-list/component/scale-virtual-list.vue.d.ts

@@ -0,0 +1,31 @@
+import { UseVirtualListState } from '../hooks/useVirtualList';
+import { VirtualListProps, VirtualListSlot } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<VirtualListSlot> & VirtualListSlot;
+    refs: {
+        wrapperRef: HTMLDivElement;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<VirtualListProps, {
+    scrollTo: (index: number) => void;
+    scaleTo: (s: number) => void;
+    state: import('vue').Ref<UseVirtualListState, UseVirtualListState>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:state": (state: UseVirtualListState | null) => any;
+}, string, import('vue').PublicProps, Readonly<VirtualListProps> & Readonly<{
+    "onUpdate:state"?: ((state: UseVirtualListState | null) => any) | undefined;
+}>, {
+    itemClassName: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    wrapperRef: 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;
+    };
+};

package/dist/types/components/scale-virtual-list/component/types.d.ts

@@ -0,0 +1,12 @@
+import { UseVirtualListItem, UseVirtualListOptions } from '../hooks/useVirtualList';
+export interface VirtualListProps {
+    list: Array<any>;
+    option: UseVirtualListOptions;
+    itemClassName?: string;
+}
+export interface VirtualListSlot {
+    default: (props: {
+        item: UseVirtualListItem<any>;
+        index: number;
+    }) => any;
+}

package/dist/types/components/scale-virtual-list/hooks/useVirtualList.d.ts

@@ -0,0 +1,71 @@
+import { EventHookOn } from '@vueuse/shared';
+import { ComputedRef, MaybeRef, Ref, StyleValue } from 'vue';
+export interface UseVirtualListState {
+    start: number;
+    end: number;
+    current: number;
+    scale: number;
+}
+type RefState = Ref<UseVirtualListState>;
+type UseVirtualListItemSize = number | ((index: number) => number);
+export interface UseHorizontalVirtualListOptions extends UseVirtualListOptionsBase {
+    /**
+     * item width, accept a pixel value or a function that returns the width
+     *
+     * @default 0
+     */
+    itemWidth: UseVirtualListItemSize;
+}
+export interface UseVerticalVirtualListOptions extends UseVirtualListOptionsBase {
+    /**
+     * item height, accept a pixel value or a function that returns the height
+     *
+     * @default 0
+     */
+    itemHeight: UseVirtualListItemSize;
+}
+export interface UseVirtualListOptionsBase {
+    /**
+     * the extra buffer items outside of the view area
+     *
+     * @default 5
+     */
+    overscan?: number;
+}
+export type UseVirtualListOptions = UseHorizontalVirtualListOptions | UseVerticalVirtualListOptions;
+export interface UseVirtualListItem<T> {
+    data: T;
+    index: number;
+}
+export interface UseVirtualListReturn<T> {
+    onUpdate: EventHookOn<UseVirtualListState | null>;
+    state: RefState;
+    list: Ref<UseVirtualListItem<T>[]>;
+    scrollTo: (index: number) => void;
+    scaleTo: (s: number) => void;
+    containerProps: {
+        ref: Ref<HTMLElement | null>;
+        onScroll: () => void;
+        style: StyleValue;
+    };
+    wrapperProps: ComputedRef<{
+        style: {
+            height: string;
+            marginTop: string;
+            transform: string;
+            transformOrigin: string;
+        } | {
+            width: string;
+            height: string;
+            marginLeft: string;
+            display: string;
+            transform: string;
+            transformOrigin: string;
+        };
+    }>;
+}
+/**
+ * Please consider using [`vue-virtual-scroller`](https://github.com/Akryum/vue-virtual-scroller) if you are looking for more features.
+ */
+export declare function useVirtualList<T = any>(list: MaybeRef<T[]>, options: UseVirtualListOptions): UseVirtualListReturn<T>;
+export {};

package/dist/types/components/scale-virtual-list/index.d.ts

@@ -0,0 +1,48 @@
+export * from './style/index';
+export * from './component/types';
+export declare const GdAntScaleVirtualList: import('../utils/install').SFCWithInstall<{
+    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('.').VirtualListProps> & Readonly<{
+        "onUpdate:state"?: ((state: import('./hooks/useVirtualList').UseVirtualListState | null) => any) | undefined;
+    }>, {
+        scrollTo: (index: number) => void;
+        scaleTo: (s: number) => void;
+        state: import('vue').Ref<import('./hooks/useVirtualList').UseVirtualListState, import('./hooks/useVirtualList').UseVirtualListState>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        "update:state": (state: import('./hooks/useVirtualList').UseVirtualListState | null) => any;
+    }, import('vue').PublicProps, {
+        itemClassName: string;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        wrapperRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('.').VirtualListProps> & Readonly<{
+        "onUpdate:state"?: ((state: import('./hooks/useVirtualList').UseVirtualListState | null) => any) | undefined;
+    }>, {
+        scrollTo: (index: number) => void;
+        scaleTo: (s: number) => void;
+        state: import('vue').Ref<import('./hooks/useVirtualList').UseVirtualListState, import('./hooks/useVirtualList').UseVirtualListState>;
+    }, {}, {}, {}, {
+        itemClassName: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import('vue').ComponentOptionsBase<Readonly<import('.').VirtualListProps> & Readonly<{
+    "onUpdate:state"?: ((state: import('./hooks/useVirtualList').UseVirtualListState | null) => any) | undefined;
+}>, {
+    scrollTo: (index: number) => void;
+    scaleTo: (s: number) => void;
+    state: import('vue').Ref<import('./hooks/useVirtualList').UseVirtualListState, import('./hooks/useVirtualList').UseVirtualListState>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:state": (state: import('./hooks/useVirtualList').UseVirtualListState | null) => any;
+}, string, {
+    itemClassName: string;
+}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+    $slots: Readonly<import('.').VirtualListSlot> & import('.').VirtualListSlot;
+})>;
+export default GdAntScaleVirtualList;

package/dist/types/components/scroll-bar/index.d.ts

@@ -0,0 +1,46 @@
+export * from './src/types';
+export declare const GdAntScrollBar: import('../utils/install').SFCWithInstall<import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly container: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly content: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: import('vue').PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+    readonly trigger: {
+        readonly type: import('vue').PropType<"none" | "hover" | "always">;
+        readonly default: "hover";
+    };
+}>, {
+    showYBarRef: import('vue').ComputedRef<boolean>;
+    showXBarRef: import('vue').ComputedRef<boolean>;
+    sync: () => void;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    handleXScrollWheel: (e: WheelEvent) => void;
+    contentRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    yRailRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    xRailRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    containerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    contentHeightRef: import('vue').Ref<Nullable<number>, Nullable<number>>;
+    containerHeightRef: import('vue').Ref<Nullable<number>, Nullable<number>>;
+    needYBarRef: import('vue').ComputedRef<boolean>;
+    needXBarRef: import('vue').ComputedRef<boolean>;
+    yBarSizePxRef: import('vue').ComputedRef<string>;
+    handleYScrollMouseDown: (e: MouseEvent) => void;
+    handleXScrollMouseDown: (e: MouseEvent) => void;
+    yBarTopPxRef: import('vue').ComputedRef<string>;
+    handleScroll: (e: Event) => void;
+    xBarSizePxRef: import('vue').ComputedRef<string>;
+    xBarLeftPxRef: import('vue').ComputedRef<string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly container: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly content: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: import('vue').PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+    readonly trigger: {
+        readonly type: import('vue').PropType<"none" | "hover" | "always">;
+        readonly default: "hover";
+    };
+}>> & Readonly<{}>, {
+    readonly xScrollable: boolean;
+    readonly trigger: "none" | "hover" | "always";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>>;
+export default GdAntScrollBar;

package/dist/types/components/scroll-bar/src/scroll-bar.d.ts

@@ -0,0 +1,45 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    readonly container: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly content: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: import('vue').PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+    readonly trigger: {
+        readonly type: import('vue').PropType<"none" | "hover" | "always">;
+        readonly default: "hover";
+    };
+}>, {
+    showYBarRef: import('vue').ComputedRef<boolean>;
+    showXBarRef: import('vue').ComputedRef<boolean>;
+    sync: () => void;
+    handleMouseEnter: () => void;
+    handleMouseLeave: () => void;
+    handleXScrollWheel: (e: WheelEvent) => void;
+    contentRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    yRailRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    xRailRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    containerRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    contentHeightRef: import('vue').Ref<Nullable<number>, Nullable<number>>;
+    containerHeightRef: import('vue').Ref<Nullable<number>, Nullable<number>>;
+    needYBarRef: import('vue').ComputedRef<boolean>;
+    needXBarRef: import('vue').ComputedRef<boolean>;
+    yBarSizePxRef: import('vue').ComputedRef<string>;
+    handleYScrollMouseDown: (e: MouseEvent) => void;
+    handleXScrollMouseDown: (e: MouseEvent) => void;
+    yBarTopPxRef: import('vue').ComputedRef<string>;
+    handleScroll: (e: Event) => void;
+    xBarSizePxRef: import('vue').ComputedRef<string>;
+    xBarLeftPxRef: import('vue').ComputedRef<string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    readonly container: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly content: import('vue').PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: import('vue').PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+    readonly trigger: {
+        readonly type: import('vue').PropType<"none" | "hover" | "always">;
+        readonly default: "hover";
+    };
+}>> & Readonly<{}>, {
+    readonly xScrollable: boolean;
+    readonly trigger: "none" | "hover" | "always";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/types/components/scroll-bar/src/types.d.ts

@@ -0,0 +1,11 @@
+import { PropType } from 'vue';
+export declare const scrollbarProps: {
+    readonly container: PropType<() => HTMLElement | null | undefined>;
+    readonly content: PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+    readonly trigger: {
+        readonly type: PropType<"none" | "hover" | "always">;
+        readonly default: "hover";
+    };
+};

package/dist/types/components/utils/install.d.ts

@@ -0,0 +1,8 @@
+import { App, Directive, Plugin, PropType } from 'vue';
+export type SFCWithInstall<T> = T & Plugin;
+export declare function withInstall<T>(main: T): SFCWithInstall<T>;
+export declare function withInstallDirectives<T extends Directive>(main: T, name: string): {
+    install: (app: App) => void;
+    directive: T;
+};
+export declare const definePropType: <T>(val: any) => PropType<T>;

package/dist/types/components/utils/tool.d.ts

@@ -0,0 +1 @@
+export declare function rafThrottle(fn: (...arg: any[]) => any): (this: any, ...args: any[]) => void;

package/dist/types/extract.d.ts

@@ -0,0 +1,2 @@
+export * from './hooks';
+export * from './components/utils/install';

package/dist/types/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export * from './useProForm';
+export * from './useModelValue';
+export * from './use-namespace';

package/dist/types/hooks/use-namespace/index.d.ts

@@ -0,0 +1,23 @@
+import { InjectionKey, Ref } from 'vue';
+export declare const defaultNamespace = "gd-ant";
+export declare const namespaceContextKey: InjectionKey<Ref<string | undefined>>;
+export declare function useGetDerivedNamespace(namespaceOverrides?: Ref<string | undefined>): import('vue').ComputedRef<string>;
+export declare function useNamespace(block: string, namespaceOverrides?: Ref<string | undefined>): {
+    namespace: import('vue').ComputedRef<string>;
+    b: (blockSuffix?: string) => string;
+    e: (element?: string) => string;
+    m: (modifier?: string) => string;
+    be: (blockSuffix?: string, element?: string) => string;
+    em: (element?: string, modifier?: string) => string;
+    bm: (blockSuffix?: string, modifier?: string) => string;
+    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+    is: {
+        (name: string, state: boolean | undefined): string;
+        (name: string): string;
+    };
+    cssVar: (object: Record<string, string>) => Record<string, string>;
+    cssVarName: (name: string) => string;
+    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+    cssVarBlockName: (name: string) => string;
+};
+export type UseNamespaceReturn = ReturnType<typeof useNamespace>;

package/dist/types/hooks/useModelValue.d.ts

@@ -0,0 +1,3 @@
+export declare function useModelValue(modelValue: any, fn: Function): {
+    isInternalUpdate: import('vue').Ref<boolean, boolean>;
+};

package/dist/types/hooks/useProForm.d.ts

@@ -0,0 +1,14 @@
+import { FormInstance } from 'ant-design-vue';
+import { Ref } from 'vue';
+export interface ModalMethods {
+    setFormData: (data: object) => void;
+}
+export declare function useProForm<T>(init: T): {
+    ruleForm: Ref<T, T>;
+    formRef: Ref<FormInstance | undefined, FormInstance | undefined>;
+    resetForm: () => void;
+};
+export declare function useProFormInit(): [
+    (methods: ModalMethods) => void,
+    ModalMethods
+];

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './components';

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@guodun/antdv",
+  "version": "1.0.0",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/es/index.mjs",
+      "require": "./dist/lib/index.js"
+    },
+    "./es": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/es/index.mjs"
+    },
+    "./lib": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/lib/index.js"
+    },
+    "./src/*": "./src/*.js",
+    "./*": "./*"
+  },
+  "main": "./dist/lib/index.js",
+  "module": "./dist/es/index.mjs",
+  "types": "./dist/type/index.d.ts",
+  "sideEffects": [
+    "**/*.css",
+    "**/*.scss",
+    "**/style/**"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.18"
+  },
+  "devDependencies": {
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^24.12.0",
+    "@vitejs/plugin-vue": "^6.0.5",
+    "@vitejs/plugin-vue-jsx": "^5.1.5",
+    "@vue/tsconfig": "^0.9.0",
+    "sass": "^1.93.2",
+    "typescript": "~5.9.3",
+    "vite": "^8.0.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vue-tsc": "^3.2.5",
+    "@guodun/tsconfig": "^1.0.0",
+    "@guodun/theme": "^1.0.1"
+  },
+  "dependencies": {
+    "@vueuse/core": "^14.2.1",
+    "@vueuse/shared": "^14.2.1",
+    "ant-design-vue": "^4.2.6",
+    "evtd": "^0.2.4",
+    "lodash-es": "^4.17.21",
+    "mitt": "^3.0.1",
+    "vue": "^3.5.18",
+    "@guodun/utils": "^1.0.0"
+  },
+  "scripts": {
+    "build": "vite build && vite build --config vite.theme.config.ts"
+  }
+}