duck-vue-components 0.0.0

package/dist/index-C-uY4885.d.cts

@@ -0,0 +1,23 @@
+import { t as baseT } from "./index-5JdIJn1m.cjs";
+import { o as SFCWithInstall } from "./index-BGkTN1DD.cjs";
+import * as _$vue from "vue";
+import { AffixEmits, AffixProps } from "element-plus";
+
+//#region src/packages/controls/affix/affix.vue.d.ts
+type __VLS_Props = {
+  control: Partial<OptionT>;
+};
+declare const __VLS_export: _$vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+declare namespace affix_d_exports {
+  export { OptionT, Template, init };
+}
+declare const Template: SFCWithInstall<typeof _default>;
+type OptionT = AffixProps & AffixEmits & baseT & {
+  default: any;
+  moduleName: string;
+  name: string;
+};
+declare function init(moduleName: string, name: string, options?: Partial<OptionT>): Partial<OptionT>;
+//#endregion
+export { affix_d_exports as t };

package/dist/index-C5SJLWEN.d.ts

@@ -0,0 +1,23 @@
+import { t as baseT } from "./index-BHq-BMCP.js";
+import { o as SFCWithInstall } from "./index-DamAmum6.js";
+import * as _$vue from "vue";
+import { AffixEmits, AffixProps } from "element-plus";
+
+//#region src/packages/controls/affix/affix.vue.d.ts
+type __VLS_Props = {
+  control: Partial<OptionT>;
+};
+declare const __VLS_export: _$vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+declare namespace affix_d_exports {
+  export { OptionT, Template, init };
+}
+declare const Template: SFCWithInstall<typeof _default>;
+type OptionT = AffixProps & AffixEmits & baseT & {
+  default: any;
+  moduleName: string;
+  name: string;
+};
+declare function init(moduleName: string, name: string, options?: Partial<OptionT>): Partial<OptionT>;
+//#endregion
+export { affix_d_exports as t };

package/dist/index-CSvc8L11.d.cts

@@ -0,0 +1,51 @@
+import { t as baseT } from "./index-5JdIJn1m.cjs";
+import { o as SFCWithInstall } from "./index-BGkTN1DD.cjs";
+import { O as Mutable } from "./index-oDsyZ3t2.cjs";
+import * as _$vue from "vue";
+import { Component } from "vue";
+import { ButtonProps } from "element-plus";
+
+//#region src/packages/controls/button/button.vue.d.ts
+type __VLS_Props = {
+  control: Partial<OptionT>;
+};
+declare var __VLS_11: {}, __VLS_35: {}, __VLS_43: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_11) => any;
+} & {
+  loading?: (props: typeof __VLS_35) => any;
+} & {
+  icon?: (props: typeof __VLS_43) => any;
+};
+declare const __VLS_base: _$vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  click: (...args: any[]) => void;
+}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onClick?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default_1: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+declare namespace button_d_exports {
+  export { OptionT, Template, init };
+}
+declare const Template: SFCWithInstall<typeof _default_1>;
+type OptionT = Mutable<ButtonProps> & baseT & {
+  default: any;
+  loadingSlot: any;
+  iconSlot: any;
+  moduleName: string;
+  name: string;
+  customized: boolean;
+  suffixIcon: any | string | Component;
+  tag: any;
+  separator: boolean;
+  click: (e: any) => any | Promise<any>;
+  refreshButton?: (options: any, data?: any) => Partial<OptionT>;
+};
+declare function init(moduleName: string, name: string, options?: Partial<OptionT>): Partial<OptionT>;
+//#endregion
+export { button_d_exports as t };

package/dist/index-CeemHBNT.d.ts

