yuyeon 0.0.0 → 0.0.2

package/types/components/tooltip/index.d.ts

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

package/types/components/transitions/expand-transition.d.ts

@@ -0,0 +1,16 @@
+import { PropType } from 'vue';
+export declare function createExpandTransition(isHorizon?: boolean): import("vue").DefineComponent<{
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+}, {}>;

package/types/components/transitions/index.d.ts

@@ -0,0 +1,32 @@
+export declare const YExpandVTransition: import("vue").DefineComponent<{
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+}, {}>;
+export declare const YExpandHTransition: import("vue").DefineComponent<{
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    disabled: {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+}, {}>;
+export type YExpandVTransition = InstanceType<typeof YExpandVTransition>;
+export type YExpandHTransition = InstanceType<typeof YExpandHTransition>;

package/types/components/tree-view/YTreeView.d.ts

@@ -0,0 +1,37 @@
+import { PropType } from 'vue';
+type NodeKey = string | number;
+export declare const YTreeView: import("vue").DefineComponent<{
+    items: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    itemKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    childrenKey: {
+        type: PropType<string>;
+        default: string;
+    };
+}, {
+    nodes: import("vue").Ref<Record<NodeKey, any>>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    items: {
+        type: PropType<any[]>;
+        default: () => never[];
+    };
+    itemKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    childrenKey: {
+        type: PropType<string>;
+        default: string;
+    };
+}>>, {
+    itemKey: string;
+    childrenKey: string;
+    items: any[];
+}, {}>;
+export type YTreeView = InstanceType<typeof YTreeView>;
+export {};

package/types/components/tree-view/YTreeViewNode.d.ts

@@ -0,0 +1,51 @@
+import { PropType } from 'vue';
+export declare const YTreeViewNode: import("vue").DefineComponent<{
+    item: {
+        type: PropType<any>;
+    };
+    itemKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    textKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    childrenKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    level: {
+        type: PropType<number>;
+        default: number;
+    };
+}, {
+    treeView: any;
+    myKey: import("vue").ComputedRef<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: PropType<any>;
+    };
+    itemKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    textKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    childrenKey: {
+        type: PropType<string>;
+        default: string;
+    };
+    level: {
+        type: PropType<number>;
+        default: number;
+    };
+}>>, {
+    itemKey: string;
+    textKey: string;
+    childrenKey: string;
+    level: number;
+}, {}>;
+export type YTreeNode = InstanceType<typeof YTreeViewNode>;

package/types/components/tree-view/index.d.ts

@@ -0,0 +1,2 @@
+export * from './YTreeViewNode';
+export * from './YTreeView';

package/types/composables/communication.d.ts

@@ -0,0 +1 @@
+export declare function useModelDuplex(props: any, prop?: string, defaultValue?: any, getIn?: (value?: any) => any, setOut?: (value: any) => any): import("vue").WritableComputedRef<any>;

package/types/composables/component.d.ts

@@ -0,0 +1,2 @@
+import { VNode } from 'vue';
+export declare function useRender(render: () => VNode): void;

package/types/composables/layer-group.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from 'vue';
+export declare const Y_LAYER_GROUP_CLASS_NAME = "y-layer-group";
+export declare function useLayerGroup(target?: Ref<string | Element>): {
+    layerGroup: import("vue").ComputedRef<string | HTMLElement>;
+};

package/types/composables/progress.d.ts

@@ -0,0 +1,3 @@
+export declare function useProgress(props: any): {
+    numValue: import("vue").ComputedRef<number>;
+};

package/types/composables/resize-observer.d.ts

@@ -0,0 +1,14 @@
+export declare function useResizeObserver(callback?: ResizeObserverCallback): {
+    resizeObservedRef: import("vue").Ref<HTMLElement | undefined>;
+    contentRect: Readonly<import("vue").Ref<{
+        readonly bottom: number;
+        readonly height: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        readonly width: number;
+        readonly x: number;
+        readonly y: number;
+        readonly toJSON: () => any;
+    } | undefined>>;
+};

package/types/composables/scope.d.ts

@@ -0,0 +1,2 @@
+import type { WatchSource } from 'vue';
+export declare function useToggleScope(source: WatchSource<boolean>, fn: (reset: () => void) => void): void;

package/types/composables/theme/index.d.ts

@@ -0,0 +1,15 @@
+import type { App } from 'vue';
+import type { ThemeOptions } from "./setting";
+export declare const Y_THEME_PREFIX = "y-theme";
+export declare const YUYEON_THEME_KEY: unique symbol;
+export declare function createThemeModule(options: ThemeOptions): {
+    install: (app: App) => void;
+    init: (yuyeon: any) => void;
+    scope: import("vue").EffectScope;
+    instance: {
+        scheme: any;
+        theme: [string, string];
+        themes: any;
+        mode: any;
+    };
+};

