@ilokesto/utilinent 1.0.14 → 1.1.1

package/dist/constants/htmlTags.js

@@ -1,3 +1,87 @@
-export const htmlTags = [
-    "a", "abbr", "address", "article", "aside", "b", "bdi", "bdo", "blockquote", "button", "canvas", "cite", "code", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hr", "i", "img", "input", "ins", "kbd", "label", "legend", "li", "main", "map", "mark", "menu", "meter", "nav", "ol", "option", "output", "p", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "section", "select", "small", "span", "strong", "sub", "summary", "sup", "table", "tbody", "td", "textarea", "tfoot", "th", "thead", "time", "tr", "u", "ul", "var", "video"
-];
+export const htmlTags = {
+    a: "a",
+    abbr: "abbr",
+    address: "address",
+    article: "article",
+    aside: "aside",
+    b: "b",
+    bdi: "bdi",
+    bdo: "bdo",
+    blockquote: "blockquote",
+    button: "button",
+    canvas: "canvas",
+    cite: "cite",
+    code: "code",
+    data: "data",
+    datalist: "datalist",
+    dd: "dd",
+    del: "del",
+    details: "details",
+    dfn: "dfn",
+    dialog: "dialog",
+    div: "div",
+    dl: "dl",
+    dt: "dt",
+    em: "em",
+    fieldset: "fieldset",
+    figcaption: "figcaption",
+    figure: "figure",
+    footer: "footer",
+    form: "form",
+    h1: "h1",
+    h2: "h2",
+    h3: "h3",
+    h4: "h4",
+    h5: "h5",
+    h6: "h6",
+    header: "header",
+    hr: "hr",
+    i: "i",
+    img: "img",
+    input: "input",
+    ins: "ins",
+    kbd: "kbd",
+    label: "label",
+    legend: "legend",
+    li: "li",
+    main: "main",
+    map: "map",
+    mark: "mark",
+    menu: "menu",
+    meter: "meter",
+    nav: "nav",
+    ol: "ol",
+    option: "option",
+    output: "output",
+    p: "p",
+    picture: "picture",
+    pre: "pre",
+    progress: "progress",
+    q: "q",
+    rp: "rp",
+    rt: "rt",
+    ruby: "ruby",
+    s: "s",
+    samp: "samp",
+    section: "section",
+    select: "select",
+    small: "small",
+    span: "span",
+    strong: "strong",
+    sub: "sub",
+    summary: "summary",
+    sup: "sup",
+    table: "table",
+    tbody: "tbody",
+    td: "td",
+    textarea: "textarea",
+    tfoot: "tfoot",
+    th: "th",
+    thead: "thead",
+    time: "time",
+    tr: "tr",
+    u: "u",
+    ul: "ul",
+    var: "var",
+    video: "video"
+};

package/dist/core/PluginManager.d.ts

@@ -1,10 +1,9 @@
+import type { RegistryCategory } from "../types";
 /**
  * 플러그인 등록을 위한 타입
  * Register 인터페이스의 각 카테고리에 대해 부분적으로 등록 가능
  */
-type PluginRegistration = {
-    [K in "show" | "for" | "repeat" | "base"]?: Record<string, any>;
-};
+type PluginRegistration = Partial<Record<RegistryCategory, Record<string, any>>>;
 /**
  * 플러그인 컴포넌트를 등록하고 관리하는 싱글턴 클래스
  *
@@ -41,6 +40,7 @@ export declare class PluginManager {
     private static instance;
     private plugins;
     private constructor();
+    private getCategory;
     /**
      * PluginManager 인스턴스를 가져옵니다
      */
