@pathscale/ui 1.3.1 → 1.4.0

package/dist/components/card/Card.generated.d.ts

@@ -0,0 +1,30 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./Card.css";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type CardVariant = "default" | "flat" | "bordered" | "shadow";
+type CardContextlessProps<T extends HTMLElement> = Omit<JSX.HTMLAttributes<T>, "children"> & IComponentBaseProps & {
+    children?: JSX.Element;
+};
+export type CardRootProps = CardContextlessProps<HTMLDivElement> & {
+    variant?: CardVariant;
+    isHoverable?: boolean;
+    isPressable?: boolean;
+};
+export type CardHeaderProps = CardContextlessProps<HTMLDivElement>;
+export type CardBodyProps = CardContextlessProps<HTMLDivElement>;
+export type CardFooterProps = CardContextlessProps<HTMLDivElement>;
+declare const CardRoot: __LayoutComponent<CardRootProps>;
+declare const CardHeader: __LayoutComponent<CardHeaderProps>;
+declare const CardBody: __LayoutComponent<CardBodyProps>;
+declare const CardFooter: __LayoutComponent<CardFooterProps>;
+declare const Card: __LayoutComponent<CardRootProps> & {
+    Root: __LayoutComponent<CardRootProps>;
+    Header: __LayoutComponent<CardHeaderProps>;
+    Body: __LayoutComponent<CardBodyProps>;
+    Content: __LayoutComponent<CardBodyProps>;
+    Footer: __LayoutComponent<CardFooterProps>;
+};
+export default Card;
+export { Card, CardRoot, CardHeader, CardBody, CardFooter };
+export type { CardRootProps as CardProps };

package/dist/components/card/Card.generated.js

@@ -0,0 +1,172 @@
+import { insert, mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./Card.css";
+import { splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./Card.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>");
+const invokeEventHandler = (handler, event)=>{
+    if ("function" == typeof handler) return void handler(event);
+    if (Array.isArray(handler) && "function" == typeof handler[0]) handler[0](handler[1], event);
+};
+const __solidLayoutCardRoot = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style",
+        "variant",
+        "isHoverable",
+        "isPressable",
+        "onKeyDown",
+        "role",
+        "tabIndex"
+    ]);
+    const variant = ()=>local.variant ?? "default";
+    const handleKeyDown = (event)=>{
+        invokeEventHandler(local.onKeyDown, event);
+        if (event.defaultPrevented || !local.isPressable) return;
+        if ("Enter" !== event.key && " " !== event.key) return;
+        if (event.target !== event.currentTarget) return;
+        event.preventDefault();
+        event.currentTarget.click();
+    };
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Root.base, CLASSES.Root.variant[variant()], local.isHoverable && CLASSES.Root.flag.isHoverable, local.isPressable && CLASSES.Root.flag.isPressable, local.class, local.className)
+            }), {
+            "data-slot": "card",
+            get ["data-variant"] () {
+                return variant();
+            },
+            get ["data-hoverable"] () {
+                return local.isHoverable ? "true" : "false";
+            },
+            get ["data-pressable"] () {
+                return local.isPressable ? "true" : "false";
+            },
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            },
+            get role () {
+                return local.role ?? (local.isPressable ? "button" : void 0);
+            },
+            get tabIndex () {
+                return local.tabIndex ?? (local.isPressable ? 0 : void 0);
+            },
+            onKeyDown: handleKeyDown
+        }), false, true);
+        insert(_el$, ()=>local.children);
+        return _el$;
+    })();
+};
+const CardRoot = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutCardRoot,
+    embedded: true
+});
+const __solidLayoutCardHeader = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    return (()=>{
+        var _el$2 = _tmpl$();
+        spread(_el$2, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Header.base, local.class, local.className)
+            }), {
+            "data-slot": "card-header",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$2, ()=>local.children);
+        return _el$2;
+    })();
+};
+const CardHeader = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutCardHeader,
+    embedded: true
+});
+const __solidLayoutCardBody = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    return (()=>{
+        var _el$3 = _tmpl$();
+        spread(_el$3, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Body.base, local.class, local.className)
+            }), {
+            "data-slot": "card-body",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$3, ()=>local.children);
+        return _el$3;
+    })();
+};
+const CardBody = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutCardBody,
+    embedded: true
+});
+const __solidLayoutCardFooter = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "children",
+        "class",
+        "className",
+        "dataTheme",
+        "style"
+    ]);
+    return (()=>{
+        var _el$4 = _tmpl$();
+        spread(_el$4, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.Footer.base, local.class, local.className)
+            }), {
+            "data-slot": "card-footer",
+            get ["data-theme"] () {
+                return local.dataTheme;
+            },
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$4, ()=>local.children);
+        return _el$4;
+    })();
+};
+const CardFooter = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutCardFooter,
+    embedded: true
+});
+const Card = Object.assign(CardRoot, {
+    Root: CardRoot,
+    Header: CardHeader,
+    Body: CardBody,
+    Content: CardBody,
+    Footer: CardFooter
+});
+const Card_generated = Card;
+export default Card_generated;
+export { Card, CardBody, CardFooter, CardHeader, CardRoot };