@@ -0,0 +1,51 @@
+import { t as baseT } from "./index-BHq-BMCP.js";
+import { o as SFCWithInstall } from "./index-DamAmum6.js";
+import { O as Mutable } from "./index-BI-hrf4t.js";
+import * as _$vue from "vue";
+import { Component } from "vue";
+import { ButtonProps } from "element-plus";
+
+//#region src/packages/controls/button/button.vue.d.ts
+type __VLS_Props = {
+  control: Partial<OptionT>;
+};
+declare var __VLS_11: {}, __VLS_35: {}, __VLS_43: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_11) => any;
+} & {
+  loading?: (props: typeof __VLS_35) => any;
+} & {
+  icon?: (props: typeof __VLS_43) => any;
+};
+declare const __VLS_base: _$vue.DefineComponent<__VLS_Props, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  click: (...args: any[]) => void;
+}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onClick?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default_1: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+declare namespace button_d_exports {
+  export { OptionT, Template, init };
+}
+declare const Template: SFCWithInstall<typeof _default_1>;
+type OptionT = Mutable<ButtonProps> & baseT & {
+  default: any;
+  loadingSlot: any;
+  iconSlot: any;
+  moduleName: string;
+  name: string;
+  customized: boolean;
+  suffixIcon: any | string | Component;
+  tag: any;
+  separator: boolean;
+  click: (e: any) => any | Promise<any>;
+  refreshButton?: (options: any, data?: any) => Partial<OptionT>;
+};
+declare function init(moduleName: string, name: string, options?: Partial<OptionT>): Partial<OptionT>;
+//#endregion
+export { button_d_exports as t };

package/dist/index-CfkAYIKD.d.cts

@@ -0,0 +1,80 @@
+import { CSSProperties } from "vue";
+
+//#region src/packages/utils/dom/aria.d.ts
+/**
+ * Determine if the testing element is visible on screen no matter if its on the viewport or not
+ */
+declare const isVisible: (element: HTMLElement) => boolean;
+declare const obtainAllFocusableElements: (element: HTMLElement) => HTMLElement[];
+/**
+ * @desc Determine if target element is focusable
+ * @param element {HTMLElement}
+ * @returns {Boolean} true if it is focusable
+ */
+declare const isFocusable: (element: HTMLElement) => boolean;
+/**
+ * @desc Set Attempt to set focus on the current node.
+ * @param element
+ *          The node to attempt to focus on.
+ * @returns
+ *  true if element is focused.
+ */
+declare const attemptFocus: (element: HTMLElement) => boolean;
+/**
+ * Trigger an event
+ * mouseenter, mouseleave, mouseover, keyup, change, click, etc.
+ * @param  {HTMLElement} elm
+ * @param  {String} name
+ * @param  {*} opts
+ */
+declare const triggerEvent: (elm: HTMLElement, name: string, ...opts: Array<boolean>) => HTMLElement;
+declare const isLeaf: (el: HTMLElement) => boolean;
+declare const getSibling: (el: HTMLElement, distance: number, elClass: string) => Element | null;
+declare const focusNode: (el: HTMLElement) => void;
+//#endregion
+//#region src/packages/utils/dom/event.d.ts
+declare const composeEventHandlers: <E>(theirsHandler?: (event: E) => boolean | void, oursHandler?: (event: E) => void, {
+  checkForDefaultPrevented
+}?: {
+  checkForDefaultPrevented?: boolean | undefined;
+}) => (event: E) => void;
+type WhenMouseHandler = (e: PointerEvent) => any;
+declare const whenMouse: (handler: WhenMouseHandler) => WhenMouseHandler;
+//#endregion
+//#region src/packages/utils/dom/position.d.ts
+declare const isInContainer: (el?: Element, container?: Element | Window) => boolean;
+declare const getOffsetTop: (el: HTMLElement) => number;
+declare const getOffsetTopDistance: (el: HTMLElement, containerEl: HTMLElement) => number;
+declare const getClientXY: (event: MouseEvent | TouchEvent) => {
+  clientX: number;
+  clientY: number;
+};
+//#endregion
+//#region src/packages/utils/dom/scroll.d.ts
+declare const isScroll: (el: HTMLElement, isVertical?: boolean) => boolean;
+declare const getScrollContainer: (el: HTMLElement, isVertical?: boolean) => Window | HTMLElement | undefined;
+declare const getScrollBarWidth: (namespace: string) => number;
+/**
+ * Scroll with in the container element, positioning the **selected** element at the top
+ * of the container
+ */
+declare function scrollIntoView(container: HTMLElement, selected: HTMLElement): void;
+declare function animateScrollTo(container: HTMLElement | Window, from: number, to: number, duration: number, callback?: unknown): () => void;
+declare const getScrollElement: (target: HTMLElement, container: HTMLElement | Window) => HTMLElement;
+declare const getScrollTop: (container: HTMLElement | Window) => number;
+//#endregion
+//#region src/packages/utils/dom/style.d.ts
+declare const classNameToArray: (cls?: string) => string[];
+declare const hasClass: (el: Element, cls: string) => boolean;
+declare const addClass: (el: Element, cls: string) => void;
+declare const removeClass: (el: Element, cls: string) => void;
+declare const getStyle: (element: HTMLElement, styleName: keyof CSSProperties) => string;
+declare const setStyle: (element: HTMLElement, styleName: CSSProperties | keyof CSSProperties, value?: string | number) => void;
+declare const removeStyle: (element: HTMLElement, style: CSSProperties | keyof CSSProperties) => void;
+declare function addUnit(value?: string | number, defaultUnit?: string): string | undefined;
+//#endregion
+//#region src/packages/utils/dom/element.d.ts
+type GetElement = <T extends string | HTMLElement | Window | null | undefined>(target: T) => T extends string ? HTMLElement | null : T;
+declare const getElement: GetElement;
+//#endregion
+export { triggerEvent as A, attemptFocus as C, isLeaf as D, isFocusable as E, isVisible as O, whenMouse as S, getSibling as T, getClientXY as _, getStyle as a, isInContainer as b, removeStyle as c, getScrollBarWidth as d, getScrollContainer as f, scrollIntoView as g, isScroll as h, classNameToArray as i, obtainAllFocusableElements as k, setStyle as l, getScrollTop as m, addClass as n, hasClass as o, getScrollElement as p, addUnit as r, removeClass as s, getElement as t, animateScrollTo as u, getOffsetTop as v, focusNode as w, composeEventHandlers as x, getOffsetTopDistance as y };

