ep-craft 0.1.19 → 0.1.21

package/dist/utils/types.d.ts

@@ -0,0 +1,9 @@
+export { isArray, isFunction, isObject, isString, isDate, isPromise, isSymbol, isPlainObject, } from '@vue/shared';
+export declare const isUndefined: (val: any) => val is undefined;
+export declare const isBoolean: (val: any) => val is boolean;
+export declare const isNumber: (val: any) => val is number;
+export declare const isEmpty: (val: unknown) => boolean;
+export declare const isElement: (e: unknown) => e is Element;
+export declare const isPropAbsent: (prop: unknown) => prop is null | undefined;
+export declare const isStringNumber: (val: string) => boolean;
+export declare const isWindow: (val: unknown) => val is Window;

package/dist/utils/types.js

@@ -0,0 +1,16 @@
+import { isString as t } from "../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { isArray as u, isDate as a, isFunction as b, isObject as c, isPlainObject as l, isPromise as p } from "../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+const r = (e) => typeof e == "boolean", i = (e) => typeof e == "number", s = (e) => typeof Element > "u" ? !1 : e instanceof Element, o = (e) => t(e) ? !Number.isNaN(Number(e)) : !1;
+export {
+  u as isArray,
+  r as isBoolean,
+  a as isDate,
+  s as isElement,
+  b as isFunction,
+  i as isNumber,
+  c as isObject,
+  l as isPlainObject,
+  p as isPromise,
+  t as isString,
+  o as isStringNumber
+};

package/dist/utils/typescript.d.ts

@@ -0,0 +1,93 @@
+import type * as CSS from 'csstype';
+export declare const mutable: <T extends readonly any[] | Record<string, unknown>>(val: T) => Mutable<typeof val>;
+export type Mutable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type HTMLElementCustomized<T> = HTMLElement & T;
+/**
+ * @deprecated stop to use null
+ * @see {@link https://github.com/sindresorhus/meta/discussions/7}
+ */
+export type Nullable<T> = T | null;
+export type Arrayable<T> = T | T[];
+export type Awaitable<T> = Promise<T> | T;
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type BrowserNativeObject = Date | FileList | File | Blob | RegExp;
+/**
+ * Check whether it is tuple
+ *
+ * 检查是否为元组
+ *
+ * @example
+ * IsTuple<[1, 2, 3]> => true
+ * IsTuple<Array[number]> => false
+ */
+type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
+/**
+ * Array method key
+ *
+ * 数组方法键
+ */
+type ArrayMethodKey = keyof any[];
+/**
+ * Tuple index key
+ *
+ * 元组下标键
+ *
+ * @example
+ * TupleKey<[1, 2, 3]> => '0' | '1' | '2'
+ */
+type TupleKey<T extends ReadonlyArray<any>> = Exclude<keyof T, ArrayMethodKey>;
+/**
+ * Array index key
+ *
+ * 数组下标键
+ */
+type ArrayKey = number;
+/**
+ * Helper type for recursively constructing paths through a type
+ *
+ * 用于通过一个类型递归构建路径的辅助类型
+ */
+type PathImpl<K extends string | number, V> = V extends Primitive | BrowserNativeObject ? `${K}` : `${K}` | `${K}.${Path<V>}`;
+/**
+ * Type which collects all paths through a type
+ *
+ * 通过一个类型收集所有路径的类型
+ *
+ * @see {@link FieldPath}
+ */
+type Path<T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKey<T>]-?: PathImpl<Exclude<K, symbol>, T[K]>;
+}[TupleKey<T>] : PathImpl<ArrayKey, V> : {
+    [K in keyof T]-?: PathImpl<Exclude<K, symbol>, T[K]>;
+}[keyof T];
+/**
+ * Type which collects all paths through a type
+ *
+ * 通过一个类型收集所有路径的类型
+ *
+ * @example
+ * FieldPath<{ 1: number; a: number; b: string; c: { d: number; e: string }; f: [{ value: string }]; g: { value: string }[]; h: Date; i: FileList; j: File; k: Blob; l: RegExp }> => '1' | 'a' | 'b' | 'c' | 'f' | 'g' | 'c.d' | 'c.e' | 'f.0' | 'f.0.value' | 'g.number' | 'g.number.value' | 'h' | 'i' | 'j' | 'k' | 'l'
+ */
+export type FieldPath<T> = T extends object ? Path<T> : never;
+/**
+ * csstype 是 vue的依赖，因此，直接从vue中导入CSSProperties会导致ts类型解析错误，参考 https://github.com/pnpm/pnpm/issues/7453，因此，我们直接安装csstype，并从csstype中导入CSSProperties
+ *
+ * csstype is a dependency of vue, so importing CSSProperties directly from vue will cause ts type parsing errors, see https://github.com/pnpm/pnpm/issues/7453. Therefore, we directly install csstype and import CSSProperties from csstype.
+ */
+export interface CSSProperties extends CSS.Properties<string | number>, CSS.PropertiesHyphen<string | number> {
+    /**
+     * The index signature was removed to enable closed typing for style
+     * using CSSType. You're able to use type assertion or module augmentation
+     * to add properties or an index signature of your own.
+     *
+     * For examples and more information, visit:
+     * https://github.com/frenic/csstype#what-should-i-do-when-i-get-type-errors
+     */
+    [v: `--${string}`]: string | number | undefined;
+}
+export type ObjectFit = CSSProperties['objectFit'];
+export type ZIndexType = CSSProperties['zIndex'];
+export type AlignItems = CSSProperties['alignItems'];
+export {};

