@hanzo/ui 5.3.34 → 5.3.35

package/dist/src/registry/index.d.ts

@@ -0,0 +1,354 @@
+import { z } from "zod";
+export declare const fileSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    target: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    type: string;
+    content?: string | undefined;
+    target?: string | undefined;
+}, {
+    path: string;
+    type: string;
+    content?: string | undefined;
+    target?: string | undefined;
+}>;
+export declare const registryItemSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    author: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    devDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodOptional<z.ZodString>;
+        type: z.ZodString;
+        target: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        type: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }, {
+        path: string;
+        type: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }>, "many">>;
+    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    title: z.ZodOptional<z.ZodString>;
+    cssVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    tailwind: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    category: z.ZodOptional<z.ZodString>;
+    subcategory: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: string;
+    meta?: Record<string, any> | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+    author?: string | undefined;
+    dependencies?: string[] | undefined;
+    devDependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+    files?: {
+        path: string;
+        type: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }[] | undefined;
+    cssVars?: Record<string, any> | undefined;
+    tailwind?: Record<string, any> | undefined;
+    subcategory?: string | undefined;
+}, {
+    name: string;
+    type: string;
+    meta?: Record<string, any> | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+    category?: string | undefined;
+    author?: string | undefined;
+    dependencies?: string[] | undefined;
+    devDependencies?: string[] | undefined;
+    registryDependencies?: string[] | undefined;
+    files?: {
+        path: string;
+        type: string;
+        content?: string | undefined;
+        target?: string | undefined;
+    }[] | undefined;
+    cssVars?: Record<string, any> | undefined;
+    tailwind?: Record<string, any> | undefined;
+    subcategory?: string | undefined;
+}>;
+export declare const registrySchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    homepage: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        devDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodOptional<z.ZodString>;
+            type: z.ZodString;
+            target: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            type: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }, {
+            path: string;
+            type: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }>, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        title: z.ZodOptional<z.ZodString>;
+        cssVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        tailwind: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        category: z.ZodOptional<z.ZodString>;
+        subcategory: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: string;
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        files?: {
+            path: string;
+            type: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }, {
+        name: string;
+        type: string;
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        files?: {
+            path: string;
+            type: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    items: {
+        name: string;
+        type: string;
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        files?: {
+            path: string;
+            type: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }[];
+    style?: string | undefined;
+    $schema?: string | undefined;
+    homepage?: string | undefined;
+}, {
+    name: string;
+    items: {
+        name: string;
+        type: string;
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        files?: {
+            path: string;
+            type: string;
+            content?: string | undefined;
+            target?: string | undefined;
+        }[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }[];
+    style?: string | undefined;
+    $schema?: string | undefined;
+    homepage?: string | undefined;
+}>;
+export declare const registryWithContentSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    homepage: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodString>;
+} & {
+    items: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        author: z.ZodOptional<z.ZodString>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        devDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        title: z.ZodOptional<z.ZodString>;
+        cssVars: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        tailwind: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        category: z.ZodOptional<z.ZodString>;
+        subcategory: z.ZodOptional<z.ZodString>;
+    } & {
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            type: z.ZodString;
+            target: z.ZodOptional<z.ZodString>;
+        } & {
+            content: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            content: string;
+            type: string;
+            target?: string | undefined;
+        }, {
+            path: string;
+            content: string;
+            type: string;
+            target?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: string;
+        files: {
+            path: string;
+            content: string;
+            type: string;
+            target?: string | undefined;
+        }[];
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }, {
+        name: string;
+        type: string;
+        files: {
+            path: string;
+            content: string;
+            type: string;
+            target?: string | undefined;
+        }[];
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    items: {
+        name: string;
+        type: string;
+        files: {
+            path: string;
+            content: string;
+            type: string;
+            target?: string | undefined;
+        }[];
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }[];
+    style?: string | undefined;
+    $schema?: string | undefined;
+    homepage?: string | undefined;
+}, {
+    name: string;
+    items: {
+        name: string;
+        type: string;
+        files: {
+            path: string;
+            content: string;
+            type: string;
+            target?: string | undefined;
+        }[];
+        meta?: Record<string, any> | undefined;
+        title?: string | undefined;
+        description?: string | undefined;
+        category?: string | undefined;
+        author?: string | undefined;
+        dependencies?: string[] | undefined;
+        devDependencies?: string[] | undefined;
+        registryDependencies?: string[] | undefined;
+        cssVars?: Record<string, any> | undefined;
+        tailwind?: Record<string, any> | undefined;
+        subcategory?: string | undefined;
+    }[];
+    style?: string | undefined;
+    $schema?: string | undefined;
+    homepage?: string | undefined;
+}>;
+export type RegistryItem = z.infer<typeof registryItemSchema>;
+export type Registry = z.infer<typeof registrySchema>;
+export type RegistryWithContent = z.infer<typeof registryWithContentSchema>;
+export type RegistryFile = z.infer<typeof fileSchema>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/registry/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;EAKrB,CAAA;AAGF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe7B,CAAA;AAGF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMzB,CAAA;AAGF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUpC,CAAA;AAGF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AACrD,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAC3E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/src/registry/index.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+// Define the file schema to match hanzo/ui's format
+export const fileSchema = z.object({
+    path: z.string(),
+    content: z.string().optional(),
+    type: z.string(),
+    target: z.string().optional(),
+});
+// Registry item schema aligned with hanzo/ui format
+export const registryItemSchema = z.object({
+    name: z.string(),
+    type: z.string(),
+    description: z.string().optional(),
+    author: z.string().optional(),
+    dependencies: z.array(z.string()).optional(),
+    devDependencies: z.array(z.string()).optional(),
+    registryDependencies: z.array(z.string()).optional(),
+    files: z.array(fileSchema).optional(),
+    meta: z.record(z.string(), z.any()).optional(),
+    title: z.string().optional(),
+    cssVars: z.record(z.string(), z.any()).optional(),
+    tailwind: z.record(z.string(), z.any()).optional(),
+    category: z.string().optional(),
+    subcategory: z.string().optional(),
+});
+// Registry schema aligned with hanzo/ui format
+export const registrySchema = z.object({
+    $schema: z.string().optional(),
+    name: z.string(),
+    homepage: z.string().optional(),
+    style: z.string().optional(),
+    items: z.array(registryItemSchema),
+});
+// Schema for a registry with full content
+export const registryWithContentSchema = registrySchema.extend({
+    items: z.array(registryItemSchema.extend({
+        files: z.array(fileSchema.extend({
+            content: z.string(),
+        })),
+    })),
+});
+// Support CommonJS
+if (typeof module !== 'undefined') {
+    module.exports = { fileSchema, registryItemSchema, registrySchema, registryWithContentSchema };
+}

package/dist/src/spline/index.d.ts

@@ -0,0 +1,3 @@
+export { default as MediaStack } from './media-stack';
+export { default as SplinePlayer } from './player';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/spline/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/spline/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,eAAe,CAAA;AACrD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,UAAU,CAAA"}

package/dist/src/spline/index.js

@@ -0,0 +1,4 @@
+// @hanzo/ui/spline - Optional spline 3D components
+// Requires: npm install @splinetool/react-spline
+export { default as MediaStack } from './media-stack';
+export { default as SplinePlayer } from './player';

package/dist/src/spline/media-stack.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { MediaStackDef, Dimensions } from '../../types';
+/**
+ * MediaStack with Spline 3D support
+ * Requires: npm install @splinetool/react-spline
+ *
+ * For apps that don't need 3D, use the base MediaStack from @hanzo/ui instead
+ */
+declare const MediaStack: React.FC<{
+    media: MediaStackDef;
+    constrainTo?: Dimensions;
+    clx?: string;
+}>;
+export default MediaStack;
+//# sourceMappingURL=media-stack.d.ts.map

package/dist/src/spline/media-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-stack.d.ts","sourceRoot":"","sources":["../../../src/spline/media-stack.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAIzB,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAK5D;;;;;GAKG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,WAAW,CAAC,EAAE,UAAU,CAAA;IACxB,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAkDA,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/src/spline/media-stack.js

@@ -0,0 +1,33 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import Spline from '@splinetool/react-spline';
+import { cn, constrain, spreadToTransform } from '../../util';
+import Image from '../../primitives/next/image';
+import VideoPlayer from '../../primitives/video-player';
+/**
+ * MediaStack with Spline 3D support
+ * Requires: npm install @splinetool/react-spline
+ *
+ * For apps that don't need 3D, use the base MediaStack from @hanzo/ui instead
+ */
+const MediaStack = ({ media, constrainTo: cnst = { w: 250, h: 250 }, clx = '' }) => {
+    const { img, video, animation, mediaTransform } = media;
+    const transform = mediaTransform ?? {};
+    // Order of precedence: 3D > MP4 > Image
+    if (animation) {
+        return (_jsx(Spline, { scene: animation, className: cn(clx, 'pointer-events-none'), "data-vaul-no-drag": true, style: {
+                width: (6 / 5 * (typeof cnst.h === 'number' ? cnst.h : parseInt(cnst.h))),
+                height: cnst.h,
+                ...spreadToTransform(transform)
+            } }));
+    }
+    if (video) {
+        const dim = constrain(video.dim.md, cnst);
+        return (_jsx(VideoPlayer, { className: clx, sources: video.sources, width: dim.w, height: dim.h, style: {
+                minHeight: dim.h,
+                ...spreadToTransform(transform)
+            }, ...video.videoProps }));
+    }
+    return img ? (_jsx(Image, { def: img, constrainTo: cnst, className: clx, transform: transform })) : (_jsx("div", { style: { width: cnst.w, height: cnst.h }, className: cn('bg-level-2', clx) }));
+};
+export default MediaStack;

package/dist/src/spline/player.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { Application } from '@splinetool/runtime';
+export interface SplinePlayerProps {
+    scene: string;
+    className?: string;
+    style?: React.CSSProperties;
+    onLoad?: (spline: Application) => void;
+}
+/**
+ * Spline 3D player component
+ * Requires: npm install @splinetool/react-spline
+ */
+declare const SplinePlayer: React.FC<SplinePlayerProps>;
+export default SplinePlayer;
+//# sourceMappingURL=player.d.ts.map

package/dist/src/spline/player.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.d.ts","sourceRoot":"","sources":["../../../src/spline/player.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAA;AAEzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAItD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAA;IAC3B,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;CACvC;AAED;;;GAGG;AACH,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAc7C,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/src/spline/player.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import Spline from '@splinetool/react-spline';
+import { cn } from '../../util';
+/**
+ * Spline 3D player component
+ * Requires: npm install @splinetool/react-spline
+ */
+const SplinePlayer = ({ scene, className, style, onLoad }) => {
+    return (_jsx(Spline, { scene: scene, className: cn('pointer-events-none', className), style: style, onLoad: onLoad }));
+};
+export default SplinePlayer;

package/dist/src/ui/announcement.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+export interface AnnouncementProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+}
+declare const Announcement: React.ForwardRefExoticComponent<AnnouncementProps & React.RefAttributes<HTMLDivElement>>;
+export { Announcement };
+//# sourceMappingURL=announcement.d.ts.map

package/dist/src/ui/announcement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"announcement.d.ts","sourceRoot":"","sources":["../../../src/ui/announcement.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAM9B,MAAM,WAAW,iBAAkB,SAAQ,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC;IAC7E,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,IAAI,CAAA;CACvB;AAED,QAAA,MAAM,YAAY,0FAmCjB,CAAA;AAID,OAAO,EAAE,YAAY,EAAE,CAAA"}

package/dist/src/ui/announcement.js

@@ -0,0 +1,18 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { X } from "lucide-react";
+import { cn } from "../utils";
+import { Button } from "../button";
+const Announcement = React.forwardRef(({ className, children, dismissible = true, onDismiss, ...props }, ref) => {
+    const [isVisible, setIsVisible] = React.useState(true);
+    const handleDismiss = () => {
+        setIsVisible(false);
+        onDismiss?.();
+    };
+    if (!isVisible)
+        return null;
+    return (_jsxs("div", { ref: ref, className: cn("relative flex items-center gap-4 rounded-lg border bg-background px-4 py-3 text-sm", className), ...props, children: [_jsx("div", { className: "flex-1", children: children }), dismissible && (_jsxs(Button, { variant: "ghost", size: "icon", className: "h-6 w-6", onClick: handleDismiss, children: [_jsx(X, { className: "h-4 w-4" }), _jsx("span", { className: "sr-only", children: "Dismiss" })] }))] }));
+});
+Announcement.displayName = "Announcement";
+export { Announcement };

package/dist/src/ui/avatar-group.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+export interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    items: Array<{
+        src?: string;
+        alt?: string;
+        fallback: string;
+    }>;
+    max?: number;
+}
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
+export { AvatarGroup };
+//# sourceMappingURL=avatar-group.d.ts.map