package/dist/components/card/Card.recipe.d.ts

@@ -0,0 +1,34 @@
+export declare const CLASSES: {
+    readonly Root: {
+        readonly base: "card";
+        readonly variant: {
+            readonly default: "card--default";
+            readonly flat: "card--flat";
+            readonly bordered: "card--bordered";
+            readonly shadow: "card--shadow";
+        };
+        readonly flag: {
+            readonly isHoverable: "card--hoverable";
+            readonly isPressable: "card--pressable";
+        };
+    };
+    readonly Header: {
+        readonly base: "card__header";
+    };
+    readonly Body: {
+        readonly base: "card__body";
+    };
+    readonly Footer: {
+        readonly base: "card__footer";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "card";
+    readonly slots: {
+        readonly card: {};
+        readonly "card-body": {};
+        readonly "card-footer": {};
+        readonly "card-header": {};
+        readonly root: {};
+    };
+}>;

package/dist/components/card/Card.recipe.js

@@ -0,0 +1,68 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    Root: {
+        base: "card",
+        variant: {
+            default: "card--default",
+            flat: "card--flat",
+            bordered: "card--bordered",
+            shadow: "card--shadow"
+        },
+        flag: {
+            isHoverable: "card--hoverable",
+            isPressable: "card--pressable"
+        }
+    },
+    Header: {
+        base: "card__header"
+    },
+    Body: {
+        base: "card__body"
+    },
+    Footer: {
+        base: "card__footer"
+    }
+};
+const componentRecipe = recipe({
+    component: "card",
+    slots: {
+        card: {},
+        "card-body": {},
+        "card-footer": {},
+        "card-header": {},
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            card: {
+                base: "",
+                axes: {}
+            },
+            "card-body": {
+                base: "",
+                axes: {}
+            },
+            "card-footer": {
+                base: "",
+                axes: {}
+            },
+            "card-header": {
+                base: "",
+                axes: {}
+            },
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            card: 0,
+            "card-body": 1,
+            "card-footer": 2,
+            "card-header": 3,
+            root: 4
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/card/index.d.ts

@@ -1 +1 @@
-export { default, Card, CardRoot, CardHeader, CardBody, CardFooter, type CardProps, type CardVariant, type CardRootProps, type CardHeaderProps, type CardBodyProps, type CardFooterProps, } from "./Card";
+export { default, Card, CardRoot, CardHeader, CardBody, CardFooter, type CardProps, type CardVariant, type CardRootProps, type CardHeaderProps, type CardBodyProps, type CardFooterProps, } from "./Card.generated";

package/dist/components/card/index.js

@@ -1,3 +1 @@
-import { Card as external_Card_js_Card, CardBody, CardFooter, CardHeader, CardRoot } from "./Card.js";
-export default external_Card_js_Card;
-export { CardBody, CardFooter, CardHeader, CardRoot, external_Card_js_Card as Card };
+export { Card, CardBody, CardFooter, CardHeader, CardRoot, default } from "./Card.generated.js";

package/dist/components/chatbubble/ChatBubble.generated.d.ts

@@ -0,0 +1,15 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import "./ChatBubble.css";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ChatBubbleProps = IComponentBaseProps & JSX.HTMLAttributes<HTMLDivElement> & {
+    end?: boolean;
+};
+declare const _default: __LayoutComponent<ChatBubbleProps> & {
+    Header: __LayoutComponent<import("./ChatBubbleHeader.generated").ChatBubbleHeaderProps>;
+    Time: __LayoutComponent<import("./ChatBubbleTime.generated").ChatBubbleTimeProps>;
+    Avatar: __LayoutComponent<import("./ChatBubbleAvatar.generated").ChatBubbleAvatarProps>;
+    Message: __LayoutComponent<import("./ChatBubbleMessage.generated").ChatBubbleMessageProps>;
+    Footer: __LayoutComponent<import("./ChatBubbleFooter.generated").ChatBubbleFooterProps>;
+};
+export default _default;

package/dist/components/chatbubble/ChatBubble.generated.js

@@ -0,0 +1,51 @@
+import { insert, mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import "./ChatBubble.css";
+import { createMemo, splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import ChatBubbleHeader_generated from "./ChatBubbleHeader.generated.js";
+import ChatBubbleTime_generated from "./ChatBubbleTime.generated.js";
+import ChatBubbleAvatar_generated from "./ChatBubbleAvatar.generated.js";
+import ChatBubbleMessage_generated from "./ChatBubbleMessage.generated.js";
+import ChatBubbleFooter_generated from "./ChatBubbleFooter.generated.js";
+import { CLASSES, componentRecipe } from "./ChatBubble.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>");
+const __solidLayoutChatBubble = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "end",
+        "dataTheme",
+        "class",
+        "className",
+        "style"
+    ]);
+    const classes = createMemo(()=>twMerge(CLASSES.base, local.end ? CLASSES.align.end : CLASSES.align.start, local.class, local.className));
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, {
+            get ["data-theme"] () {
+                return local.dataTheme;
+            }
+        }, ()=>({
+                class: classes()
+            }), {
+            get style () {
+                return local.style;
+            }
+        }), false, true);
+        insert(_el$, ()=>others.children);
+        return _el$;
+    })();
+};
+const ChatBubble = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutChatBubble,
+    embedded: true
+});
+const ChatBubble_generated = Object.assign(ChatBubble, {
+    Header: ChatBubbleHeader_generated,
+    Time: ChatBubbleTime_generated,
+    Avatar: ChatBubbleAvatar_generated,
+    Message: ChatBubbleMessage_generated,
+    Footer: ChatBubbleFooter_generated
+});
+export default ChatBubble_generated;