package/dist/utils/vue/global-node.d.ts

@@ -0,0 +1,3 @@
+export declare function createGlobalNode(id?: string): HTMLDivElement;
+export declare function removeGlobalNode(el: HTMLElement): void;
+export declare function changeGlobalNodesTarget(el: HTMLElement): void;

package/dist/utils/vue/icon.d.ts

@@ -0,0 +1,27 @@
+import { Loading } from '@element-plus/icons-vue';
+import type { Component } from 'vue';
+export type IconPropType = string | Component;
+export declare const iconPropType: import("vue").PropType<string | Component>;
+export declare const CloseComponents: {
+    Close: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export declare const TypeComponents: {
+    Close: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    SuccessFilled: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    InfoFilled: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    WarningFilled: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    CircleCloseFilled: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export declare const TypeComponentsMap: {
+    primary: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    success: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    warning: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    error: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    info: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export declare const ValidateComponentsMap: {
+    validating: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    success: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    error: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+};
+export type IconComponent = typeof Loading;

package/dist/utils/vue/index.d.ts

@@ -0,0 +1,9 @@
+import { changeGlobalNodesTarget, createGlobalNode, removeGlobalNode } from "./global-node";
+import { buildProp, buildProps, definePropType, epPropKey, isEpProp } from "./props/runtime";
+import { CloseComponents, TypeComponents, TypeComponentsMap, ValidateComponentsMap, iconPropType } from "./icon";
+import { withInstall, withInstallDirective, withInstallFunction, withNoopInstall, withPropsDefaultsSetter } from "./install";
+import { composeRefs } from "./refs";
+import { getComponentSize } from "./size";
+import { isValidComponentSize, isValidDatePickType } from "./validator";
+import { PatchFlags, flattedChildren, getFirstValidNode, getNormalizedProps, isComment, isFragment, isTemplate, isText, isValidElementNode, renderBlock, renderIf } from "./vnode";
+export { CloseComponents, PatchFlags, TypeComponents, TypeComponentsMap, ValidateComponentsMap, buildProp, buildProps, changeGlobalNodesTarget, composeRefs, createGlobalNode, definePropType, epPropKey, flattedChildren, getComponentSize, getFirstValidNode, getNormalizedProps, iconPropType, isComment, isEpProp, isFragment, isTemplate, isText, isValidComponentSize, isValidDatePickType, isValidElementNode, removeGlobalNode, renderBlock, renderIf, withInstall, withInstallDirective, withInstallFunction, withNoopInstall, withPropsDefaultsSetter };

package/dist/utils/vue/install.d.ts

@@ -0,0 +1,7 @@
+import type { Directive } from 'vue';
+import type { SFCInstallWithContext, SFCWithInstall } from './typescript';
+export declare const withPropsDefaultsSetter: (target: any) => void;
+export declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;
+export declare const withInstallFunction: <T>(fn: T, name: string) => SFCInstallWithContext<T>;
+export declare const withInstallDirective: <T extends Directive>(directive: T, name: string) => SFCWithInstall<T>;
+export declare const withNoopInstall: <T>(component: T) => SFCWithInstall<T>;

package/dist/utils/vue/install.js

@@ -0,0 +1,34 @@
+import { isArray as f, hasOwn as c } from "../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import i from "../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/fromPairs.js";
+import l from "../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/isPlainObject.js";
+const a = (o) => {
+  const s = o.props, t = f(s) ? i(s.map((r) => [r, {}])) : s;
+  o.setPropsDefaults = (r) => {
+    if (t) {
+      for (const [e, n] of Object.entries(r)) {
+        const p = t[e];
+        if (c(t, e)) {
+          if (l(p)) {
+            t[e] = {
+              ...p,
+              default: n
+            };
+            continue;
+          }
+          t[e] = {
+            type: p,
+            default: n
+          };
+        }
+      }
+      o.props = t;
+    }
+  };
+}, P = (o, s) => (o.install = (t) => {
+  for (const r of [o, ...Object.values({})])
+    t.component(r.name, r);
+}, a(o), o);
+export {
+  P as withInstall,
+  a as withPropsDefaultsSetter
+};

package/dist/utils/vue/props/index.d.ts

@@ -0,0 +1,2 @@
+import { buildProp, buildProps, definePropType, epPropKey, isEpProp } from "./runtime";
+export { buildProp, buildProps, definePropType, epPropKey, isEpProp };

package/dist/utils/vue/props/runtime.d.ts

@@ -0,0 +1,29 @@
+import type { PropType } from 'vue';
+import type { EpProp, EpPropConvert, EpPropFinalized, EpPropInput, EpPropMergeType, IfEpProp, IfNativePropType, NativePropType } from './types';
+export declare const epPropKey = "__epPropKey";
+export declare const definePropType: <T>(val: any) => PropType<T>;
+export declare const isEpProp: (val: unknown) => val is EpProp<any, any, any>;
+/**
+ * @description Build prop. It can better optimize prop types
+ * @description 生成 prop，能更好地优化类型
+ * @example
+  // limited options
+  // the type will be PropType<'light' | 'dark'>
+  buildProp({
+    type: String,
+    values: ['light', 'dark'],
+  } as const)
+  * @example
+  // limited options and other types
+  // the type will be PropType<'small' | 'large' | number>
+  buildProp({
+    type: [String, Number],
+    values: ['small', 'large'],
+    validator: (val: unknown): val is number => typeof val === 'number',
+  } as const)
+  @link see more: https://github.com/element-plus/element-plus/pull/3341
+ */
+export declare const buildProp: <Type = never, Value = never, Validator = never, Default extends EpPropMergeType<Type, Value, Validator> = never, Required extends boolean = false>(prop: EpPropInput<Type, Value, Validator, Default, Required>, key?: string) => EpPropFinalized<Type, Value, Validator, Default, Required>;
+export declare const buildProps: <Props extends Record<string, {
+    [epPropKey]: true;
+} | NativePropType | EpPropInput<any, any, any, any, any>>>(props: Props) => { [K in keyof Props]: IfEpProp<Props[K], Props[K], IfNativePropType<Props[K], Props[K], EpPropConvert<Props[K]>>>; };

package/dist/utils/vue/props/runtime.js

@@ -0,0 +1,36 @@
+import { warn as v } from "vue";
+import { isObject as d, hasOwn as s } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import w from "../../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/fromPairs.js";
+const u = "__epPropKey", h = (e) => e, y = (e) => d(e) && !!e[u], O = (e, t) => {
+  if (!d(e) || y(e)) return e;
+  const { values: r, required: p, default: n, type: c, validator: a } = e, f = {
+    type: c,
+    required: !!p,
+    validator: r || a ? (l) => {
+      let i = !1, o = [];
+      if (r && (o = Array.from(r), s(e, "default") && o.push(n), i || (i = o.includes(l))), a && (i || (i = a(l))), !i && o.length > 0) {
+        const m = [...new Set(o)].map((P) => JSON.stringify(P)).join(", ");
+        v(
+          `Invalid prop: validation failed${t ? ` for prop "${t}"` : ""}. Expected one of [${m}], got value ${JSON.stringify(
+            l
+          )}.`
+        );
+      }
+      return i;
+    } : void 0,
+    [u]: !0
+  };
+  return s(e, "default") && (f.default = n), f;
+}, j = (e) => w(
+  Object.entries(e).map(([t, r]) => [
+    t,
+    O(r, t)
+  ])
+);
+export {
+  O as buildProp,
+  j as buildProps,
+  h as definePropType,
+  u as epPropKey,
+  y as isEpProp
+};

package/dist/utils/vue/props/types.d.ts

@@ -0,0 +1,85 @@
+import type { IfNever, UnknownToNever, WritableArray } from './util';
+import { epPropKey } from './runtime';
+import type { ExtractPropTypes, PropType } from 'vue';
+type Value<T> = T[keyof T];
+/**
+ * Extract the type of a single prop
+ *
+ * 提取单个 prop 的参数类型
+ */
+export type ExtractPropType<T extends object> = Value<ExtractPropTypes<{
+    key: T;
+}>>;
+/**
+ * Extracts types via `ExtractPropTypes`, accepting `PropType<T>`, `XXXConstructor`, `never`...
+ *
+ * 通过 `ExtractPropTypes` 提取类型，接受 `PropType<T>`、`XXXConstructor`、`never`...
+ */
+export type ResolvePropType<T> = IfNever<T, never, ExtractPropType<{
+    type: WritableArray<T>;
+    required: true;
+}>>;
+/**
+ * Merge Type, Value, Validator types
+ * 合并 Type、Value、Validator 的类型
+ */
+export type EpPropMergeType<Type, Value, Validator> = IfNever<UnknownToNever<Value>, ResolvePropType<Type>, never> | UnknownToNever<Value> | UnknownToNever<Validator>;
+/**
+ * Handling default values for input (constraints)
+ *
+ * 处理输入参数的默认值（约束）
+ */
+export type EpPropInputDefault<Required extends boolean, Default> = Required extends true ? never : Default extends Record<string, unknown> | Array<any> ? () => Default : (() => Default) | Default;
+/**
+ * Native prop types, e.g: `BooleanConstructor`, `StringConstructor`, `null`, `undefined`, etc.
+ *
+ * 原生 prop 类型，如 `BooleanConstructor`、`StringConstructor`、`null`、`undefined` 等
+ */
+export type NativePropType = ((...args: any) => any) | {
+    new (...args: any): any;
+} | undefined | null;
+export type IfNativePropType<T, Y, N> = [T] extends [NativePropType] ? Y : N;
+/**
+ * input prop `buildProp` or `buildProps` (constraints)
+ *
+ * prop 输入参数（约束）
+ */
+export type EpPropInput<Type, Value, Validator, Default extends EpPropMergeType<Type, Value, Validator>, Required extends boolean> = {
+    type?: Type;
+    required?: Required;
+    values?: readonly Value[];
+    validator?: ((val: any) => val is Validator) | ((val: any) => boolean);
+    default?: EpPropInputDefault<Required, Default>;
+};
+/**
+ * output prop `buildProp` or `buildProps`.
+ *
+ * prop 输出参数。
+ */
+export type EpProp<Type, Default, Required> = {
+    readonly type: PropType<Type>;
+    readonly required: [Required] extends [true] ? true : false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    [epPropKey]: true;
+} & IfNever<Default, unknown, {
+    readonly default: Default;
+}>;
+/**
+ * Determine if it is `EpProp`
+ */
+export type IfEpProp<T, Y, N> = T extends {
+    [epPropKey]: true;
+} ? Y : N;
+/**
+ * Converting input to output.
+ *
+ * 将输入转换为输出
+ */
+export type EpPropConvert<Input> = Input extends EpPropInput<infer Type, infer Value, infer Validator, any, infer Required> ? EpPropFinalized<Type, Value, Validator, Input['default'], Required> : never;
+/**
+ * Finalized conversion output
+ *
+ * 最终转换 EpProp
+ */
+export type EpPropFinalized<Type, Value, Validator, Default, Required> = EpProp<EpPropMergeType<Type, Value, Validator>, UnknownToNever<Default>, Required>;
+export {};

package/dist/utils/vue/props/util.d.ts

@@ -0,0 +1,7 @@
+export type Writable<T> = {
+    -readonly [P in keyof T]: T[P];
+};
+export type WritableArray<T> = T extends readonly any[] ? Writable<T> : T;
+export type IfNever<T, Y = true, N = false> = [T] extends [never] ? Y : N;
+export type IfUnknown<T, Y, N> = [unknown] extends [T] ? Y : N;
+export type UnknownToNever<T> = IfUnknown<T, never, T>;

package/dist/utils/vue/refs.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentPublicInstance, Ref } from 'vue';
+export declare const composeRefs: (...refs: Ref<HTMLElement | undefined>[]) => (el: Element | ComponentPublicInstance | null) => void;

package/dist/utils/vue/size.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentSize } from '@element-plus/constants';
+export declare const getComponentSize: (size?: ComponentSize) => 40 | 32 | 24;

package/dist/utils/vue/typescript.d.ts

@@ -0,0 +1,25 @@
+import type { AllowedComponentProps, AppContext, Component, EmitsOptions, ObjectPlugin, SetupContext, VNodeProps } from 'vue';
+import type { ComponentEmit, ComponentProps } from 'vue-component-type-helpers';
+type NativeType = null | undefined | number | string | boolean | symbol | Function;
+/**
+ * Reference from https://github.com/vuejs/core/blob/main/packages/runtime-core/src/apiSetupHelpers.ts#L338-L340
+ */
+type InferDefaults<T> = {
+    [K in keyof T as string extends K ? never : K]?: InferDefault<T[K]>;
+};
+type InferDefault<T> = (() => T & {}) | (T extends NativeType ? T : never);
+type ExtractEventNames<T> = ComponentEmit<T> extends ((event: string, ...args: any[]) => any) ? never : keyof {
+    [K in keyof ComponentProps<T> as K extends `on${infer Event}` ? ComponentEmit<T> extends ((event: Uncapitalize<Event>, ...args: any[]) => any) ? K : never : never]: unknown;
+};
+type ExcludedProps<T> = ExtractEventNames<T> | keyof VNodeProps | keyof AllowedComponentProps;
+export type SFCWithInstall<T> = T & ObjectPlugin & SFCWithPropsDefaultsSetter<T>;
+export type SFCInstallWithContext<T> = SFCWithInstall<T> & {
+    _context: AppContext | null;
+};
+type SFCWithPropsDefaultsSetter<T> = T extends Component ? {
+    setPropsDefaults: (defaults: InferDefaults<{
+        [K in keyof ComponentProps<T> as K extends ExcludedProps<T> ? never : K]?: ComponentProps<T>[K];
+    }>) => void;
+} : unknown;
+export type EmitFn<E extends EmitsOptions> = SetupContext<E>['emit'];
+export {};

package/dist/utils/vue/validator.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentSize, DatePickType } from '@element-plus/constants';
+export declare const isValidComponentSize: (val: string) => val is ComponentSize | "";
+export declare const isValidDatePickType: (val: string) => val is DatePickType;