package/dist/src/ui/avatar-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"avatar-group.d.ts","sourceRoot":"","sources":["../../../src/ui/avatar-group.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAS9B,MAAM,WAAW,gBAAiB,SAAQ,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC;IAC5E,KAAK,EAAE,KAAK,CAAC;QACX,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,QAAQ,EAAE,MAAM,CAAA;KACjB,CAAC,CAAA;IACF,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,QAAA,MAAM,WAAW,yFAqBhB,CAAA;AAGD,OAAO,EAAE,WAAW,EAAE,CAAA"}

package/dist/src/ui/avatar-group.js

@@ -0,0 +1,12 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../utils";
+import { Avatar, AvatarFallback, AvatarImage, } from "../avatar";
+const AvatarGroup = React.forwardRef(({ className, items, max = 5, ...props }, ref) => {
+    const displayItems = items.slice(0, max);
+    const remaining = items.length - max;
+    return (_jsxs("div", { ref: ref, className: cn("flex -space-x-4", className), ...props, children: [displayItems.map((item, index) => (_jsxs(Avatar, { className: "border-2 border-background", children: [_jsx(AvatarImage, { src: item.src, alt: item.alt }), _jsx(AvatarFallback, { children: item.fallback })] }, index))), remaining > 0 && (_jsx(Avatar, { className: "border-2 border-background", children: _jsxs(AvatarFallback, { children: ["+", remaining] }) }))] }));
+});
+AvatarGroup.displayName = "AvatarGroup";
+export { AvatarGroup };