@@ -71,18 +71,18 @@ export declare class PluginManager {
     /**
      * 등록된 플러그인 컴포넌트를 가져옵니다 (내부용)
      */
-    static get<K extends "show" | "for" | "repeat" | "base">(category: K, name: string): any;
+    static get<K extends RegistryCategory>(category: K, name: string): any;
     /**
      * 특정 카테고리의 모든 플러그인을 가져옵니다 (내부용)
      */
-    static getAll<K extends "show" | "for" | "repeat" | "base">(category: K): Map<string, any>;
+    static getAll<K extends RegistryCategory>(category: K): Map<string, any>;
     /**
      * 플러그인이 등록되어 있는지 확인합니다
      */
-    static has<K extends "show" | "for" | "repeat" | "base">(category: K, name: string): boolean;
+    static has<K extends RegistryCategory>(category: K, name: string): boolean;
     /**
      * 플러그인을 제거합니다
      */
-    static unregister<K extends "show" | "for" | "repeat" | "base">(category: K, name: string): boolean;
+    static unregister<K extends RegistryCategory>(category: K, name: string): boolean;
 }
 export {};

package/dist/core/PluginManager.js

@@ -1,3 +1,4 @@
+const DEFAULT_CATEGORIES = ["show", "for", "repeat", "mount", "switch", "base"];
 /**
  * 플러그인 컴포넌트를 등록하고 관리하는 싱글턴 클래스
  *
@@ -32,14 +33,21 @@
  */
 export class PluginManager {
     static instance;
-    plugins = {
-        show: new Map(),
-        for: new Map(),
-        repeat: new Map(),
-        base: new Map(),
-    };
+    plugins = new Map();
     constructor() {
         // 싱글턴 패턴: private constructor
+        DEFAULT_CATEGORIES.forEach((category) => {
+            this.plugins.set(category, new Map());
+        });
+    }
+    getCategory(category) {
+        const existing = this.plugins.get(category);
+        if (existing) {
+            return existing;
+        }
+        const created = new Map();
+        this.plugins.set(category, created);
+        return created;
     }
     /**
      * PluginManager 인스턴스를 가져옵니다
@@ -70,8 +78,7 @@ export class PluginManager {
      */
     static register(plugins) {
         const instance = PluginManager.getInstance();
-        Object.keys(plugins).forEach((category) => {
-            const components = plugins[category];
+        Object.entries(plugins).forEach(([category, components]) => {
             if (components) {
                 Object.entries(components).forEach(([name, component]) => {
                     instance.registerOne(category, name, component);
@@ -83,34 +90,34 @@ export class PluginManager {
      * 단일 플러그인 컴포넌트를 등록합니다 (내부용)
      */
     registerOne(category, name, component) {
-        this.plugins[category].set(name, component);
+        this.getCategory(category).set(name, component);
     }
     /**
      * 등록된 플러그인 컴포넌트를 가져옵니다 (내부용)
      */
     static get(category, name) {
         const instance = PluginManager.getInstance();
-        return instance.plugins[category].get(name);
+        return instance.plugins.get(category)?.get(name);
     }
     /**
      * 특정 카테고리의 모든 플러그인을 가져옵니다 (내부용)
      */
     static getAll(category) {
         const instance = PluginManager.getInstance();
-        return instance.plugins[category];
+        return instance.getCategory(category);
     }
     /**
      * 플러그인이 등록되어 있는지 확인합니다
      */
     static has(category, name) {
         const instance = PluginManager.getInstance();
-        return instance.plugins[category].has(name);
+        return instance.plugins.get(category)?.has(name) ?? false;
     }
     /**
      * 플러그인을 제거합니다
      */
     static unregister(category, name) {
         const instance = PluginManager.getInstance();
-        return instance.plugins[category].delete(name);
+        return instance.plugins.get(category)?.delete(name) ?? false;
     }
 }

package/dist/core/createProxy.d.ts

@@ -0,0 +1,2 @@
+import type { RegistryCategory } from "../types";
+export declare function createProxy<TProxy extends object, TBase extends object = TProxy>(base: TBase, renderForTag: (tag: any) => React.ForwardRefExoticComponent<any>, category: RegistryCategory): TProxy;

package/dist/core/createProxy.js

@@ -0,0 +1,30 @@
+import { htmlTags } from "../constants/htmlTags";
+import { PluginManager } from "./PluginManager";
+export function createProxy(base, renderForTag, category) {
+    const tagEntries = Object.keys(htmlTags).reduce((acc, tag) => {
+        acc[tag] = renderForTag(tag);
+        return acc;
+    }, {});
+    const target = Object.assign(base, tagEntries);
+    return new Proxy(target, {
+        get(currentTarget, prop) {
+            if (prop in currentTarget) {
+                return currentTarget[prop];
+            }
+            const propName = String(prop);
+            if (PluginManager.has(category, propName)) {
+                const component = PluginManager.get(category, propName);
+                const specialized = renderForTag(component);
+                currentTarget[prop] = specialized;
+                return specialized;
+            }
+            if (PluginManager.has("base", propName)) {
+                const component = PluginManager.get("base", propName);
+                const specialized = renderForTag(component);
+                currentTarget[prop] = specialized;
+                return specialized;
+            }
+            return undefined;
+        },
+    });
+}

package/dist/index.d.ts

@@ -1,10 +1,14 @@
 export * from './components/For';
+export * from './components/Mount';
 export * from './components/Observer';
 export * from './components/OptionalWrapper';
 export * from './components/Repeat';
 export * from './components/Show';
 export * from './components/Slacker';
-export * from './components/Slot';
+export * from './components/Slot/Slot';
+export * from './components/Switch/Switch';
 export * from './hooks/useIntersectionObserver';
 export { PluginManager } from './core/PluginManager';
-export { UtilinentRegister } from './types/register';
+export { UtilinentRegister } from './types';
+export { createProxy } from './core/createProxy';
+export { BaseTypeHelperFn, ProxyType } from './types';

package/dist/index.js

@@ -1,9 +1,16 @@
+// export components
 export * from './components/For';
+export * from './components/Mount';
 export * from './components/Observer';
 export * from './components/OptionalWrapper';
 export * from './components/Repeat';
 export * from './components/Show';
 export * from './components/Slacker';
-export * from './components/Slot';
+export * from './components/Slot/Slot';
+export * from './components/Switch/Switch';
+// export hooks
 export * from './hooks/useIntersectionObserver';
+// export Register and PluginManager
 export { PluginManager } from './core/PluginManager';
+// export createProxy
+export { createProxy } from './core/createProxy';

package/dist/types/RegistryCategory.d.ts

@@ -0,0 +1 @@
+export type RegistryCategory = "show" | "for" | "repeat" | "mount" | "switch" | "base" | (string & {});

package/dist/types/RegistryCategory.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -1,51 +1,4 @@
-import type { ReactElement } from "react";
-export type { UtilinentRegister } from "./register";
-export interface Fallback {
-    fallback?: React.ReactNode;
-}
-export type NonNullableElements<T extends readonly any[]> = {
-    -readonly [P in keyof T]: NonNullable<T[P]>;
-};
-export interface OptionalWrapperProps {
-    when: boolean;
-    children: React.ReactNode;
-    wrapper: (children: React.ReactNode) => React.ReactNode;
-    fallback?: (children: React.ReactNode) => React.ReactNode;
-}
-export interface ObserverProps extends Fallback {
-    children?: React.ReactNode | ((isIntersecting: boolean) => React.ReactNode);
-    threshold?: number | number[];
-    rootMargin?: string;
-    triggerOnce?: boolean;
-    onIntersect?: (isIntersecting: boolean, entry: IntersectionObserverEntry) => void;
-}
-export interface SwitchProps<T, K extends LiteralKeys<T>> extends Fallback {
-    children: Array<ReactElement>;
-    when: K;
-}
-export interface MountProps extends Fallback {
-    children: React.ReactNode | (() => React.ReactNode | Promise<React.ReactNode>);
-}
-export type ExtractValues<T, K extends keyof T> = T extends any ? T[K] : never;
-type IsUnion<T, U = T> = T extends any ? [U] extends [T] ? false : true : false;
-export type ExtractByKeyValue<T, K extends keyof T, V> = T extends any ? IsUnion<T> extends true ? T[K] extends V ? T : never : V extends T[K] ? T : never : never;
-export type GetLiteralKeys<T> = {
-    [K in keyof T]: T[K] extends string ? string extends T[K] ? never : K : T[K] extends number ? number extends T[K] ? never : K : T[K] extends boolean ? boolean extends T[K] ? never : K : T[K] extends bigint ? bigint extends T[K] ? never : K : T[K] extends symbol ? symbol extends T[K] ? never : K : never;
-}[keyof T];
-export type LiteralKeys<T> = [GetLiteralKeys<T>] extends [never] ? keyof T : GetLiteralKeys<T>;
-export type SlackerFallbackProps = {
-    isLoading: boolean;
-    error: Error | null;
-    retry: () => void;
-};
-export type SlackerProps<T = any> = {
-    children: (loaded: T) => React.ReactNode;
-    errorFallback?: React.ReactNode | ((props: SlackerFallbackProps) => React.ReactNode);
-    loadingFallback?: React.ReactNode;
-    threshold?: number | number[];
-    rootMargin?: string;
-    loader: () => Promise<T> | T;
-    onError?: (error: Error) => void;
-    maxRetries?: number;
-    retryDelay?: number;
-};
+export * from "./register";
+export * from "./RegistryCategory";
+export * from "./tagHelper";
+export * from "./utils";

package/dist/types/index.js

@@ -1 +1,4 @@
-export {};
+export * from "./register";
+export * from "./RegistryCategory";
+export * from "./tagHelper";
+export * from "./utils";

package/dist/types/register.d.ts

@@ -1,14 +1,6 @@
+import { RegistryCategory } from "./RegistryCategory";
 export interface UtilinentRegister {
 }
-export type UtilinentRegisterShow = UtilinentRegister extends {
-    show: infer Show;
-} ? Show : never;
-export type UtilinentRegisterBase = UtilinentRegister extends {
-    base: infer Base;
-} ? Base : never;
-export type UtilinentRegisterFor = UtilinentRegister extends {
-    for: infer For;
-} ? For : never;
-export type UtilinentRegisterRepeat = UtilinentRegister extends {
-    repeat: infer Repeat;
-} ? Repeat : never;
+export type RegisterProps<T extends RegistryCategory> = UtilinentRegister extends {
+    [X in T]: infer Props;
+} ? Props : never;

package/dist/types/tagHelper.d.ts

@@ -0,0 +1,20 @@
+import { HtmlTag } from "../constants/htmlTags";
+import { RegisterProps } from "./register";
+import { RegistryCategory } from "./RegistryCategory";
+export interface BaseTypeHelperFn {
+    props: unknown;
+    type: unknown;
+}
+type Apply<F extends BaseTypeHelperFn, Props> = (F & {
+    props: Props;
+})["type"];
+type MaybeOmitChildren<Props, OmitChildren extends boolean> = OmitChildren extends true ? Omit<Props, "children"> : Props;
+export type TagHelper<K, F extends BaseTypeHelperFn, OmitChildren extends boolean = true> = K extends keyof HtmlTag ? Apply<F, MaybeOmitChildren<React.ComponentPropsWithRef<K>, OmitChildren>> : K extends React.ComponentType<infer P> ? Apply<F, MaybeOmitChildren<P, OmitChildren>> : K;
+export type ProxyType<F extends BaseTypeHelperFn, RegisterKey extends RegistryCategory, OmitChildren extends boolean = true> = Apply<F, object> & {
+    [K in keyof HtmlTag]: TagHelper<K, F, OmitChildren>;
+} & {
+    [K in keyof RegisterProps<RegisterKey>]: TagHelper<RegisterProps<RegisterKey>[K], F, OmitChildren>;
+} & {
+    [K in keyof RegisterProps<"base">]: TagHelper<RegisterProps<"base">[K], F, OmitChildren>;
+};
+export {};

package/dist/types/tagHelper.js

@@ -0,0 +1 @@
+export {};

package/dist/types/utils.d.ts

@@ -0,0 +1,14 @@
+export type { UtilinentRegister } from "./register";
+export interface Fallback {
+    fallback?: React.ReactNode;
+}
+export type NonNullableElements<T extends readonly any[]> = {
+    -readonly [P in keyof T]: NonNullable<T[P]>;
+};
+export type ExtractValues<T, K extends keyof T> = T extends any ? T[K] : never;
+type IsUnion<T, U = T> = T extends any ? [U] extends [T] ? false : true : false;
+export type ExtractByKeyValue<T, K extends keyof T, V> = T extends any ? IsUnion<T> extends true ? T[K] extends V ? T : never : V extends T[K] ? T : never : never;
+export type GetLiteralKeys<T> = {
+    [K in keyof T]: T[K] extends string ? string extends T[K] ? never : K : T[K] extends number ? number extends T[K] ? never : K : T[K] extends boolean ? boolean extends T[K] ? never : K : T[K] extends bigint ? bigint extends T[K] ? never : K : T[K] extends symbol ? symbol extends T[K] ? never : K : never;
+}[keyof T];
+export type LiteralKeys<T> = [GetLiteralKeys<T>] extends [never] ? keyof T : GetLiteralKeys<T>;

package/dist/types/utils.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/resolveWhen.d.ts

@@ -0,0 +1 @@
+export declare const resolveWhen: (value: unknown) => boolean;

package/dist/utils/resolveWhen.js

@@ -0,0 +1 @@
+export const resolveWhen = (value) => Array.isArray(value) ? value.every(Boolean) : !!value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilokesto/utilinent",
-  "version": "1.0.14",
+  "version": "1.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ilokesto/utilinent.git"
@@ -13,10 +13,6 @@
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
-    },
-    "./experimental": {
-      "import": "./dist/experimental.js",
-      "types": "./dist/experimental.d.ts"
     }
   },
   "files": [

package/dist/components/For.d.ts

@@ -1,2 +0,0 @@
-import type { ForType } from "../types/for";
-export declare const For: ForType;

package/dist/components/For.js

@@ -1,48 +0,0 @@
-import { Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { createElement, forwardRef } from "react";
-import { htmlTags } from "../constants/htmlTags";
-import { PluginManager } from "../core/PluginManager";
-function BaseFor({ each, children, fallback = null, before, after, }) {
-    const content = each && each.length > 0 ? each.map(children) : fallback;
-    return (_jsxs(_Fragment, { children: [before, content, after] }));
-}
-const renderForTag = (tag) => 
-// forward ref so consumers can attach a ref to the underlying DOM element
-forwardRef(({ each, children, fallback = null, before, after, ...props }, ref) => {
-    const content = each && each.length > 0 ? each.map(children) : fallback;
-    return createElement(tag, { ...props, ref }, before, content, after);
-});
-// HTML 태그들을 등록
-const tagEntries = htmlTags.reduce((acc, tag) => {
-    acc[tag] = renderForTag(tag);
-    return acc;
-}, {});
-// Proxy를 사용하여 동적으로 플러그인 조회
-export const For = new Proxy(Object.assign(BaseFor, tagEntries), {
-    get(target, prop) {
-        // 기존 속성이 있으면 반환
-        if (prop in target) {
-            return target[prop];
-        }
-        // 플러그인에서 동적으로 조회
-        const propName = String(prop);
-        // 'for' 카테고리에서 먼저 찾기
-        if (PluginManager.has('for', propName)) {
-            const component = PluginManager.get('for', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 'base' 카테고리에서 찾기
-        if (PluginManager.has('base', propName)) {
-            const component = PluginManager.get('base', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 찾지 못하면 undefined 반환
-        return undefined;
-    }
-});

package/dist/components/OptionalWrapper.d.ts

@@ -1,2 +0,0 @@
-import { OptionalWrapperProps } from "../types";
-export declare function OptionalWrapper({ when, children, wrapper, fallback }: OptionalWrapperProps): React.ReactNode;

package/dist/components/Repeat.d.ts

@@ -1,2 +0,0 @@
-import type { RepeatType } from "../types/repeat";
-export declare const Repeat: RepeatType;

package/dist/components/Repeat.js

@@ -1,52 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createElement, forwardRef } from "react";
-import { htmlTags } from "../constants/htmlTags";
-import { PluginManager } from "../core/PluginManager";
-import { For } from "./For";
-function BaseRepeat({ times, children, fallback = null }) {
-    if (!times || times <= 0 || !Number.isInteger(times)) {
-        return fallback ?? null;
-    }
-    return _jsx(For, { each: Array.from({ length: times }, (_, i) => i), children: children });
-}
-const renderForTag = (tag) => 
-// forward ref so consumers can attach a ref to the underlying DOM element
-forwardRef(({ times, children, fallback = null, ...props }, ref) => {
-    const content = times && times > 0 && Number.isInteger(times)
-        ? Array.from({ length: times }, (_, i) => children(i))
-        : fallback ?? null;
-    return createElement(tag, { ...props, ref }, content);
-});
-// HTML 태그들을 등록
-const tagEntries = htmlTags.reduce((acc, tag) => {
-    acc[tag] = renderForTag(tag);
-    return acc;
-}, {});
-export const Repeat = new Proxy(Object.assign(BaseRepeat, tagEntries), {
-    get(target, prop) {
-        // 기존 속성이 있으면 반환
-        if (prop in target) {
-            return target[prop];
-        }
-        // 플러그인에서 동적으로 조회
-        const propName = String(prop);
-        // 'repeat' 카테고리에서 먼저 찾기
-        if (PluginManager.has('repeat', propName)) {
-            const component = PluginManager.get('repeat', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 'base' 카테고리에서 찾기
-        if (PluginManager.has('base', propName)) {
-            const component = PluginManager.get('base', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 찾지 못하면 undefined 반환
-        return undefined;
-    }
-});

package/dist/components/Show.d.ts

@@ -1,2 +0,0 @@
-import type { ShowType } from "../types/show";
-export declare const Show: ShowType;

package/dist/components/Show.js

@@ -1,55 +0,0 @@
-import { createElement, forwardRef } from "react";
-import { htmlTags } from "../constants/htmlTags";
-import { PluginManager } from "../core/PluginManager";
-const BaseShow = ({ when, children, fallback = null }) => {
-    const shouldRender = Array.isArray(when) ? when.every(Boolean) : !!when;
-    return shouldRender
-        ? typeof children === "function"
-            ? children(when)
-            : children
-        : fallback;
-};
-const renderForTag = (tag) => 
-// forward ref so consumers like Observer can pass a ref to the real DOM element
-forwardRef(function Render({ when, children, fallback = null, ...props }, ref) {
-    const shouldRender = Array.isArray(when) ? when.every(Boolean) : !!when;
-    const content = shouldRender
-        ? typeof children === "function"
-            ? children(when)
-            : children
-        : fallback;
-    return createElement(tag, { ...props, ref }, content);
-});
-// HTML 태그들을 등록
-const tagEntries = htmlTags.reduce((acc, tag) => {
-    acc[tag] = renderForTag(tag);
-    return acc;
-}, {});
-export const Show = new Proxy(Object.assign(BaseShow, tagEntries), {
-    get(target, prop) {
-        // 기존 속성이 있으면 반환
-        if (prop in target) {
-            return target[prop];
-        }
-        // 플러그인에서 동적으로 조회
-        const propName = String(prop);
-        // 'show' 카테고리에서 먼저 찾기
-        if (PluginManager.has('show', propName)) {
-            const component = PluginManager.get('show', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 'base' 카테고리에서 찾기
-        if (PluginManager.has('base', propName)) {
-            const component = PluginManager.get('base', propName);
-            const specialized = renderForTag(component);
-            // 캐싱하여 다음 조회 시 동일한 참조 반환
-            target[prop] = specialized;
-            return specialized;
-        }
-        // 찾지 못하면 undefined 반환
-        return undefined;
-    }
-});