package/dist/utils/vue/vnode.d.ts

@@ -0,0 +1,48 @@
+import { createBlock } from 'vue';
+import type { VNode, VNodeChild, VNodeNormalizedChildren } from 'vue';
+export declare enum PatchFlags {
+    TEXT = 1,
+    CLASS = 2,
+    STYLE = 4,
+    PROPS = 8,
+    FULL_PROPS = 16,
+    HYDRATE_EVENTS = 32,
+    STABLE_FRAGMENT = 64,
+    KEYED_FRAGMENT = 128,
+    UNKEYED_FRAGMENT = 256,
+    NEED_PATCH = 512,
+    DYNAMIC_SLOTS = 1024,
+    HOISTED = -1,
+    BAIL = -2
+}
+export type VNodeChildAtom = Exclude<VNodeChild, Array<any>>;
+export type RawSlots = Exclude<VNodeNormalizedChildren, Array<any> | null | string>;
+export declare function isFragment(node: VNode): boolean;
+export declare function isFragment(node: unknown): node is VNode;
+export declare function isText(node: VNode): boolean;
+export declare function isText(node: unknown): node is VNode;
+export declare function isComment(node: VNode): boolean;
+export declare function isComment(node: unknown): node is VNode;
+export declare function isTemplate(node: VNode): boolean;
+export declare function isTemplate(node: unknown): node is VNode;
+/**
+ * determine if the element is a valid element type rather than fragments and comment e.g. <template> v-if
+ * @param node {VNode} node to be tested
+ */
+export declare function isValidElementNode(node: VNode): boolean;
+export declare function isValidElementNode(node: unknown): node is VNode;
+export declare const getFirstValidNode: (nodes: VNodeNormalizedChildren, maxDepth?: number) => string | number | boolean | void | VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | import("vue").VNodeArrayChildren | {
+    [name: string]: unknown;
+    $stable?: boolean;
+} | null | undefined;
+export declare function renderIf(condition: boolean, ...args: Parameters<typeof createBlock>): VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare function renderBlock(...args: Parameters<typeof createBlock>): VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;
+export declare const getNormalizedProps: (node: VNode) => Record<string, any>;
+export type FlattenVNodes = Array<VNodeChildAtom | RawSlots>;
+export declare const flattedChildren: (children: FlattenVNodes | VNode | VNodeNormalizedChildren) => FlattenVNodes;