package/dist/components/chatbubble/ChatBubble.recipe.d.ts

@@ -0,0 +1,30 @@
+export declare const CLASSES: {
+    readonly base: "chatbubble";
+    readonly align: {
+        readonly start: "chatbubble--start";
+        readonly end: "chatbubble--end";
+    };
+    readonly slot: {
+        readonly header: "chatbubble__header";
+        readonly footer: "chatbubble__footer";
+        readonly avatar: "chatbubble__avatar";
+        readonly message: "chatbubble__message";
+        readonly time: "chatbubble__time";
+    };
+    readonly color: {
+        readonly neutral: "chatbubble__message--neutral";
+        readonly primary: "chatbubble__message--primary";
+        readonly secondary: "chatbubble__message--secondary";
+        readonly accent: "chatbubble__message--accent";
+        readonly info: "chatbubble__message--info";
+        readonly success: "chatbubble__message--success";
+        readonly warning: "chatbubble__message--warning";
+        readonly error: "chatbubble__message--error";
+    };
+};
+export declare const componentRecipe: import("solid-layouts").Recipe<{
+    readonly component: "chatbubble";
+    readonly slots: {
+        readonly root: {};
+    };
+}>;

package/dist/components/chatbubble/ChatBubble.recipe.js

@@ -0,0 +1,44 @@
+import { recipe } from "../../lib/layouts/index.js";
+const CLASSES = {
+    base: "chatbubble",
+    align: {
+        start: "chatbubble--start",
+        end: "chatbubble--end"
+    },
+    slot: {
+        header: "chatbubble__header",
+        footer: "chatbubble__footer",
+        avatar: "chatbubble__avatar",
+        message: "chatbubble__message",
+        time: "chatbubble__time"
+    },
+    color: {
+        neutral: "chatbubble__message--neutral",
+        primary: "chatbubble__message--primary",
+        secondary: "chatbubble__message--secondary",
+        accent: "chatbubble__message--accent",
+        info: "chatbubble__message--info",
+        success: "chatbubble__message--success",
+        warning: "chatbubble__message--warning",
+        error: "chatbubble__message--error"
+    }
+};
+const componentRecipe = recipe({
+    component: "chatbubble",
+    slots: {
+        root: {}
+    },
+    _layouts: {
+        slots: {
+            root: {
+                base: "",
+                axes: {}
+            }
+        },
+        stateKeys: [],
+        slotIds: {
+            root: 0
+        }
+    }
+});
+export { CLASSES, componentRecipe };

