yuyeon 0.1.0-rc.13 → 0.1.0-rc.16

package/dist/util/date/types.d.ts

@@ -0,0 +1,167 @@
+export interface DateAdapter<T = unknown> {
+    /**
+     *
+     * @param value
+     */
+    date(value?: any): T | null;
+    /**
+     *
+     * @param date
+     * @param formatString
+     */
+    format(date: T, formatString: string): string;
+    /**
+     *
+     * @param value
+     */
+    toJsDate(value: T): Date;
+    /**
+     *
+     * @param date
+     */
+    parseISO(date: string): T;
+    /**
+     *
+     * @param date
+     */
+    toISO(date: T): string;
+    /**
+     *
+     * @param date
+     */
+    startOfDay(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    endOfDay(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    startOfMonth(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    endOfMonth(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    startOfYear(date: T): T;
+    /**
+     *
+     * @param date
+     */
+    endOfYear(date: T): T;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isBefore(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isAfter(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isEqual(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isSameDay(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     * @param comparing
+     */
+    isSameMonth(date: T, comparing: T): boolean;
+    /**
+     *
+     * @param date
+     */
+    isValid(date: any): boolean;
+    /**
+     *
+     * @param date
+     * @param range
+     */
+    isWithinRange(date: T, range: [T, T]): boolean;
+    /**
+     *
+     * @param date
+     * @param amount
+     */
+    addDays(date: T, amount: number): T;
+    /**
+     *
+     * @param date
+     * @param amount
+     */
+    addMonths(date: T, amount: number): T;
+    /**
+     *
+     * @param date
+     */
+    getYear(date: T): number;
+    /**
+     *
+     * @param date
+     * @param year
+     */
+    setYear(date: T, year: number): T;
+    /**
+     *
+     * @param date
+     * @param comparing
+     * @param unit
+     */
+    getDiff(date: T, comparing: T | string, unit?: string): number;
+    /**
+     *
+     *
+     * @param date
+     */
+    getWeekArray(date: T): T[][];
+    /**
+     *
+     */
+    getWeekdays(): string[];
+    /**
+     *  0 ~ 11
+     * @param date
+     */
+    getMonth(date: T): number;
+    /**
+     *
+     * @param date
+     * @param month
+     */
+    setMonth(date: T, month: number): T;
+    /**
+     *
+     * get day (1-31) number
+     *
+     * @param date
+     */
+    getDay(date: T): number;
+    /**
+     *
+     * @param date
+     */
+    getNextMonth(date: T): T;
+    getHour(date: T): number;
+    setHour(date: T, hour: number): T;
+    getMinute(date: T): number;
+    setMinute(date: T, minute: number): T;
+}
+export type DateFormatOptions = Intl.DateTimeFormatOptions | ((date: Date, formatString: string, locale: string) => string);

package/dist/util/debounce.d.ts

@@ -0,0 +1,11 @@
+interface DebouncedFn<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+}
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, options?: {
+    leading: boolean;
+    maxWait?: number;
+    trailing: boolean;
+}): DebouncedFn<T>;
+export {};

package/dist/util/dom.d.ts

@@ -0,0 +1,3 @@
+export declare function documentRoot(domNode: Node): null | HTMLDocument | ShadowRoot;
+export declare function hasElementMouseEvent(mouseEvent: Event, element: HTMLElement, include?: HTMLElement[]): boolean;
+export declare function isOverflow(el: HTMLElement): boolean;

package/dist/util/frame-scheduler.d.ts

@@ -0,0 +1,7 @@
+export declare class FrameScheduler {
+    private clean;
+    private frames;
+    private raf;
+    private run;
+    requestNewFrame(callback: () => void): void;
+}

package/dist/util/index.d.ts

@@ -0,0 +1,16 @@
+export * from './common';
+export * from './collection';
+export * from './array';
+export * from './string';
+export * from './validation';
+export * from './debounce';
+export * from './dom';
+export * from './ui';
+export * from './rect';
+export * from './anchor';
+export * from './scroll';
+export * from './frame-scheduler';
+export * from './vue-component';
+export * from './reactivity';
+export * from './color';
+export * from './date';

package/dist/util/reactivity.d.ts

@@ -0,0 +1,7 @@
+import { ComputedGetter } from 'vue';
+
+/**
+ * For Destructuring assignment
+ * @param getter
+ */
+export declare function $computed<T extends object>(getter: ComputedGetter<T>): import('vue').ToRefs<T>;

package/dist/util/rect.d.ts

@@ -0,0 +1,36 @@
+export interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+export declare class MutableRect implements Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    constructor({ x, y, width, height }: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    });
+    get top(): number;
+    get bottom(): number;
+    get left(): number;
+    get right(): number;
+}
+export declare function getOverflow(a: MutableRect, b: MutableRect): {
+    x: {
+        before: number;
+        after: number;
+    };
+    y: {
+        before: number;
+        after: number;
+    };
+};

package/dist/util/scroll.d.ts

@@ -0,0 +1,3 @@
+export declare function getScrollParent(el?: HTMLElement, horizontal?: boolean): HTMLElement;
+export declare function getScrollParents(el?: Element | null, stopAt?: Element | null, horizontal?: boolean): HTMLElement[];
+export declare function hasScrollbar(el?: Element | null, horizontal?: boolean): boolean;

package/dist/util/string.d.ts

@@ -0,0 +1,4 @@
+export declare function camelToPascal(str: string): string;
+export declare function toKebabCase(str: string, from?: 'camel' | 'pascal'): string;
+export declare function kebabToCamel(str: string): string;
+export declare function randomCharOne(str: string): string;

package/dist/util/ui.d.ts

@@ -0,0 +1,4 @@
+export declare function getBoundingPureRect(el: HTMLElement): DOMRect;
+export declare function pixelRound(val: number): number;
+export declare function pixelCeil(val: number): number;
+export declare function toStyleSizeValue(size: number | string | null | undefined, unit?: string): string | undefined;

package/dist/util/validation.d.ts

@@ -0,0 +1,3 @@
+export declare function REQUIRE_RULE(value: any): boolean;
+declare const _default: {};
+export default _default;

package/dist/util/vue-component.d.ts

@@ -0,0 +1,39 @@
+import { ComponentInternalInstance } from '@vue/runtime-core';
+import { IfAny } from '@vue/shared';
+import { ComponentObjectPropsOptions, ComponentPublicInstance, ExtractPropTypes, InjectionKey, Prop, PropType, VNode, VNodeChild } from 'vue';
+
+export declare function getSlot(vm: ComponentPublicInstance | any, name?: string, data?: any | (() => any), optional?: boolean): VNode[] | undefined;
+export declare function getUid(): number | undefined;
+export declare function chooseProps<PropsOptions extends ComponentObjectPropsOptions>(props: any, target: PropsOptions): ExtractPropTypes<PropsOptions>;
+export declare function bindClasses(classes: string | string[] | Record<string, any> | undefined): Record<string, boolean>;
+export declare function getHtmlElement<N extends object | undefined>(node: N): Exclude<N, ComponentPublicInstance> | HTMLElement;
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => OverwrittenPropOptions<PropsOptions, Defaults>;
+export declare function hasEventProp(props: Record<string, any>, type: string): boolean;
+type OverwrittenPropOptions<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], 'type' | 'default'> & {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
+type MergeDefault<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
+type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny<V, V, D> : V : T;
+export type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
+export declare const EventPropOption: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;
+export {};