package/dist/vendored-components.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 已源码化（vendored）组件的权威清单 —— 单一事实来源。
+ *
+ * 判定某组件是否源码化的唯一依据。以下工具/代码均从本清单派生，不得各自维护副本：
+ * - scripts/gen-components.ts：生成包装文件时跳过源码化组件。
+ * - src/resolver.ts：按需导入解析器区分源码化 / 包装组件。
+ *
+ * 源码化原因：element-plus 的菜单 / 标签页 / 单选框组件内部按 `type.name === 'ElXxx'`
+ * 查找父级或子级，改名包装（ElXxx -> EpXxx）会破坏父子识别，必须 vendor 源码。
+ */
+export declare const vendoredComponents: readonly ["Affix", "Alert", "Anchor", "AnchorLink", "Button", "CheckTag", "Tag", "Menu", "MenuItem", "MenuItemGroup", "SubMenu", "Tabs", "TabPane", "Radio", "RadioButton", "RadioGroup"];
+export type VendoredComponentName = (typeof vendoredComponents)[number];
+export declare const isVendored: (name: string) => boolean;

package/dist/vendored-components.js

@@ -0,0 +1,22 @@
+const e = [
+  "Affix",
+  "Alert",
+  "Anchor",
+  "AnchorLink",
+  "Button",
+  "CheckTag",
+  "Tag",
+  "Menu",
+  "MenuItem",
+  "MenuItemGroup",
+  "SubMenu",
+  "Tabs",
+  "TabPane",
+  "Radio",
+  "RadioButton",
+  "RadioGroup"
+], o = (n) => e.includes(n);
+export {
+  o as isVendored,
+  e as vendoredComponents
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ep-craft",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "A Vue 3 component library based on element-plus with ep- prefix",
   "type": "module",
   "main": "./dist/ep-craft.js",
@@ -62,7 +62,14 @@
   "dependencies": {
     "@ctrl/tinycolor": "^4.2.0",
     "@element-plus/icons-vue": "^2.3.0",
-    "element-plus": "^2.9.0"
+    "@popperjs/core": "npm:@sxzz/popperjs-es@^2.11.8",
+    "@vue/shared": "^3.5.40",
+    "@vueuse/core": "14.3.0",
+    "csstype": "^3.2.3",
+    "element-plus": "^2.9.0",
+    "lodash-unified": "^1.0.3",
+    "normalize-wheel-es": "^1.2.0",
+    "vue-component-type-helpers": "^3.3.5"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
@@ -73,7 +80,8 @@
     "vite": "^5.4.0",
     "vitepress": "^1.6.4",
     "vue": "^3.4.0",
-    "vue-tsc": "^2.0.0"
+    "vue-tsc": "^2.0.0",
+    "vue-router": "^4.3.0"
   },
   "keywords": [
     "vue",