package/dist/components/chatbubble/ChatBubbleAvatar.generated.d.ts

@@ -0,0 +1,10 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import type { AvatarRootProps } from "../avatar";
+import type { IComponentBaseProps } from "../types";
+export type ChatBubbleAvatarProps = {
+    src?: string;
+    alt?: string;
+    fallback?: string;
+} & Omit<AvatarRootProps, "children"> & IComponentBaseProps;
+declare const ChatBubbleAvatar: __LayoutComponent<ChatBubbleAvatarProps>;
+export default ChatBubbleAvatar;

package/dist/components/chatbubble/ChatBubbleAvatar.generated.js

@@ -0,0 +1,49 @@
+import { createComponent, memo, mergeProps } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import { twMerge } from "tailwind-merge";
+import avatar from "../avatar/index.js";
+import { CLASSES, componentRecipe } from "./ChatBubble.recipe.js";
+const __solidLayoutChatBubbleAvatar = (_stable, p)=>createComponent(avatar, mergeProps({
+        get size () {
+            return p.size ?? "sm";
+        },
+        get color () {
+            return p.color;
+        },
+        get variant () {
+            return p.variant;
+        }
+    }, ()=>({
+            class: twMerge(CLASSES.slot.avatar, p.class, p.className)
+        }), {
+        get dataTheme () {
+            return p.dataTheme;
+        },
+        get style () {
+            return p.style;
+        },
+        get children () {
+            return [
+                memo(()=>memo(()=>!!p.src)() && createComponent(avatar.Image, {
+                        get src () {
+                            return p.src;
+                        },
+                        get alt () {
+                            return p.alt;
+                        }
+                    })),
+                createComponent(avatar.Fallback, {
+                    get children () {
+                        return p.fallback ?? p.alt?.charAt(0) ?? "?";
+                    }
+                })
+            ];
+        }
+    }));
+const ChatBubbleAvatar = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutChatBubbleAvatar,
+    embedded: true
+});
+const ChatBubbleAvatar_generated = ChatBubbleAvatar;
+export default ChatBubbleAvatar_generated;

package/dist/components/chatbubble/ChatBubbleFooter.generated.d.ts

@@ -0,0 +1,6 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ChatBubbleFooterProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps;
+declare const ChatBubbleFooter: __LayoutComponent<ChatBubbleFooterProps>;
+export default ChatBubbleFooter;

package/dist/components/chatbubble/ChatBubbleFooter.generated.js

@@ -0,0 +1,26 @@
+import { mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import { splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./ChatBubble.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>");
+const __solidLayoutChatBubbleFooter = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "class",
+        "className"
+    ]);
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.slot.footer, local.class, local.className)
+            })), false, false);
+        return _el$;
+    })();
+};
+const ChatBubbleFooter = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutChatBubbleFooter,
+    embedded: true
+});
+const ChatBubbleFooter_generated = ChatBubbleFooter;
+export default ChatBubbleFooter_generated;

