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

@@ -1,7 +1,7 @@
 import { htmlTags } from "../constants/htmlTags";
 import { PluginManager } from "./PluginManager";
-export function createTagProxy(base, renderForTag, category) {
-    const tagEntries = htmlTags.reduce((acc, tag) => {
+export function createProxy(base, renderForTag, category) {
+    const tagEntries = Object.keys(htmlTags).reduce((acc, tag) => {
         acc[tag] = renderForTag(tag);
         return acc;
     }, {});

package/dist/index.d.ts

@@ -4,9 +4,11 @@ export * from './components/Observer';
 export * from './components/OptionalWrapper';
 export * from './components/Repeat';
 export * from './components/Show';
-export * from './components/Switch';
 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,11 +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/Switch';
 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,47 +1,4 @@
-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<T = unknown> {
-    when: T;
-    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 MountProps extends Fallback {
-    children: React.ReactNode | (() => React.ReactNode | Promise<React.ReactNode>);
-    onError?: (error: unknown) => void;
-}
-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,20 +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 UtilinentRegisterMount = UtilinentRegister extends {
-    mount: infer Mount;
-} ? Mount : never;
-export type UtilinentRegisterSwitch = UtilinentRegister extends {
-    switch: infer Switch;
-} ? Switch : 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilokesto/utilinent",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ilokesto/utilinent.git"

package/dist/components/For.d.ts

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

package/dist/components/Mount.d.ts

@@ -1,2 +0,0 @@
-import type { MountType } from "../types/mount";
-export declare const Mount: MountType;

package/dist/components/Repeat.d.ts

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

package/dist/components/Show.d.ts

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

package/dist/components/Slot.js

@@ -1,75 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { Children, cloneElement, forwardRef, isValidElement } from 'react';
-function mergeProps(slotProps, childProps) {
-    const merged = { ...childProps };
-    for (const propName in slotProps) {
-        const slotProp = slotProps[propName];
-        const childProp = merged[propName];
-        if (/^on[A-Z]/.test(propName) && typeof slotProp === 'function' && typeof childProp === 'function') {
-            merged[propName] = (...args) => {
-                childProp(...args);
-                slotProp(...args);
-            };
-        }
-        else if (propName === 'style' && typeof slotProp === 'object' && typeof childProp === 'object') {
-            merged[propName] = { ...childProp, ...slotProp };
-        }
-        else if (propName === 'className' && typeof slotProp === 'string' && typeof childProp === 'string') {
-            merged[propName] = [childProp, slotProp].filter(Boolean).join(' ');
-        }
-        else {
-            merged[propName] = slotProp;
-        }
-    }
-    return merged;
-}
-function composeRefs(...refs) {
-    return (node) => {
-        for (const ref of refs) {
-            if (typeof ref === 'function') {
-                ref(node);
-            }
-            else if (ref != null) {
-                ref.current = node;
-            }
-        }
-    };
-}
-export const Slot = forwardRef((props, ref) => {
-    const { children, ...slotProps } = props;
-    const childrenArray = Children.toArray(children);
-    const slottable = childrenArray.find(isSlottable);
-    if (slottable) {
-        // Slottable의 children을 가져와서 병합
-        const slottableChild = slottable.props.children;
-        if (!isValidElement(slottableChild)) {
-            return null;
-        }
-        const newElement = cloneElement(slottableChild, {
-            ...mergeProps(slotProps, slottableChild.props),
-            ref: ref ? composeRefs(ref, slottableChild.ref) : slottableChild.ref,
-            key: slottable.key
-        });
-        const newChildren = childrenArray.map((child) => {
-            if (child === slottable) {
-                return newElement;
-            }
-            return child;
-        });
-        return _jsx(_Fragment, { children: newChildren });
-    }
-    const [child] = childrenArray;
-    if (!isValidElement(child)) {
-        return null;
-    }
-    return cloneElement(child, {
-        ...mergeProps(slotProps, child.props),
-        ref: ref ? composeRefs(ref, child.ref) : child.ref
-    });
-});
-function isSlottable(child) {
-    return isValidElement(child) && child.type === Slottable;
-}
-export const Slottable = ({ children }) => {
-    return _jsx(_Fragment, { children: children });
-};

package/dist/components/Switch.d.ts

@@ -1,4 +0,0 @@
-import type { ReactNode } from "react";
-import type { MatchProps, SwitchType } from "../types/switch";
-export declare const Switch: SwitchType;
-export declare function Match<T>({ when, children }: MatchProps<T>): ReactNode;

package/dist/components/Switch.js

@@ -1,39 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { Children, Fragment, createElement, forwardRef, isValidElement, } from "react";
-import { createTagProxy } from "../core/createTagProxy";
-import { resolveWhen } from "../utils/resolveWhen";
-const flattenChildren = (nodes) => Children.toArray(nodes).flatMap((child) => {
-    if (isValidElement(child) && child.type === Fragment) {
-        return flattenChildren(child.props.children);
-    }
-    return [child];
-});
-const isMatchElement = (child) => isValidElement(child) && child.type === Match;
-function BaseSwitch({ children, fallback = null }) {
-    const childArray = flattenChildren(children);
-    for (const child of childArray) {
-        if (!isMatchElement(child)) {
-            continue;
-        }
-        const { when } = child.props;
-        if (!resolveWhen(when)) {
-            continue;
-        }
-        return child;
-    }
-    return fallback;
-}
-const renderForTag = (tag) => 
-// forward ref so consumers can attach a ref to the underlying DOM element
-forwardRef(function Render({ children, fallback = null, ...props }, ref) {
-    return createElement(tag, { ...props, ref }, _jsx(BaseSwitch, { fallback: fallback, children: children }));
-});
-export const Switch = createTagProxy(BaseSwitch, renderForTag, "switch");
-export function Match({ when, children }) {
-    if (!resolveWhen(when)) {
-        return null;
-    }
-    return typeof children === "function"
-        ? children(when)
-        : children;
-}

package/dist/core/createTagProxy.d.ts

@@ -1,3 +0,0 @@
-import type { TagProxyCategory } from "./tagProxyTypes";
-export type { TagProxyCategory } from "./tagProxyTypes";
-export declare function createTagProxy<TProxy extends object, TBase extends object = TProxy>(base: TBase, renderForTag: (tag: any) => any, category: TagProxyCategory): TProxy;

package/dist/core/tagProxyTypes.d.ts

@@ -1 +0,0 @@
-export type TagProxyCategory = "show" | "for" | "repeat" | "mount" | "switch" | "base";

package/dist/types/for.d.ts

@@ -1,23 +0,0 @@
-import { Fallback } from ".";
-import { HtmlTag } from "../constants/htmlTags";
-import { UtilinentRegisterBase, UtilinentRegisterFor } from "./register";
-export interface ForProps<T extends Array<unknown>> extends Fallback {
-    each: T | null | undefined;
-    children: (item: T[number], index: number) => React.ReactNode;
-}
-type ForTagHelper<K extends HtmlTag> = {
-    <const T extends Array<unknown>>(props: ForProps<T> & Omit<React.ComponentPropsWithRef<K>, 'children'>): React.ReactNode;
-};
-type ForRegisterHelper<C> = C extends React.ComponentType<infer P> ? {
-    <const T extends Array<unknown>>(props: Omit<P, "children"> & ForProps<T>): React.ReactNode;
-} : C;
-export type ForType = {
-    <const T extends Array<unknown>>(props: ForProps<T>): React.ReactNode;
-} & {
-    [K in HtmlTag]: ForTagHelper<K>;
-} & {
-    [K in keyof UtilinentRegisterFor]: ForRegisterHelper<UtilinentRegisterFor[K]>;
-} & {
-    [K in keyof UtilinentRegisterBase]: ForRegisterHelper<UtilinentRegisterBase[K]>;
-};
-export {};

package/dist/types/mount.d.ts

@@ -1,20 +0,0 @@
-import { ComponentPropsWithRef } from "react";
-import { HtmlTag } from "../constants/htmlTags";
-import { MountProps } from ".";
-import { UtilinentRegisterBase, UtilinentRegisterMount } from "./register";
-type MountTagHelper<K extends HtmlTag> = {
-    (props: MountProps & Omit<ComponentPropsWithRef<K>, "children">): React.ReactNode;
-};
-type MountRegisterHelper<C> = C extends React.ComponentType<infer P> ? {
-    (props: Omit<P, "children"> & MountProps): React.ReactNode;
-} : C;
-export type MountType = {
-    (props: MountProps): React.ReactNode;
-} & {
-    [K in HtmlTag]: MountTagHelper<K>;
-} & {
-    [K in keyof UtilinentRegisterMount]: MountRegisterHelper<UtilinentRegisterMount[K]>;
-} & {
-    [K in keyof UtilinentRegisterBase]: MountRegisterHelper<UtilinentRegisterBase[K]>;
-};
-export {};

package/dist/types/repeat.d.ts

@@ -1,24 +0,0 @@
-import { ComponentPropsWithRef } from "react";
-import { Fallback } from ".";
-import { HtmlTag } from "../constants/htmlTags";
-import { UtilinentRegisterBase, UtilinentRegisterRepeat } from "./register";
-export interface RepeatProps extends Fallback {
-    times: number;
-    children: (index: number) => React.ReactNode;
-}
-type RepeatTagHelper<K extends HtmlTag> = {
-    (props: RepeatProps & Omit<ComponentPropsWithRef<K>, "children">): React.ReactNode;
-};
-type RepeatRegisterHelper<C> = C extends React.ComponentType<infer P> ? {
-    (props: Omit<P, "children"> & RepeatProps): React.ReactNode;
-} : C;
-export type RepeatType = {
-    (props: RepeatProps): React.ReactNode;
-} & {
-    [K in HtmlTag]: RepeatTagHelper<K>;
-} & {
-    [K in keyof UtilinentRegisterRepeat]: RepeatRegisterHelper<UtilinentRegisterRepeat[K]>;
-} & {
-    [K in keyof UtilinentRegisterBase]: RepeatRegisterHelper<UtilinentRegisterBase[K]>;
-};
-export {};