package/dist/src/ui/banner.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const bannerVariants: (props?: ({
+    variant?: "default" | "error" | "info" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface BannerProps extends React.HTMLAttributes<HTMLDivElement>, VariantProps<typeof bannerVariants> {
+    onClose?: () => void;
+}
+declare const Banner: React.ForwardRefExoticComponent<BannerProps & React.RefAttributes<HTMLDivElement>>;
+export { Banner, bannerVariants };
+//# sourceMappingURL=banner.d.ts.map

package/dist/src/ui/banner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"banner.d.ts","sourceRoot":"","sources":["../../../src/ui/banner.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAKjE,QAAA,MAAM,cAAc;;8EAmBnB,CAAA;AAED,MAAM,WAAW,WACf,SAAQ,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC,EAC1C,YAAY,CAAC,OAAO,cAAc,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CACrB;AAED,QAAA,MAAM,MAAM,oFAuBX,CAAA;AAGD,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA"}

package/dist/src/ui/banner.js

@@ -0,0 +1,25 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { cva } from "class-variance-authority";
+import { X } from "lucide-react";
+import { cn } from "../utils";
+const bannerVariants = cva("relative w-full border-b px-4 py-3 text-sm [&>svg~*]:pl-7 [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground", {
+    variants: {
+        variant: {
+            default: "bg-background text-foreground",
+            info: "border-blue-500/50 bg-blue-50 text-blue-900 dark:bg-blue-950 dark:text-blue-100 [&>svg]:text-blue-600 dark:[&>svg]:text-blue-400",
+            success: "border-green-500/50 bg-green-50 text-green-900 dark:bg-green-950 dark:text-green-100 [&>svg]:text-green-600 dark:[&>svg]:text-green-400",
+            warning: "border-yellow-500/50 bg-yellow-50 text-yellow-900 dark:bg-yellow-950 dark:text-yellow-100 [&>svg]:text-yellow-600 dark:[&>svg]:text-yellow-400",
+            error: "border-red-500/50 bg-red-50 text-red-900 dark:bg-red-950 dark:text-red-100 [&>svg]:text-red-600 dark:[&>svg]:text-red-400",
+        },
+    },
+    defaultVariants: {
+        variant: "default",
+    },
+});
+const Banner = React.forwardRef(({ className, variant, onClose, children, ...props }, ref) => {
+    return (_jsxs("div", { ref: ref, role: "alert", className: cn(bannerVariants({ variant }), className), ...props, children: [children, onClose && (_jsxs("button", { type: "button", onClick: onClose, className: "absolute right-4 top-3 rounded-md p-1 hover:bg-black/5 dark:hover:bg-white/5", children: [_jsx(X, { className: "h-4 w-4" }), _jsx("span", { className: "sr-only", children: "Close" })] }))] }));
+});
+Banner.displayName = "Banner";
+export { Banner, bannerVariants };

package/dist/src/ui/cursor.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+export interface CursorProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    cursorText?: string;
+    cursorSize?: number;
+}
+declare const Cursor: React.ForwardRefExoticComponent<CursorProps & React.RefAttributes<HTMLDivElement>>;
+export { Cursor };
+//# sourceMappingURL=cursor.d.ts.map

package/dist/src/ui/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../../src/ui/cursor.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,cAAc,CAAC,cAAc,CAAC;IACvE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,QAAA,MAAM,MAAM,oFA4CX,CAAA;AAGD,OAAO,EAAE,MAAM,EAAE,CAAA"}

package/dist/src/ui/cursor.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../utils";
+const Cursor = React.forwardRef(({ className, children, cursorText, cursorSize = 20, ...props }, ref) => {
+    const [position, setPosition] = React.useState({ x: 0, y: 0 });
+    const [isHovered, setIsHovered] = React.useState(false);
+    const handleMouseMove = (e) => {
+        const rect = e.currentTarget.getBoundingClientRect();
+        setPosition({
+            x: e.clientX - rect.left,
+            y: e.clientY - rect.top,
+        });
+    };
+    return (_jsxs("div", { ref: ref, className: cn("relative cursor-none", className), onMouseMove: handleMouseMove, onMouseEnter: () => setIsHovered(true), onMouseLeave: () => setIsHovered(false), ...props, children: [children, isHovered && (_jsx("div", { className: "pointer-events-none absolute z-50 flex items-center justify-center rounded-full bg-primary/20 backdrop-blur-sm transition-transform", style: {
+                    left: position.x,
+                    top: position.y,
+                    width: cursorSize,
+                    height: cursorSize,
+                    transform: "translate(-50%, -50%)",
+                }, children: cursorText && (_jsx("span", { className: "text-xs font-medium text-primary", children: cursorText })) }))] }));
+});
+Cursor.displayName = "Cursor";
+export { Cursor };