package/dist/components/chatbubble/ChatBubbleHeader.generated.d.ts

@@ -0,0 +1,6 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ChatBubbleHeaderProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps;
+declare const ChatBubbleHeader: __LayoutComponent<ChatBubbleHeaderProps>;
+export default ChatBubbleHeader;

package/dist/components/chatbubble/ChatBubbleHeader.generated.js

@@ -0,0 +1,26 @@
+import { mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import { splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./ChatBubble.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>");
+const __solidLayoutChatBubbleHeader = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "class",
+        "className"
+    ]);
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.slot.header, local.class, local.className)
+            })), false, false);
+        return _el$;
+    })();
+};
+const ChatBubbleHeader = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutChatBubbleHeader,
+    embedded: true
+});
+const ChatBubbleHeader_generated = ChatBubbleHeader;
+export default ChatBubbleHeader_generated;

package/dist/components/chatbubble/ChatBubbleMessage.generated.d.ts

@@ -0,0 +1,8 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ChatBubbleMessageProps = JSX.HTMLAttributes<HTMLDivElement> & IComponentBaseProps & {
+    color?: "neutral" | "primary" | "secondary" | "accent" | "info" | "success" | "warning" | "error";
+};
+declare const ChatBubbleMessage: __LayoutComponent<ChatBubbleMessageProps>;
+export default ChatBubbleMessage;

package/dist/components/chatbubble/ChatBubbleMessage.generated.js

@@ -0,0 +1,33 @@
+import { mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import { splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./ChatBubble.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<div>");
+const __solidLayoutChatBubbleMessage = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "color",
+        "class",
+        "className"
+    ]);
+    const colorClass = ()=>{
+        if (!local.color) return;
+        return CLASSES.color[local.color];
+    };
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, {
+            get ["class"] () {
+                return twMerge(CLASSES.slot.message, colorClass(), local.class, local.className);
+            }
+        }), false, false);
+        return _el$;
+    })();
+};
+const ChatBubbleMessage = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutChatBubbleMessage,
+    embedded: true
+});
+const ChatBubbleMessage_generated = ChatBubbleMessage;
+export default ChatBubbleMessage_generated;

package/dist/components/chatbubble/ChatBubbleTime.generated.d.ts

@@ -0,0 +1,6 @@
+import type { Component as __LayoutComponent } from "solid-js";
+import { type JSX } from "solid-js";
+import type { IComponentBaseProps } from "../types";
+export type ChatBubbleTimeProps = JSX.HTMLAttributes<HTMLTimeElement> & IComponentBaseProps;
+declare const ChatBubbleTime: __LayoutComponent<ChatBubbleTimeProps>;
+export default ChatBubbleTime;

package/dist/components/chatbubble/ChatBubbleTime.generated.js

@@ -0,0 +1,26 @@
+import { mergeProps, spread, template } from "solid-js/web";
+import { defineComponent } from "solid-layouts/application-boundary";
+import { splitProps } from "solid-js";
+import { twMerge } from "tailwind-merge";
+import { CLASSES, componentRecipe } from "./ChatBubble.recipe.js";
+var _tmpl$ = /*#__PURE__*/ template("<time>");
+const __solidLayoutChatBubbleTime = (_stable, p)=>{
+    const [local, others] = splitProps(p, [
+        "class",
+        "className"
+    ]);
+    return (()=>{
+        var _el$ = _tmpl$();
+        spread(_el$, mergeProps(others, ()=>({
+                class: twMerge(CLASSES.slot.time, local.class, local.className)
+            })), false, false);
+        return _el$;
+    })();
+};
+const ChatBubbleTime = defineComponent({
+    recipe: componentRecipe,
+    layout: __solidLayoutChatBubbleTime,
+    embedded: true
+});
+const ChatBubbleTime_generated = ChatBubbleTime;
+export default ChatBubbleTime_generated;

package/dist/components/chatbubble/index.d.ts

@@ -1 +1 @@
-export { default, type ChatBubbleProps } from "./ChatBubble";
+export { default, type ChatBubbleProps } from "./ChatBubble.generated";