package/types/composables/theme/setting.d.ts

@@ -0,0 +1,12 @@
+export declare const ThemeScheme: {
+    readonly light: "light";
+    readonly dark: "dark";
+};
+export interface ThemeOptions {
+    mode: 'manual';
+    scheme: keyof typeof ThemeScheme | 'normal';
+    theme: string | [string, string];
+    themes: any;
+}
+export declare const defaultThemesValues: any;
+export declare function configureOptions(options?: ThemeOptions): any;

package/types/composables/timing.d.ts

@@ -0,0 +1,15 @@
+import { Ref } from 'vue';
+export declare function useLazy(eager: boolean, updated: Ref<any>): {
+    entered: Ref<boolean>;
+    lazyValue: import("vue").ComputedRef<any>;
+    onAfterUpdate: () => void;
+};
+export declare function useTimer(cb: () => void, duration?: number, options?: {
+    tickDuration: number;
+}): {
+    start: () => void;
+    stop: () => void;
+    reset: () => void;
+    drift: Ref<number>;
+    isWork: Ref<boolean>;
+};

package/types/composables/transition.d.ts

@@ -0,0 +1,21 @@
+import { Component, FunctionalComponent, PropType, TransitionProps } from 'vue';
+export declare const polyTransitionPropOptions: {
+    transition: {
+        type: PropType<string | (TransitionProps & {
+            is?: Component | undefined;
+        })>;
+        default: string;
+    };
+};
+export declare function usePolyTransition(props: {
+    transition: any;
+}): {
+    polyTransitionBindProps: import("vue").ComputedRef<{
+        is: any;
+        transitionProps: any;
+    }>;
+};
+export declare const PolyTransition: FunctionalComponent<TransitionProps & {
+    is: string | Component;
+    transitionProps: TransitionProps;
+}>;

package/types/directives/complement-click/index.d.ts

@@ -0,0 +1,25 @@
+import { DirectiveBinding } from 'vue';
+interface ComplementClickDirectiveElementImplanted {
+    onClick: EventListener;
+    onMousedown: EventListener;
+}
+declare global {
+    interface Element {
+        _complementClick?: Record<number, ComplementClickDirectiveElementImplanted | undefined> & {
+            lastMousedownWasOutside: boolean;
+        };
+    }
+}
+export interface ComplementClickBindingOptions {
+    handler: (mouseEvent: MouseEvent) => void;
+    determine?: (event: Event) => boolean;
+    include?: () => HTMLElement[];
+}
+export interface ComplementClickBinding extends DirectiveBinding {
+    value: ((mouseEvent: MouseEvent) => void) | ComplementClickBindingOptions;
+}
+export declare const ComplementClick: {
+    mounted(element: HTMLElement, binding: ComplementClickBinding): void;
+    unmounted(element: HTMLElement, binding: ComplementClickBinding): void;
+};
+export {};

package/types/directives/plate-wave/index.d.ts

@@ -0,0 +1,13 @@
+import type { DirectiveBinding } from 'vue';
+export interface PlateWaveBinding extends Omit<DirectiveBinding, 'modifiers' | 'value'> {
+    value?: boolean;
+    modifiers: {
+        stop?: boolean;
+    };
+}
+export declare const PlateWave: {
+    mounted(el: HTMLElement, binding: PlateWaveBinding): void;
+    updated(el: HTMLElement, binding: PlateWaveBinding): void;
+    unmount(el: HTMLElement): void;
+};
+export default PlateWave;

package/types/directives/theme-class.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDirective } from "vue";
+declare const bindThemeClass: FunctionDirective;
+export default bindThemeClass;

package/types/etc/index.d.ts

@@ -0,0 +1 @@
+export declare const YUYEON_LOGO = ",--. ,--.,--.,--.,--. ,--.,---.  ,---. ,--,--,  \n \\  '  / |  ||  | \\  '  /| .-. :| .-. ||      \\ \n  \\   '  '  ''  '  \\   ' \\   --.' '-' '|  ||  | \n.-'  /    `----' .-'  /   `----' `---' `--''--' \n`---'            `---'                          ";

package/types/globals.d.ts

