@element-plus/nightly 0.0.20220106 → 0.0.20220110

package/lib/hooks/use-locale/index.js

@@ -5,56 +5,33 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var vue = require('vue');
 var get = require('lodash/get');
 var en = require('../../locale/lang/en.js');
-var props = require('../../utils/props.js');
+var index = require('../use-global-config/index.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
 
-const useLocaleProps = props.buildProps({
-  locale: {
-    type: props.definePropType(Object)
-  }
-});
-const localeContextKey = Symbol("localeContextKey");
-let cache;
-const provideLocale = () => {
-  const vm = vue.getCurrentInstance();
-  const props = vm.props;
-  const locale = vue.computed(() => props.locale || en["default"]);
-  const lang = vue.computed(() => locale.value.name);
-  const t = buildTranslator(locale);
-  const provides = {
-    locale,
-    lang,
-    t
-  };
-  cache = provides;
-  vue.provide(localeContextKey, provides);
-};
 const buildTranslator = (locale) => (path, option) => translate(path, option, vue.unref(locale));
 const translate = (path, option, locale) => get__default["default"](locale, path, path).replace(/\{(\w+)\}/g, (_, key) => {
   var _a;
   return `${(_a = option == null ? void 0 : option[key]) != null ? _a : `{${key}}`}`;
 });
-const localeProviderMaker = (locale = en["default"]) => {
-  const lang = vue.ref(locale.name);
-  const localeRef = vue.ref(locale);
+const buildLocaleContext = (locale) => {
+  const lang = vue.computed(() => vue.unref(locale).name);
+  const localeRef = vue.isRef(locale) ? locale : vue.ref(locale);
   return {
     lang,
     locale: localeRef,
-    t: buildTranslator(localeRef)
+    t: buildTranslator(locale)
   };
 };
 const useLocale = () => {
-  return vue.inject(localeContextKey, cache || localeProviderMaker(en["default"]));
+  const locale = index.useGlobalConfig("locale");
+  return buildLocaleContext(vue.computed(() => locale.value || en["default"]));
 };
 
+exports.buildLocaleContext = buildLocaleContext;
 exports.buildTranslator = buildTranslator;
-exports.localeContextKey = localeContextKey;
-exports.localeProviderMaker = localeProviderMaker;
-exports.provideLocale = provideLocale;
 exports.translate = translate;
 exports.useLocale = useLocale;
-exports.useLocaleProps = useLocaleProps;
 //# sourceMappingURL=index.js.map

package/lib/hooks/use-locale/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../packages/hooks/use-locale/index.ts"],"sourcesContent":["import { computed, getCurrentInstance, inject, provide, ref, unref } from 'vue'\nimport get from 'lodash/get'\nimport English from '@element-plus/locale/lang/en'\nimport { buildProps, definePropType } from '@element-plus/utils/props'\nimport type { MaybeRef } from '@vueuse/core'\nimport type { InjectionKey, Ref } from 'vue'\nimport type { Language } from '@element-plus/locale'\n\nexport type TranslatorOption = Record<string, string | number>\nexport type Translator = (path: string, option?: TranslatorOption) => string\nexport type LocaleContext = {\n  locale: Ref<Language>\n  lang: Ref<string>\n  t: Translator\n}\n\nexport const useLocaleProps = buildProps({\n  locale: {\n    type: definePropType<Language>(Object),\n  },\n})\n\nexport const localeContextKey: InjectionKey<LocaleContext> =\n  Symbol('localeContextKey')\n\n// this is meant to fix global methods like `ElMessage(opts)`, this way we can inject current locale\n// into the component as default injection value.\n// refer to: https://github.com/element-plus/element-plus/issues/2610#issuecomment-887965266\nlet cache: LocaleContext\n\nexport const provideLocale = () => {\n  const vm = getCurrentInstance()!\n  const props = vm.props as {\n    locale: Language\n  }\n  const locale = computed(() => props.locale || English)\n  const lang = computed(() => locale.value.name)\n\n  const t = buildTranslator(locale)\n  const provides: LocaleContext = {\n    locale,\n    lang,\n    t,\n  }\n\n  // this could be broken if someone tries to do following:\n\n  /**\n   * <config-provider :locale=\"lang1\">\n   *   <config-provider :locale=\"lang2\">\n   *     Something calls modal component.\n   *   </config-provider>\n   * </config-provider>\n   */\n  cache = provides\n  provide(localeContextKey, provides)\n}\n\nexport const buildTranslator =\n  (locale: MaybeRef<Language>): Translator =>\n  (path, option) =>\n    translate(path, option, unref(locale))\n\nexport const translate = (\n  path: string,\n  option: undefined | TranslatorOption,\n  locale: Language\n): string =>\n  (get(locale, path, path) as string).replace(\n    /\\{(\\w+)\\}/g,\n    (_, key) => `${option?.[key] ?? `{${key}}`}`\n  )\n\nexport const localeProviderMaker = (locale = English) => {\n  const lang = ref(locale.name)\n  const localeRef = ref(locale)\n  return {\n    lang,\n    locale: localeRef,\n    t: buildTranslator(localeRef),\n  }\n}\n\nexport const useLocale = () => {\n  return inject(localeContextKey, cache || localeProviderMaker(English))\n}\n"],"names":["buildProps","definePropType","getCurrentInstance","computed","English","provide","unref","get","ref","inject"],"mappings":";;;;;;;;;;;;;AAIY,MAAC,cAAc,GAAGA,gBAAU,CAAC;AACzC,EAAE,MAAM,EAAE;AACV,IAAI,IAAI,EAAEC,oBAAc,CAAC,MAAM,CAAC;AAChC,GAAG;AACH,CAAC,EAAE;AACS,MAAC,gBAAgB,GAAG,MAAM,CAAC,kBAAkB,EAAE;AAC3D,IAAI,KAAK,CAAC;AACE,MAAC,aAAa,GAAG,MAAM;AACnC,EAAE,MAAM,EAAE,GAAGC,sBAAkB,EAAE,CAAC;AAClC,EAAE,MAAM,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC;AACzB,EAAE,MAAM,MAAM,GAAGC,YAAQ,CAAC,MAAM,KAAK,CAAC,MAAM,IAAIC,aAAO,CAAC,CAAC;AACzD,EAAE,MAAM,IAAI,GAAGD,YAAQ,CAAC,MAAM,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACjD,EAAE,MAAM,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,CAAC;AACpC,EAAE,MAAM,QAAQ,GAAG;AACnB,IAAI,MAAM;AACV,IAAI,IAAI;AACR,IAAI,CAAC;AACL,GAAG,CAAC;AACJ,EAAE,KAAK,GAAG,QAAQ,CAAC;AACnB,EAAEE,WAAO,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;AACtC,EAAE;AACU,MAAC,eAAe,GAAG,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC,IAAI,EAAE,MAAM,EAAEC,SAAK,CAAC,MAAM,CAAC,EAAE;AACxF,MAAC,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,KAAKC,uBAAG,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK;AAC7G,EAAE,IAAI,EAAE,CAAC;AACT,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrF,CAAC,EAAE;AACS,MAAC,mBAAmB,GAAG,CAAC,MAAM,GAAGH,aAAO,KAAK;AACzD,EAAE,MAAM,IAAI,GAAGI,OAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;AAChC,EAAE,MAAM,SAAS,GAAGA,OAAG,CAAC,MAAM,CAAC,CAAC;AAChC,EAAE,OAAO;AACT,IAAI,IAAI;AACR,IAAI,MAAM,EAAE,SAAS;AACrB,IAAI,CAAC,EAAE,eAAe,CAAC,SAAS,CAAC;AACjC,GAAG,CAAC;AACJ,EAAE;AACU,MAAC,SAAS,GAAG,MAAM;AAC/B,EAAE,OAAOC,UAAM,CAAC,gBAAgB,EAAE,KAAK,IAAI,mBAAmB,CAACL,aAAO,CAAC,CAAC,CAAC;AACzE;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../packages/hooks/use-locale/index.ts"],"sourcesContent":["import { computed, ref, unref, isRef } from 'vue'\nimport get from 'lodash/get'\nimport English from '@element-plus/locale/lang/en'\nimport { useGlobalConfig } from '../use-global-config'\nimport type { MaybeRef } from '@vueuse/core'\nimport type { Ref } from 'vue'\nimport type { Language } from '@element-plus/locale'\n\nexport type TranslatorOption = Record<string, string | number>\nexport type Translator = (path: string, option?: TranslatorOption) => string\nexport type LocaleContext = {\n  locale: Ref<Language>\n  lang: Ref<string>\n  t: Translator\n}\n\nexport const buildTranslator =\n  (locale: MaybeRef<Language>): Translator =>\n  (path, option) =>\n    translate(path, option, unref(locale))\n\nexport const translate = (\n  path: string,\n  option: undefined | TranslatorOption,\n  locale: Language\n): string =>\n  (get(locale, path, path) as string).replace(\n    /\\{(\\w+)\\}/g,\n    (_, key) => `${option?.[key] ?? `{${key}}`}`\n  )\n\nexport const buildLocaleContext = (\n  locale: MaybeRef<Language>\n): LocaleContext => {\n  const lang = computed(() => unref(locale).name)\n  const localeRef = isRef(locale) ? locale : ref(locale)\n  return {\n    lang,\n    locale: localeRef,\n    t: buildTranslator(locale),\n  }\n}\n\nexport const useLocale = () => {\n  const locale = useGlobalConfig('locale')\n  return buildLocaleContext(computed(() => locale.value || English))\n}\n"],"names":["unref","get","computed","isRef","ref","useGlobalConfig","English"],"mappings":";;;;;;;;;;;;;AAIY,MAAC,eAAe,GAAG,CAAC,MAAM,KAAK,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC,IAAI,EAAE,MAAM,EAAEA,SAAK,CAAC,MAAM,CAAC,EAAE;AACxF,MAAC,SAAS,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,KAAKC,uBAAG,CAAC,MAAM,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK;AAC7G,EAAE,IAAI,EAAE,CAAC;AACT,EAAE,OAAO,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,IAAI,IAAI,GAAG,KAAK,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrF,CAAC,EAAE;AACS,MAAC,kBAAkB,GAAG,CAAC,MAAM,KAAK;AAC9C,EAAE,MAAM,IAAI,GAAGC,YAAQ,CAAC,MAAMF,SAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC;AAClD,EAAE,MAAM,SAAS,GAAGG,SAAK,CAAC,MAAM,CAAC,GAAG,MAAM,GAAGC,OAAG,CAAC,MAAM,CAAC,CAAC;AACzD,EAAE,OAAO;AACT,IAAI,IAAI;AACR,IAAI,MAAM,EAAE,SAAS;AACrB,IAAI,CAAC,EAAE,eAAe,CAAC,MAAM,CAAC;AAC9B,GAAG,CAAC;AACJ,EAAE;AACU,MAAC,SAAS,GAAG,MAAM;AAC/B,EAAE,MAAM,MAAM,GAAGC,qBAAe,CAAC,QAAQ,CAAC,CAAC;AAC3C,EAAE,OAAO,kBAAkB,CAACH,YAAQ,CAAC,MAAM,MAAM,CAAC,KAAK,IAAII,aAAO,CAAC,CAAC,CAAC;AACrE;;;;;;;"}

package/lib/hooks/use-model-toggle/index.d.ts

@@ -6,7 +6,7 @@ export declare const createModelToggleComposable: (name: string) => {
         toggle: () => void;
     };
     useModelToggleProps: {
-        [x: string]: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<boolean | null>, null, false, never, never> | import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<(val: boolean) => void>, never, false, never, never>;
+        [x: string]: import("@element-plus/utils/props").BuildPropReturn<import("@element-plus/utils/props").PropWrapper<boolean | null>, null, false, never, never> | import("@element-plus/utils/props").BuildPropReturn<import("@element-plus/utils/props").PropWrapper<(val: boolean) => void>, never, false, never, never>;
     };
     useModelToggleEmits: string[];
 };
@@ -15,7 +15,7 @@ declare const useModelToggle: ({ indicator, shouldHideWhenRouteChanges, shouldPr
     show: () => void;
     toggle: () => void;
 }, useModelToggleProps: {
-    [x: string]: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<boolean | null>, null, false, never, never> | import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<(val: boolean) => void>, never, false, never, never>;
+    [x: string]: import("@element-plus/utils/props").BuildPropReturn<import("@element-plus/utils/props").PropWrapper<boolean | null>, null, false, never, never> | import("@element-plus/utils/props").BuildPropReturn<import("@element-plus/utils/props").PropWrapper<(val: boolean) => void>, never, false, never, never>;
 }, useModelToggleEmits: string[];
 export { useModelToggle, useModelToggleEmits, useModelToggleProps };
 export declare type UseModelToggleProps = ExtractPropTypes<typeof useModelToggleProps>;

package/lib/index.d.ts

@@ -1,19 +1,22 @@
 import installer from './defaults';
-export * from 'element-plus/es/components';
-export * from 'element-plus/es/directives';
-export * from 'element-plus/es/hooks';
-export * from 'element-plus/es/tokens';
+export * from '@element-plus/components';
+export * from '@element-plus/directives';
+export * from '@element-plus/hooks';
+export * from '@element-plus/tokens';
+export * from '@element-plus/utils/popup-manager';
 export { makeInstaller } from './make-installer';
 export declare const install: (app: import("vue").App<any>, options?: {
+    readonly locale?: unknown;
     readonly size?: unknown;
     readonly button?: unknown;
+    readonly message?: unknown;
     readonly zIndex?: unknown;
-    readonly locale?: unknown;
 } & {} & {
-    button?: import("element-plus/es/components").ButtonConfigContext | undefined;
+    message?: import("@element-plus/components").MessageConfigContext | undefined;
+    button?: import("@element-plus/components").ButtonConfigContext | undefined;
+    zIndex?: number | undefined;
     size?: import("./utils/props").BuildPropType<StringConstructor, "small" | "default" | "large", unknown> | undefined;
     locale?: import("./locale").Language | undefined;
-    zIndex?: number | undefined;
 }) => void;
 export declare const version: string;
 export default installer;

package/lib/index.js

@@ -7,6 +7,7 @@ require('./components/index.js');
 require('./directives/index.js');
 require('./hooks/index.js');
 require('./tokens/index.js');
+var popupManager = require('./utils/popup-manager.js');
 var makeInstaller = require('./make-installer.js');
 var affix = require('./components/affix/src/affix.js');
 var index = require('./components/affix/index.js');
@@ -194,6 +195,7 @@ const install = defaults["default"].install;
 const version = defaults["default"].version;
 
 exports["default"] = defaults["default"];
+exports.PopupManager = popupManager.PopupManager;
 exports.makeInstaller = makeInstaller.makeInstaller;
 exports.affixEmits = affix.affixEmits;
 exports.affixProps = affix.affixProps;
@@ -246,6 +248,7 @@ exports.ElCollapseItem = index$g.ElCollapseItem;
 exports.ElCollapseTransition = index$h.ElCollapseTransition;
 exports.ElColorPicker = index$i.ElColorPicker;
 exports.configProviderProps = configProvider.configProviderProps;
+exports.messageConfig = configProvider.messageConfig;
 exports.ElConfigProvider = index$j.ElConfigProvider;
 exports.ElAside = index$k.ElAside;
 exports.ElContainer = index$k.ElContainer;
@@ -438,13 +441,10 @@ exports.useFocus = index$1e.useFocus;
 exports.useFormItem = index$1f.useFormItem;
 exports.provideGlobalConfig = index$1g.provideGlobalConfig;
 exports.useGlobalConfig = index$1g.useGlobalConfig;
+exports.buildLocaleContext = index$1h.buildLocaleContext;
 exports.buildTranslator = index$1h.buildTranslator;
-exports.localeContextKey = index$1h.localeContextKey;
-exports.localeProviderMaker = index$1h.localeProviderMaker;
-exports.provideLocale = index$1h.provideLocale;
 exports.translate = index$1h.translate;
 exports.useLocale = index$1h.useLocale;
-exports.useLocaleProps = index$1h.useLocaleProps;
 exports.useLockscreen = index$1i.useLockscreen;
 exports.useModal = index$1j.useModal;
 exports.createModelToggleComposable = index$1k.createModelToggleComposable;

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../packages/element-plus/index.ts"],"sourcesContent":["import installer from './defaults'\nexport * from '@element-plus/components'\nexport * from '@element-plus/directives'\nexport * from '@element-plus/hooks'\nexport * from '@element-plus/tokens'\nexport { makeInstaller } from './make-installer'\n\nexport const install = installer.install\nexport const version = installer.version\nexport default installer\n"],"names":["installer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMY,MAAC,OAAO,GAAGA,mBAAS,CAAC,QAAQ;AAC7B,MAAC,OAAO,GAAGA,mBAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../packages/element-plus/index.ts"],"sourcesContent":["import installer from './defaults'\nexport * from '@element-plus/components'\nexport * from '@element-plus/directives'\nexport * from '@element-plus/hooks'\nexport * from '@element-plus/tokens'\nexport * from '@element-plus/utils/popup-manager'\nexport { makeInstaller } from './make-installer'\n\nexport const install = installer.install\nexport const version = installer.version\nexport default installer\n"],"names":["installer"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOY,MAAC,OAAO,GAAGA,mBAAS,CAAC,QAAQ;AAC7B,MAAC,OAAO,GAAGA,mBAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/make-installer.d.ts

@@ -1,5 +1,5 @@
 import type { App, Plugin } from 'vue';
-import type { ConfigProviderContext } from 'element-plus/es/tokens';
+import type { ConfigProviderContext } from '@element-plus/tokens';
 export declare const makeInstaller: (components?: Plugin[]) => {
     version: string;
     install: (app: App, options?: ConfigProviderContext) => void;

package/lib/packages/component.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vue';
+declare const _default: Plugin[];
+export default _default;

package/lib/packages/components/affix/src/affix.d.ts

@@ -0,0 +1,17 @@
+import type { ExtractPropTypes } from 'vue';
+import type { ZIndexProperty } from 'csstype';
+export declare const affixProps: {
+    readonly zIndex: import("element-plus/es/utils/props").BuildPropReturn<import("element-plus/es/utils/props").PropWrapper<ZIndexProperty>, 100, unknown, unknown, unknown>;
+    readonly target: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly offset: import("element-plus/es/utils/props").BuildPropReturn<NumberConstructor, 0, unknown, unknown, unknown>;
+    readonly position: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "top", unknown, "top" | "bottom", unknown>;
+};
+export declare type AffixProps = ExtractPropTypes<typeof affixProps>;
+export declare const affixEmits: {
+    scroll: ({ scrollTop, fixed }: {
+        scrollTop: number;
+        fixed: boolean;
+    }) => boolean;
+    change: (fixed: boolean) => boolean;
+};
+export declare type AffixEmits = typeof affixEmits;

package/lib/packages/components/affix/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-affix.css';

package/lib/packages/components/affix/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/affix.scss';

package/lib/packages/components/alert/index.d.ts

@@ -0,0 +1,50 @@
+export declare const ElAlert: import("../../utils/types").SFCWithInstall<import("vue").DefineComponent<{
+    readonly title: import("../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly description: import("../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly type: import("../../utils/props").BuildPropReturn<StringConstructor, "info", unknown, "success" | "warning" | "info" | "error", unknown>;
+    readonly closable: import("../../utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+    readonly closeText: import("../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly showIcon: BooleanConstructor;
+    readonly center: BooleanConstructor;
+    readonly effect: import("../../utils/props").BuildPropReturn<StringConstructor, "light", unknown, "dark" | "light", unknown>;
+}, {
+    visible: import("vue").Ref<boolean>;
+    typeClass: import("vue").ComputedRef<string>;
+    iconComponent: import("vue").ComputedRef<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{}>, {}>>;
+    isBigIcon: import("vue").ComputedRef<"" | "is-big">;
+    isBoldTitle: import("vue").ComputedRef<"" | "is-bold">;
+    close: (evt: MouseEvent) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (evt: MouseEvent) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly title?: unknown;
+    readonly description?: unknown;
+    readonly type?: unknown;
+    readonly closable?: unknown;
+    readonly closeText?: unknown;
+    readonly showIcon?: unknown;
+    readonly center?: unknown;
+    readonly effect?: unknown;
+} & {
+    type: import("../../utils/props").BuildPropType<StringConstructor, "success" | "warning" | "info" | "error", unknown>;
+    closable: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    title: string;
+    center: boolean;
+    description: string;
+    closeText: string;
+    effect: import("../../utils/props").BuildPropType<StringConstructor, "dark" | "light", unknown>;
+    showIcon: boolean;
+} & {}> & {
+    onClose?: ((evt: MouseEvent) => any) | undefined;
+}, {
+    type: import("../../utils/props").BuildPropType<StringConstructor, "success" | "warning" | "info" | "error", unknown>;
+    closable: import("../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    title: string;
+    center: boolean;
+    description: string;
+    closeText: string;
+    effect: import("../../utils/props").BuildPropType<StringConstructor, "dark" | "light", unknown>;
+    showIcon: boolean;
+}>> & Record<string, any>;
+export default ElAlert;
+export * from './src/alert';

package/lib/packages/components/alert/src/alert.d.ts

@@ -0,0 +1,17 @@
+import type { ExtractPropTypes } from 'vue';
+export declare type AlertEffect = 'light' | 'dark';
+export declare const alertProps: {
+    readonly title: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly description: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly type: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "info", unknown, "success" | "warning" | "info" | "error", unknown>;
+    readonly closable: import("element-plus/es/utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+    readonly closeText: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly showIcon: BooleanConstructor;
+    readonly center: BooleanConstructor;
+    readonly effect: import("element-plus/es/utils/props").BuildPropReturn<StringConstructor, "light", unknown, "dark" | "light", unknown>;
+};
+export declare type AlertProps = ExtractPropTypes<typeof alertProps>;
+export declare const alertEmits: {
+    close: (evt: MouseEvent) => boolean;
+};
+export declare type AlertEmits = typeof alertEmits;

package/lib/packages/components/alert/src/alert.vue.d.ts

@@ -0,0 +1,49 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly title: import("../../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly description: import("../../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly type: import("../../../utils/props").BuildPropReturn<StringConstructor, "info", unknown, "success" | "warning" | "info" | "error", unknown>;
+    readonly closable: import("../../../utils/props").BuildPropReturn<BooleanConstructor, true, unknown, unknown, unknown>;
+    readonly closeText: import("../../../utils/props").BuildPropReturn<StringConstructor, "", unknown, unknown, unknown>;
+    readonly showIcon: BooleanConstructor;
+    readonly center: BooleanConstructor;
+    readonly effect: import("../../../utils/props").BuildPropReturn<StringConstructor, "light", unknown, "dark" | "light", unknown>;
+}, {
+    visible: import("vue").Ref<boolean>;
+    typeClass: import("vue").ComputedRef<string>;
+    iconComponent: import("vue").ComputedRef<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{}>, {}>>;
+    isBigIcon: import("vue").ComputedRef<"" | "is-big">;
+    isBoldTitle: import("vue").ComputedRef<"" | "is-bold">;
+    close: (evt: MouseEvent) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (evt: MouseEvent) => boolean;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    readonly title?: unknown;
+    readonly description?: unknown;
+    readonly type?: unknown;
+    readonly closable?: unknown;
+    readonly closeText?: unknown;
+    readonly showIcon?: unknown;
+    readonly center?: unknown;
+    readonly effect?: unknown;
+} & {
+    type: import("../../../utils/props").BuildPropType<StringConstructor, "success" | "warning" | "info" | "error", unknown>;
+    closable: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    title: string;
+    center: boolean;
+    description: string;
+    closeText: string;
+    effect: import("../../../utils/props").BuildPropType<StringConstructor, "dark" | "light", unknown>;
+    showIcon: boolean;
+} & {}> & {
+    onClose?: ((evt: MouseEvent) => any) | undefined;
+}, {
+    type: import("../../../utils/props").BuildPropType<StringConstructor, "success" | "warning" | "info" | "error", unknown>;
+    closable: import("../../../utils/props").BuildPropType<BooleanConstructor, unknown, unknown>;
+    title: string;
+    center: boolean;
+    description: string;
+    closeText: string;
+    effect: import("../../../utils/props").BuildPropType<StringConstructor, "dark" | "light", unknown>;
+    showIcon: boolean;
+}>;
+export default _default;

package/lib/packages/components/alert/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-alert.css';

package/lib/packages/components/alert/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/alert.scss';

package/lib/packages/components/aside/style/css.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-aside.css';

package/lib/packages/components/aside/style/index.d.ts

@@ -0,0 +1,2 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/aside.scss';

package/lib/packages/components/autocomplete/index.d.ts

@@ -0,0 +1,244 @@
+import type { SFCWithInstall } from 'element-plus/es/utils/types';
+declare const _Autocomplete: SFCWithInstall<import("vue").DefineComponent<{
+    valueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placement: {
+        type: import("vue").PropType<import("@popperjs/core").Placement>;
+        validator: (val: string) => boolean;
+        default: string;
+    };
+    fetchSuggestions: {
+        type: import("vue").PropType<(queryString: string, cb: (data: any[]) => void) => void>;
+        default: () => void;
+    };
+    popperClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    triggerOnFocus: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectWhenUnmatched: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    highlightFirstItem: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    attrs: import("vue").ComputedRef<Record<string, unknown>>;
+    suggestions: import("vue").Ref<any[]>;
+    highlightedIndex: import("vue").Ref<number>;
+    dropdownWidth: import("vue").Ref<string>;
+    activated: import("vue").Ref<boolean>;
+    suggestionDisabled: import("vue").Ref<boolean>;
+    loading: import("vue").Ref<boolean>;
+    inputRef: import("vue").Ref<{
+        inputOrTextarea: HTMLInputElement | HTMLTextAreaElement;
+        focus: () => void;
+        $el: HTMLElement;
+    } | null>;
+    regionRef: import("vue").Ref<HTMLElement | null>;
+    popper: import("vue").Ref<null>;
+    id: import("vue").ComputedRef<string>;
+    suggestionVisible: import("vue").ComputedRef<boolean>;
+    suggestionLoading: import("vue").ComputedRef<boolean>;
+    getData: (queryString: string) => void;
+    handleInput: (value: string) => void;
+    handleChange: (value: any) => void;
+    handleFocus: (e: any) => void;
+    handleBlur: (e: any) => void;
+    handleClear: () => void;
+    handleKeyEnter: () => void;
+    close: () => void;
+    focus: () => void;
+    select: (item: any) => void;
+    highlight: (index: number) => void;
+    onSuggestionShow: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "select" | "update:modelValue" | "change" | "blur" | "focus" | "clear")[], "input" | "select" | "update:modelValue" | "change" | "blur" | "focus" | "clear", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    valueKey?: unknown;
+    modelValue?: unknown;
+    debounce?: unknown;
+    placement?: unknown;
+    fetchSuggestions?: unknown;
+    popperClass?: unknown;
+    triggerOnFocus?: unknown;
+    selectWhenUnmatched?: unknown;
+    hideLoading?: unknown;
+    popperAppendToBody?: unknown;
+    highlightFirstItem?: unknown;
+} & {
+    modelValue: string | number;
+    placement: import("@popperjs/core").Placement;
+    popperClass: string;
+    valueKey: string;
+    debounce: number;
+    fetchSuggestions: (queryString: string, cb: (data: any[]) => void) => void;
+    triggerOnFocus: boolean;
+    selectWhenUnmatched: boolean;
+    hideLoading: boolean;
+    popperAppendToBody: boolean;
+    highlightFirstItem: boolean;
+} & {}> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onInput?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    onSelect?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: string | number;
+    placement: import("@popperjs/core").Placement;
+    popperClass: string;
+    valueKey: string;
+    debounce: number;
+    fetchSuggestions: (queryString: string, cb: (data: any[]) => void) => void;
+    triggerOnFocus: boolean;
+    selectWhenUnmatched: boolean;
+    hideLoading: boolean;
+    popperAppendToBody: boolean;
+    highlightFirstItem: boolean;
+}>>;
+export default _Autocomplete;
+export declare const ElAutocomplete: SFCWithInstall<import("vue").DefineComponent<{
+    valueKey: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    debounce: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placement: {
+        type: import("vue").PropType<import("@popperjs/core").Placement>;
+        validator: (val: string) => boolean;
+        default: string;
+    };
+    fetchSuggestions: {
+        type: import("vue").PropType<(queryString: string, cb: (data: any[]) => void) => void>;
+        default: () => void;
+    };
+    popperClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    triggerOnFocus: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectWhenUnmatched: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    popperAppendToBody: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    highlightFirstItem: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    attrs: import("vue").ComputedRef<Record<string, unknown>>;
+    suggestions: import("vue").Ref<any[]>;
+    highlightedIndex: import("vue").Ref<number>;
+    dropdownWidth: import("vue").Ref<string>;
+    activated: import("vue").Ref<boolean>;
+    suggestionDisabled: import("vue").Ref<boolean>;
+    loading: import("vue").Ref<boolean>;
+    inputRef: import("vue").Ref<{
+        inputOrTextarea: HTMLInputElement | HTMLTextAreaElement;
+        focus: () => void;
+        $el: HTMLElement;
+    } | null>;
+    regionRef: import("vue").Ref<HTMLElement | null>;
+    popper: import("vue").Ref<null>;
+    id: import("vue").ComputedRef<string>;
+    suggestionVisible: import("vue").ComputedRef<boolean>;
+    suggestionLoading: import("vue").ComputedRef<boolean>;
+    getData: (queryString: string) => void;
+    handleInput: (value: string) => void;
+    handleChange: (value: any) => void;
+    handleFocus: (e: any) => void;
+    handleBlur: (e: any) => void;
+    handleClear: () => void;
+    handleKeyEnter: () => void;
+    close: () => void;
+    focus: () => void;
+    select: (item: any) => void;
+    highlight: (index: number) => void;
+    onSuggestionShow: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("input" | "select" | "update:modelValue" | "change" | "blur" | "focus" | "clear")[], "input" | "select" | "update:modelValue" | "change" | "blur" | "focus" | "clear", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+    valueKey?: unknown;
+    modelValue?: unknown;
+    debounce?: unknown;
+    placement?: unknown;
+    fetchSuggestions?: unknown;
+    popperClass?: unknown;
+    triggerOnFocus?: unknown;
+    selectWhenUnmatched?: unknown;
+    hideLoading?: unknown;
+    popperAppendToBody?: unknown;
+    highlightFirstItem?: unknown;
+} & {
+    modelValue: string | number;
+    placement: import("@popperjs/core").Placement;
+    popperClass: string;
+    valueKey: string;
+    debounce: number;
+    fetchSuggestions: (queryString: string, cb: (data: any[]) => void) => void;
+    triggerOnFocus: boolean;
+    selectWhenUnmatched: boolean;
+    hideLoading: boolean;
+    popperAppendToBody: boolean;
+    highlightFirstItem: boolean;
+} & {}> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onInput?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onClear?: ((...args: any[]) => any) | undefined;
+    onSelect?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: string | number;
+    placement: import("@popperjs/core").Placement;
+    popperClass: string;
+    valueKey: string;
+    debounce: number;
+    fetchSuggestions: (queryString: string, cb: (data: any[]) => void) => void;
+    triggerOnFocus: boolean;
+    selectWhenUnmatched: boolean;
+    hideLoading: boolean;
+    popperAppendToBody: boolean;
+    highlightFirstItem: boolean;
+}>>;