@hanzo/ui 5.3.41 → 5.4.1

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

@@ -0,0 +1,38 @@
+import { RegistryItem, Registry } from "./index";
+/**
+ * Gets the full registry URL based on the registry name or URL provided
+ * @param registry - Registry name, URL, or file path
+ * @returns The complete registry URL
+ */
+export declare function getRegistryUrl(registry: string): string;
+/**
+ * Fetches a specific registry item by URL
+ * @param itemUrl - The URL of the item to fetch
+ * @param basePath - Base path for resolving imports
+ * @returns The registry item or null if not found
+ */
+export declare function getRegistryItem(itemUrl: string, basePath: string): Promise<RegistryItem | null>;
+/**
+ * Resolves an import path relative to a base path
+ * @param importPath - The import path to resolve
+ * @param basePath - The base path to resolve against
+ * @returns The resolved import path
+ */
+export declare function resolveImport(importPath: string, basePath: string): string;
+/**
+ * Fetches registry data from one or more paths
+ * @param paths - Array of registry paths to fetch
+ * @param options - Options for fetching the registry
+ * @returns Array of registry data
+ */
+export declare function fetchRegistry(paths: string[], options?: {
+    useCache?: boolean;
+}): Promise<Registry[]>;
+/**
+ * Gets the URL for a specific registry item
+ * @param itemName - The name of the registry item
+ * @param registryUrl - The base registry URL
+ * @returns The URL for the specific registry item
+ */
+export declare function getRegistryItemUrl(itemName: string, registryUrl: string): string;
+//# sourceMappingURL=api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../src/registry/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,YAAY,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAKpE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAgBvD;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAoC9B;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAc1E;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GACnC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAyCrB;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAGhF"}

package/dist/src/registry/api.js

@@ -0,0 +1,129 @@
+import { registryItemSchema } from "./index";
+const registryCache = new Map();
+/**
+ * Gets the full registry URL based on the registry name or URL provided
+ * @param registry - Registry name, URL, or file path
+ * @returns The complete registry URL
+ */
+export function getRegistryUrl(registry) {
+    // Check if registry is a full URL
+    if (registry.startsWith("http")) {
+        return registry;
+    }
+    // Default to Hanzo registry if REGISTRY_BASE_URL is defined, otherwise use hanzo
+    const baseUrl = process.env.REGISTRY_BASE_URL || "https://ui.hanzo.com/registry";
+    // Check if registry is a path to a JSON file
+    if (registry.endsWith(".json")) {
+        return `${baseUrl}/${registry}`;
+    }
+    // Assume registry is a registry style
+    return `${baseUrl}/${registry}/registry.json`;
+}
+/**
+ * Fetches a specific registry item by URL
+ * @param itemUrl - The URL of the item to fetch
+ * @param basePath - Base path for resolving imports
+ * @returns The registry item or null if not found
+ */
+export async function getRegistryItem(itemUrl, basePath) {
+    try {
+        const response = await fetch(itemUrl);
+        if (!response.ok) {
+            console.error(`Failed to fetch registry item from ${itemUrl}: ${response.status} ${response.statusText}`);
+            return null;
+        }
+        const item = await response.json();
+        const validatedItem = registryItemSchema.safeParse(item);
+        if (!validatedItem.success) {
+            console.error(`Invalid registry item format: ${JSON.stringify(validatedItem.error)}`);
+            return null;
+        }
+        // Process and resolve file paths
+        if (validatedItem.data.files) {
+            for (const file of validatedItem.data.files) {
+                if (!file.content) {
+                    continue;
+                }
+                // If the file has a target, we resolve it from the target
+                if (file.target) {
+                    file.target = resolveImport(file.target, basePath);
+                }
+            }
+        }
+        return validatedItem.data;
+    }
+    catch (error) {
+        console.error(`Error fetching registry item: ${error}`);
+        return null;
+    }
+}
+/**
+ * Resolves an import path relative to a base path
+ * @param importPath - The import path to resolve
+ * @param basePath - The base path to resolve against
+ * @returns The resolved import path
+ */
+export function resolveImport(importPath, basePath) {
+    const importParts = importPath?.split("/");
+    // Check if it's a relative import
+    if (importPath.startsWith(".")) {
+        return [basePath.replace(/^@/, ""), ...importParts].filter(Boolean).join("/");
+    }
+    // Check if it's a scope package
+    if (importParts?.[0]?.startsWith("@")) {
+        return importPath;
+    }
+    return importPath;
+}
+/**
+ * Fetches registry data from one or more paths
+ * @param paths - Array of registry paths to fetch
+ * @param options - Options for fetching the registry
+ * @returns Array of registry data
+ */
+export async function fetchRegistry(paths, options = {}) {
+    options = {
+        useCache: true,
+        ...options,
+    };
+    try {
+        const results = await Promise.all(paths.map(async (path) => {
+            const url = getRegistryUrl(path);
+            // Check cache first if caching is enabled
+            if (options.useCache && registryCache.has(url)) {
+                return registryCache.get(url);
+            }
+            // Store the promise in the cache before awaiting if caching is enabled
+            const fetchPromise = (async () => {
+                const response = await fetch(url);
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch registry from ${url}. ${response.status} ${response.statusText}`);
+                }
+                return response.json();
+            })();
+            if (options.useCache) {
+                registryCache.set(url, fetchPromise);
+            }
+            return fetchPromise;
+        }));
+        return results;
+    }
+    catch (error) {
+        console.error(`Error fetching registry: ${error}`);
+        throw error;
+    }
+}
+/**
+ * Gets the URL for a specific registry item
+ * @param itemName - The name of the registry item
+ * @param registryUrl - The base registry URL
+ * @returns The URL for the specific registry item
+ */
+export function getRegistryItemUrl(itemName, registryUrl) {
+    const registryBaseUrl = registryUrl.replace(/\/registry\.json$/, "");
+    return `${registryBaseUrl}/r/${itemName}.json`;
+}
+// Support CommonJS
+if (typeof module !== 'undefined') {
+    module.exports = { getRegistryUrl, getRegistryItem, resolveImport, fetchRegistry, getRegistryItemUrl };
+}

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;