@@ -0,0 +1,11 @@
+import type { VNode } from "vue";
+
+declare global {
+  namespace JSX {
+    interface Element extends VNode {}
+
+    interface IntrinsicAttributes {
+      [name: string]: any
+    }
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,9 @@
+import type { App } from 'vue';
+declare module 'vue' {
+    interface ComponentCustomProperties {
+        $yuyeon: any;
+    }
+}
+export declare function init(options?: any): {
+    install: (app: App) => any;
+};

package/types/mixins/di.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/types/mixins/rebind-attrs.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {
+    attrs_$: any;
+    listeners_$: any;
+}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _default;

package/types/shims.d.ts

@@ -0,0 +1,71 @@
+import * as vue from 'vue';
+import {
+  YApp,
+  YButton,
+  YCard,
+  YCardBody,
+  YCardFooter,
+  YCardHeader,
+  YCheckbox,
+  YChip,
+  YDataTable,
+  YDataTableServer,
+  YDialog,
+  YDividePanel,
+  YExpandHTransition,
+  YExpandVTransition,
+  YFieldInput,
+  YForm,
+  YInput,
+  YInputCheckbox,
+  YLayer,
+  YList,
+  YListItem,
+  YMenu,
+  YPagination,
+  YProgressBar,
+  YSnackbar,
+  YSpinnerRing,
+  YSwitch,
+  YTable,
+  YTooltip,
+  YTreeView,
+  YTreeViewNode,
+} from 'yuyeon/types/components';
+
+declare module '@vue/runtime-core' {
+  export interface GlobalComponents {
+    // @define-components
+    YApp: typeof YApp;
+    YButton: typeof YButton;
+    YChip: typeof YChip;
+    YInput: typeof YInput;
+    YFieldInput: typeof YFieldInput;
+    YForm: typeof YForm;
+    YCard: typeof YCard;
+    YCardBody: typeof YCardBody;
+    YCardHeader: typeof YCardHeader;
+    YCardFooter: typeof YCardFooter;
+    YDialog: typeof YDialog;
+    YLayer: typeof YLayer;
+    YSnackbar: typeof YSnackbar;
+    YProgressBar: typeof YProgressBar;
+    YSpinnerRing: typeof YSpinnerRing;
+    YTooltip: typeof YTooltip;
+    YExpandVTransition: typeof YExpandVTransition;
+    YExpandHTransition: typeof YExpandHTransition;
+    YDividePanel: typeof YDividePanel;
+    YList: typeof YList;
+    YListItem: typeof YListItem;
+    YTreeView: typeof YTreeView;
+    YTreeViewNode: typeof YTreeViewNode;
+    YDataTable: typeof YDataTable;
+    YTable: typeof YTable;
+    YDataTableServer: typeof YDataTableServer;
+    YMenu: typeof YMenu;
+    YPagination: typeof YPagination;
+    YInputCheckbox: typeof YInputCheckbox;
+    YCheckbox: typeof YCheckbox;
+    YSwitch: typeof YSwitch;
+  }
+}

package/types/util/common.d.ts

@@ -0,0 +1,8 @@
+export declare function hasOwnProperty(object: any, property: string): boolean;
+export declare function getNestedValue(obj: any, path: (string | number)[], fallback?: any): any;
+export declare function mergeDeep(source?: Record<string, any>, overwrite?: Record<string, any>, arrayFn?: (source: unknown[], overwrite: unknown[]) => unknown[]): {
+    [x: string]: any;
+};
+export declare function getObjectValueByPath(obj: any, path: string, fallback?: any): any;
+export declare function randomCharOne(str: string): string;
+export declare function clamp(value: number, min?: number, max?: number): number;

package/types/util/dom.d.ts

@@ -0,0 +1 @@
+export declare function documentRoot(domNode: Node): null | HTMLDocument | ShadowRoot;

package/types/util/string.d.ts

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

package/types/util/ui.d.ts

@@ -0,0 +1,9 @@
+export declare function colorHexToRgb(color: string): number[] | undefined;
+export declare function textColorIsLight(r: number, g: number, b: number): boolean;
+export declare const RGBA_REGEX: RegExp;
+export declare const HEX_COLOR_REGEX: RegExp;
+export declare function isColorValue(value: string): boolean;
+export declare function toStyleSizeValue(size: number | string | null | undefined, unit?: string): string | undefined;
+export declare function getBoundingPureRect(el: HTMLElement): DOMRect;
+export declare function pixelRound(val: number): number;
+export declare function pixelCeil(val: number): number;

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

@@ -0,0 +1,33 @@
+import type { IfAny } from '@vue/shared';
+import type { ComponentObjectPropsOptions, ComponentPublicInstance, Prop, PropType, VNode } 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 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 propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults | undefined) => OverwrittenPropOptions<PropsOptions, Defaults>;
+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: FollowPropType<Pick<T[P], 'type'>, T[P], D[P]>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefault<P, D>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
+type MergeDefault<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
+type FollowPropType<T, P, D> = [T] extends [PropType<unknown>] ? T : PropType<MergeDefault<P, 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 {};

package/types/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/src/components/button/index.ts

@@ -1,3 +0,0 @@
-import YBtn from './y-btn';
-
-export { YBtn };

package/src/components/button/y-btn.ts

@@ -1,104 +0,0 @@
-import { defineComponent, h, VNodeArrayChildren, withDirectives } from 'vue';
-import { getSlot } from "../../util/vue-component";
-import { PlateWave } from "../../directives/plate-wave";
-
-/**
- * Style
- */
-import './y-btn.scss';
-import YRingSpinner from '../ring-spinner/y-ring-spinner.vue';
-import { isColorValue } from '../../util/ui';
-
-const NAME = 'y-btn';
-
-export default defineComponent({
-  name: NAME,
-  directives: {
-    PlateWave,
-  },
-  props: {
-    loading: Boolean,
-    outlined: {
-      type: Boolean,
-      default: false,
-    },
-    rounded: {
-      type: Boolean,
-      default: false,
-    },
-    filled: {
-      type: Boolean,
-      default: false,
-    },
-    disabled: {
-      type: Boolean,
-    },
-    text: {
-      type: Boolean,
-    },
-    color: {
-      type: String,
-    },
-  },
-  computed: {
-    classes() {
-      return {
-        [`${NAME}--outlined`]: this.outlined,
-        [`${NAME}--loading`]: this.loading,
-        [`${NAME}--rounded`]: this.rounded,
-        [`${NAME}--filled`]: this.filled,
-        [`${NAME}--disabled`]: this.disabled,
-        [`${NAME}--text`]: this.text,
-      };
-    },
-    styles(): Record<string, any> {
-      let { color } = this;
-      if (color && !isColorValue(color)) {
-        color = `var(--y-palette--${color})`;
-      }
-      return {
-        [`--y-btn__color`]: color,
-      };
-    },
-  },
-  methods: {
-    createContent() {
-      const defaultSlot = getSlot(this, 'default');
-      const children: VNodeArrayChildren = [];
-      if (this.loading) {
-        children.push(h(YRingSpinner));
-      }
-      children.push(defaultSlot);
-      return h('span', { class: 'y-btn__content' }, children);
-    },
-    getClasses() {
-      return this.classes;
-    },
-    /// Events
-    onClick(e: MouseEvent) {
-      e.preventDefault();
-      if (this.loading) {
-        return;
-      }
-    },
-  },
-  render() {
-    const { onClick, styles } = this;
-    return withDirectives(
-      h(
-        'button',
-        {
-          class: {
-            ...this.getClasses(),
-            [`${NAME}`]: true,
-          },
-          style: styles,
-          onClick,
-          '^disabled': this.disabled ? true : undefined,
-        },
-        this.createContent(),
-      ),
-      [[PlateWave, true]],
-    );
-  },
-});

package/src/components/card/index.ts

@@ -1,6 +0,0 @@
-import YCard from './y-card';
-import YCardHeader from './y-card-header';
-import YCardBody from './y-card-body';
-import YCardFooter from './y-card-footer';
-
-export { YCard, YCardHeader, YCardBody, YCardFooter };

package/src/components/card/y-card-body.ts

@@ -1,8 +0,0 @@
-import { defineComponent, h } from 'vue';
-
-export default defineComponent({
-  name: 'y-card-body',
-  render() {
-    return h('div', { class: 'y-card__body' }, this.$slots.default?.());
-  },
-});

package/src/components/card/y-card-footer.ts

@@ -1,8 +0,0 @@
-import { defineComponent, h } from 'vue';
-
-export default defineComponent({
-  name: 'y-card-footer',
-  render() {
-    return h('div', { class: 'y-card__footer' }, this.$slots.default?.());
-  },
-});

package/src/components/card/y-card-header.ts

@@ -1,8 +0,0 @@
-import { defineComponent, h } from 'vue';
-
-export default defineComponent({
-  name: 'y-card-header',
-  render() {
-    return h('div', { class: 'y-card__header' }, this.$slots.default?.());
-  },
-});

package/src/components/card/y-card.ts

@@ -1,16 +0,0 @@
-import { defineComponent, h, VNode } from 'vue';
-
-import './y-card.scss';
-
-export default defineComponent({
-  name: 'y-card',
-  render(): VNode {
-    return h(
-      'div',
-      {
-        class: ['y-card'],
-      },
-      this.$slots.default?.call(this),
-    );
-  },
-});