package/dist/index-CiJC-ieW.d.ts

@@ -0,0 +1,157 @@
+import { ExtractPropTypes, PropType } from "vue";
+
+//#region src/packages/utils/vue/props/util.d.ts
+type Writable<T> = { -readonly [P in keyof T]: T[P] };
+type WritableArray<T> = T extends readonly any[] ? Writable<T> : T;
+type IfNever<T, Y = true, N = false> = [T] extends [never] ? Y : N;
+type IfUnknown<T, Y, N> = [unknown] extends [T] ? Y : N;
+type UnknownToNever<T> = IfUnknown<T, never, T>;
+//#endregion
+//#region src/packages/utils/vue/props/runtime.d.ts
+declare const epPropKey = "__epPropKey";
+declare const definePropType: <T>(val: any) => PropType<T>;
+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
+ */
+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>;
+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]>>> };
+//#endregion
+//#region src/packages/utils/vue/props/types.d.ts
+type Value<T> = T[keyof T];
+/**
+ * Extract the type of a single prop
+ *
+ * 提取单个 prop 的参数类型
+ *
+ * @example
+ * ExtractPropType<{ type: StringConstructor }> => string | undefined
+ * ExtractPropType<{ type: StringConstructor, required: true }> => string
+ * ExtractPropType<{ type: BooleanConstructor }> => boolean
+ */
+type ExtractPropType<T extends object> = Value<ExtractPropTypes<{
+  key: T;
+}>>;
+/**
+ * Extracts types via `ExtractPropTypes`, accepting `PropType<T>`, `XXXConstructor`, `never`...
+ *
+ * 通过 `ExtractPropTypes` 提取类型，接受 `PropType<T>`、`XXXConstructor`、`never`...
+ *
+ * @example
+ * ResolvePropType<BooleanConstructor> => boolean
+ * ResolvePropType<PropType<T>> => T
+ **/
+type ResolvePropType<T> = IfNever<T, never, ExtractPropType<{
+  type: WritableArray<T>;
+  required: true;
+}>>;
+/**
+ * Merge Type, Value, Validator types
+ * 合并 Type、Value、Validator 的类型
+ *
+ * @example
+ * EpPropMergeType<StringConstructor, '1', 1> =>  1 | "1" // ignores StringConstructor
+ * EpPropMergeType<StringConstructor, never, number> =>  string | number
+ */
+type EpPropMergeType<Type, Value, Validator> = IfNever<UnknownToNever<Value>, ResolvePropType<Type>, never> | UnknownToNever<Value> | UnknownToNever<Validator>;
+/**
+ * Handling default values for input (constraints)
+ *
+ * 处理输入参数的默认值（约束）
+ */
+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` 等
+ */
+type NativePropType = ((...args: any) => any) | {
+  new (...args: any): any;
+} | undefined | null;
+type IfNativePropType<T, Y, N> = [T] extends [NativePropType] ? Y : N;
+/**
+ * input prop `buildProp` or `buildProps` (constraints)
+ *
+ * prop 输入参数（约束）
+ *
+ * @example
+ * EpPropInput<StringConstructor, 'a', never, never, true>
+ * ⬇️
+ * {
+    type?: StringConstructor | undefined;
+    required?: true | undefined;
+    values?: readonly "a"[] | undefined;
+    validator?: ((val: any) => boolean) | ((val: any) => val is never) | undefined;
+    default?: undefined;
+  }
+ */
+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 输出参数。
+ *
+ * @example
+ * EpProp<'a', 'b', true>
+ * ⬇️
+ * {
+    readonly type: PropType<"a">;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    readonly default: "b";
+    __epPropKey: true;
+  }
+ */
+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`
+ */
+type IfEpProp<T, Y, N> = T extends {
+  [epPropKey]: true;
+} ? Y : N;
+/**
+ * Converting input to output.
+ *
+ * 将输入转换为输出
+ */
+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
+ */
+type EpPropFinalized<Type, Value, Validator, Default, Required> = EpProp<EpPropMergeType<Type, Value, Validator>, UnknownToNever<Default>, Required>;
+//#endregion
+export { IfNever as _, EpPropInputDefault as a, Writable as b, IfEpProp as c, ResolvePropType as d, buildProp as f, isEpProp as g, epPropKey as h, EpPropInput as i, IfNativePropType as l, definePropType as m, EpPropConvert as n, EpPropMergeType as o, buildProps as p, EpPropFinalized as r, ExtractPropType as s, EpProp as t, NativePropType as u, IfUnknown as v, WritableArray as x, UnknownToNever as y };

package/dist/index-DamAmum6.d.ts

@@ -0,0 +1,15 @@
+import { AppContext, Directive, EmitsOptions, Plugin, SetupContext } from "vue";
+
+//#region src/packages/utils/vue/typescript.d.ts
+type SFCWithInstall<T> = T & Plugin;
+type SFCInstallWithContext<T> = SFCWithInstall<T> & {
+  _context: AppContext | null;
+};
+type EmitFn<E extends EmitsOptions> = SetupContext<E>['emit'];
+//#endregion
+//#region src/packages/utils/vue/install.d.ts
+declare const withInstall: <T, E extends Record<string, any>>(main: T, extra?: E) => SFCWithInstall<T> & E;
+declare const withInstallFunction: <T>(fn: T, name: string) => SFCInstallWithContext<T>;
+declare const withInstallDirective: <T extends Directive>(directive: T, name: string) => SFCWithInstall<T>;
+//#endregion
+export { SFCInstallWithContext as a, EmitFn as i, withInstallDirective as n, SFCWithInstall as o, withInstallFunction as r, withInstall as t };