@hivemindhq/core 0.4.0

package/dist/utils/index.d.ts

@@ -0,0 +1,573 @@
+import { ClassValue } from 'clsx';
+import React__default from 'react';
+
+/**
+ * Combines class names using clsx and merges Tailwind classes intelligently.
+ * This is the standard utility for conditional and merged class names.
+ *
+ * @param inputs - Class values to combine (strings, objects, arrays)
+ * @returns Merged class string with Tailwind conflicts resolved
+ *
+ * @example
+ * cn('px-4 py-2', isActive && 'bg-blue-500', { 'opacity-50': isDisabled })
+ * // Returns: "px-4 py-2 bg-blue-500" (if isActive is true, isDisabled is false)
+ */
+declare function cn(...inputs: ClassValue[]): string;
+
+/**
+ * Formatting utilities for display purposes
+ */
+/**
+ * Options for formatting crypto amounts.
+ */
+interface FormatCryptoAmountOptions {
+    /** Maximum significant digits before truncation (default: 10) */
+    maxSignificantDigits?: number;
+    /** Use compact notation for large numbers (default: false) */
+    compact?: boolean;
+    /** Locale for number formatting (default: 'en-US') */
+    locale?: string;
+    /** Minimum decimal places to show (default: 0) */
+    minDecimals?: number;
+    /** Maximum decimal places to show (default: 6) */
+    maxDecimals?: number;
+}
+/**
+ * Result of formatting a crypto amount.
+ */
+interface FormattedCryptoAmount {
+    /** The display string (may be truncated) */
+    display: string;
+    /** The full value string (for tooltips) */
+    fullValue: string;
+    /** Whether the display was truncated */
+    isTruncated: boolean;
+    /** The numeric value (for calculations) */
+    numericValue: number;
+}
+/**
+ * Formats a raw crypto amount (in wei/smallest unit) for display.
+ *
+ * Handles:
+ * - Conversion from smallest unit to readable format
+ * - Truncation of excessive precision with tooltip support
+ * - Compact notation for large amounts (1.5M, 2.3B)
+ * - Locale-aware number formatting
+ *
+ * @param value - Raw amount as string or bigint (e.g., "1500000000000000000" for 1.5 tokens)
+ * @param decimals - Token decimals (default: 18)
+ * @param options - Formatting options
+ * @returns Formatted amount with display string and metadata
+ *
+ * @example
+ * formatCryptoAmount("1500000000000000000", 18)
+ * // Returns: { display: "1.5", fullValue: "1.5", isTruncated: false, numericValue: 1.5 }
+ *
+ * formatCryptoAmount("12345678901234567890123", 18, { maxSignificantDigits: 6 })
+ * // Returns: { display: "12345.6...", fullValue: "12345.678901234567890123", isTruncated: true, ... }
+ */
+declare function formatCryptoAmount(value: string | bigint, decimals?: number, options?: FormatCryptoAmountOptions): FormattedCryptoAmount;
+/**
+ * Truncates a numeric string to a maximum number of significant digits.
+ * Leading zeros in decimals don't count toward the limit.
+ *
+ * @param value - The numeric string to truncate
+ * @param maxDigits - Maximum significant digits to keep
+ * @returns Object with truncated string and whether truncation occurred
+ *
+ * @example
+ * truncateSignificantDigits("123456789012", 10)
+ * // Returns: { truncated: "1234567890…", isTruncated: true }
+ *
+ * truncateSignificantDigits("0.0000123456789", 10)
+ * // Returns: { truncated: "0.0000123456789", isTruncated: false }
+ * // (leading zeros don't count, only 9 significant digits)
+ */
+declare function truncateSignificantDigits(value: string, maxDigits: number): {
+    truncated: string;
+    isTruncated: boolean;
+};
+/**
+ * Truncates an address or ID for display.
+ * Shows first N characters after optional prefix.
+ *
+ * @param value - The full address or ID string
+ * @param chars - Number of characters to show (default: 5)
+ * @param prefix - Prefix to skip (default: '0x')
+ * @returns Truncated string
+ *
+ * @example
+ * truncateId('0x123456789098765432') // Returns: '12345'
+ * truncateId('0x123456789098765432', 8) // Returns: '12345678'
+ */
+declare function truncateId(value: string, chars?: number, prefix?: string): string;
+/**
+ * Converts an IPFS URI to an HTTP gateway URL.
+ *
+ * @param uri - The IPFS URI (ipfs://... format)
+ * @param gateway - The gateway to use (default: ipfs.io)
+ * @returns HTTP URL for the content
+ *
+ * @example
+ * ipfsToHttp('ipfs://QmHash123') // Returns: 'https://ipfs.io/ipfs/QmHash123'
+ */
+declare function ipfsToHttp(uri: string | undefined | null, gateway?: string): string | undefined;
+/**
+ * Formats a number with compact notation (K, M, B, etc.)
+ *
+ * @param value - The number to format
+ * @param decimals - Maximum decimal places (default: 2)
+ * @returns Formatted string
+ *
+ * @example
+ * formatCompact(1500) // Returns: '1.5K'
+ * formatCompact(2500000) // Returns: '2.5M'
+ */
+declare function formatCompact(value: number, decimals?: number): string;
+/**
+ * Strengthens/normalizes an image URL to ensure it's displayable.
+ * Handles IPFS URIs, raw IPFS hashes, and validates HTTP URLs.
+ *
+ * @param url - The image URL to process
+ * @returns A normalized HTTP(S) URL
+ *
+ * @example
+ * strengthenImageUrl('ipfs://QmHash123') // Returns: 'https://ipfs.io/ipfs/QmHash123'
+ * strengthenImageUrl('QmHash123') // Returns: 'https://ipfs.io/ipfs/QmHash123'
+ * strengthenImageUrl('https://example.com/img.png') // Returns: 'https://example.com/img.png'
+ */
+declare function strengthenImageUrl(url?: string): string;
+/**
+ * Ellipsizes a string by showing characters from start and end with '...' in middle.
+ *
+ * @param str - The string to ellipsize
+ * @param length - Total visible characters (split between start and end)
+ * @returns Ellipsized string or original if shorter than length
+ *
+ * @example
+ * ellipsizeString('0x1234567890abcdef', 8) // Returns: '0x12...cdef'
+ */
+declare function ellipsizeString(str: string | undefined | null, length: number): string;
+/**
+ * Ellipsizes a hex string (0x-prefixed) preserving the prefix.
+ *
+ * @param hex - The hex string to ellipsize (must start with 0x)
+ * @param length - Visible characters in the payload (default: 12)
+ * @returns Ellipsized hex string
+ * @throws Error if hex doesn't start with 0x
+ *
+ * @example
+ * ellipsizeHex('0x1234567890abcdef1234567890abcdef') // Returns: '0x123456...abcdef'
+ */
+declare function ellipsizeHex(hex: string, length?: number): string;
+/**
+ * Truncates a string to a specified length, adding '...' at the end.
+ *
+ * @param str - The string to truncate
+ * @param length - Maximum length before truncation
+ * @returns Truncated string with '...' or original if shorter
+ *
+ * @example
+ * truncateString('Hello World', 5) // Returns: 'Hello...'
+ */
+declare function truncateString(str: string | undefined | null, length: number): string;
+/**
+ * Intelligently shortens a label based on its type (hex, URL, IPFS, DID, etc.)
+ * This is the main utility for displaying atom/entity labels in the UI.
+ *
+ * @param label - The label to shorten
+ * @param length - Maximum length for generic strings (default: 50)
+ * @returns Shortened label appropriate for its type
+ *
+ * @example
+ * shortenLabel('0x1234567890abcdef...') // Returns: '0x1234...cdef'
+ * shortenLabel('https://example.com/page') // Returns: 'example.com/page'
+ * shortenLabel('ipfs://bafkre...') // Returns: 'bafkre...xyz'
+ */
+declare function shortenLabel(label: string | null | undefined, length?: number): string;
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @param str - The string to capitalize
+ * @returns String with first letter capitalized
+ *
+ * @example
+ * capitalizeFirstLetter('hello') // Returns: 'Hello'
+ */
+declare function capitalizeFirstLetter(str: string): string;
+/**
+ * Capitalizes the first letter of each word in a phrase.
+ *
+ * @param phrase - The phrase to capitalize
+ * @returns Phrase with each word capitalized
+ *
+ * @example
+ * capitalize('hello world') // Returns: 'Hello World'
+ */
+declare function capitalize(phrase: string): string;
+/**
+ * Converts seconds to a compact human-readable format (e.g., "5d", "3h", "10m").
+ *
+ * @param seconds - Number of seconds
+ * @returns Compact time string
+ *
+ * @example
+ * secondsToHms(3700) // Returns: '1h'
+ * secondsToHms(90) // Returns: '1m'
+ */
+declare function secondsToHms(seconds: number): string;
+/**
+ * Formats a date as a human-readable "time ago" string.
+ * Handles various date input formats including Unix timestamps.
+ *
+ * @param date - Date object, ISO string, or Unix timestamp (10 or 13 digits)
+ * @param ago - Whether to append "ago" suffix (default: true)
+ * @returns Human-readable time difference string
+ *
+ * @example
+ * timeAgo(new Date(Date.now() - 3600000)) // Returns: '1h ago'
+ * timeAgo('1703001600', false) // Returns: '5d'
+ */
+declare function timeAgo(date: Date | string, ago?: boolean): string;
+/**
+ * Converts seconds to a descriptive duration string (e.g., "5 d", "3 h").
+ *
+ * @param inputVar - Seconds as number or string
+ * @returns Duration string with space before unit
+ *
+ * @example
+ * secondsToDhms(90000) // Returns: '1 d'
+ */
+declare function secondsToDhms(inputVar: string | number): string;
+
+/**
+ * Atom-related utility functions for Intuition protocol
+ */
+/**
+ * All possible atom types from the Intuition protocol.
+ * These correspond to the PostgreSQL enum and Rust AtomType.
+ */
+declare const ATOM_TYPES: readonly ["Account", "Book", "ByteObject", "Caip10", "FollowAction", "JsonObject", "Keywords", "LikeAction", "Organization", "OrganizationPredicate", "Person", "PersonPredicate", "TextObject", "Thing", "ThingPredicate", "Unknown"];
+type AtomType = typeof ATOM_TYPES[number];
+/**
+ * Shape of atom data that can be passed to getAtomType.
+ * Supports various atom object shapes from GraphQL responses.
+ */
+interface AtomTypeInput {
+    /** Direct type field from GraphQL (primary source) */
+    type?: string;
+    /** Alternate naming used in some contexts */
+    atomType?: string;
+    /** Value object with typed sub-objects (secondary source) */
+    value?: {
+        thing?: unknown;
+        person?: unknown;
+        organization?: unknown;
+        book?: unknown;
+        account?: unknown;
+        text_object?: unknown;
+        json_object?: unknown;
+        byte_object?: unknown;
+    };
+    /** Raw atom data string for pattern detection (tertiary source) */
+    data?: string;
+}
+/**
+ * Extracts the atom type from an atom object using a cascade/fallback strategy:
+ *
+ * 1. **Primary**: Direct `type` or `atomType` field from GraphQL
+ * 2. **Secondary**: Inferred from populated `value.*` sub-objects
+ * 3. **Tertiary**: Pattern detection from `data` string
+ *
+ * @param atom - Atom object with type information
+ * @returns The atom type string, or undefined if not determinable
+ *
+ * @example
+ * // From GraphQL type field
+ * getAtomType({ type: 'Person' }) // Returns: 'Person'
+ *
+ * @example
+ * // From value sub-object
+ * getAtomType({ value: { person: { name: 'Vitalik' } } }) // Returns: 'Person'
+ *
+ * @example
+ * // From text_object value (plain text atoms)
+ * getAtomType({ value: { text_object: { data: 'Revel8' } } }) // Returns: 'TextObject'
+ *
+ * @example
+ * // From data pattern
+ * getAtomType({ data: '0x1234...5678' }) // Returns: 'Account'
+ *
+ * @example
+ * // Plain text detection
+ * getAtomType({ data: 'Revel8' }) // Returns: 'TextObject'
+ * getAtomType({ data: 'Kylan Hurt' }) // Returns: 'TextObject'
+ */
+declare function getAtomType(atom: AtomTypeInput): AtomType | undefined;
+/**
+ * Formats an atom type for display purposes.
+ * Converts internal type names to user-friendly labels.
+ *
+ * @param type - The atom type string
+ * @returns Formatted display string
+ *
+ * @example
+ * formatAtomType('TextObject') // Returns: 'Text'
+ * formatAtomType('PersonPredicate') // Returns: 'Person Predicate'
+ * formatAtomType('FollowAction') // Returns: 'Follow'
+ */
+declare function formatAtomType(type: string | undefined): string;
+/**
+ * Checks if an atom type is a predicate type.
+ * Predicates are used as the middle component of triples.
+ *
+ * @param type - The atom type to check
+ * @returns True if the type is a predicate
+ *
+ * @example
+ * isPredicateType('ThingPredicate') // Returns: true
+ * isPredicateType('Person') // Returns: false
+ */
+declare function isPredicateType(type: string | undefined): boolean;
+/**
+ * Checks if an atom type represents a structured entity (Person, Organization, Thing).
+ * These types typically have rich metadata from schema.org.
+ *
+ * @param type - The atom type to check
+ * @returns True if the type is a structured entity
+ */
+declare function isEntityType(type: string | undefined): boolean;
+/**
+ * Checks if an atom type is a raw data type (TextObject, JsonObject, ByteObject).
+ * These types contain data without schema.org structure.
+ *
+ * @param type - The atom type to check
+ * @returns True if the type is a raw data type
+ *
+ * @example
+ * isRawDataType('TextObject') // Returns: true
+ * isRawDataType('Person') // Returns: false
+ */
+declare function isRawDataType(type: string | undefined): boolean;
+/**
+ * Checks if an atom type is plain text (TextObject).
+ * Plain text atoms contain simple strings like names, labels, or concepts.
+ *
+ * @param type - The atom type to check
+ * @returns True if the type is TextObject
+ *
+ * @example
+ * isPlainTextType('TextObject') // Returns: true
+ * isPlainTextType('Person') // Returns: false
+ */
+declare function isPlainTextType(type: string | undefined): boolean;
+
+/**
+ * Shared type definitions for atom search functionality
+ * Used by both revel8-explorer and intuition-extension
+ */
+/**
+ * Vault data from GraphQL response
+ */
+interface AtomVault {
+    market_cap?: string;
+    total_shares?: string;
+    current_share_price?: string;
+    position_count?: number;
+}
+/**
+ * Value sub-objects from GraphQL - resolved IPFS/schema.org data
+ */
+interface AtomValue {
+    thing?: {
+        name?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+    };
+    person?: {
+        name?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+    };
+    organization?: {
+        name?: string;
+        description?: string;
+        image?: string;
+        url?: string;
+    };
+    account?: {
+        label?: string;
+        id?: string;
+    };
+    text_object?: {
+        data?: string;
+    };
+    json_object?: {
+        data?: unknown;
+    };
+    byte_object?: {
+        data?: string;
+    };
+}
+/**
+ * Creator information
+ */
+interface AtomCreator {
+    id: string;
+    label?: string;
+}
+/**
+ * Raw atom shape from GraphQL response
+ * This matches what the API returns - use directly without transformation
+ */
+interface GraphQLAtom {
+    term_id: string;
+    label?: string;
+    data?: string;
+    type?: string;
+    emoji?: string;
+    image?: string;
+    created_at?: string;
+    creator?: AtomCreator;
+    term?: {
+        vaults?: AtomVault[];
+    };
+    value?: AtomValue;
+}
+/**
+ * Ranked atom with search scores
+ * Extends GraphQLAtom with computed ranking fields
+ */
+interface RankedAtom extends GraphQLAtom {
+    /** Match quality score based on search term relevance */
+    matchScore: number;
+    /** Stake amount for primary sorting */
+    stakeScore: number;
+    /** Whether this is an exact label match */
+    isExactMatch: boolean;
+    /** Whether this is an exact term_id match */
+    isExactTermIdMatch: boolean;
+    /** Combined score for debugging/display */
+    totalScore: number;
+}
+/**
+ * Summary of search results for display
+ */
+interface SearchSummary {
+    totalMatches: number;
+    totalStaked: string;
+    totalPositions: number;
+    topMatches: RankedAtom[];
+}
+/**
+ * Complete search result
+ */
+interface SearchResult<T extends GraphQLAtom = GraphQLAtom> {
+    matches: T[];
+    summary: SearchSummary;
+}
+
+/**
+ * Atom search ranking utilities
+ * Provides stake-first ranking with relevance as secondary sort
+ *
+ * @example
+ * import { rankAtoms } from '@revel8/core'
+ * const rankedResults = rankAtoms(response.data.atoms, searchTerm)
+ */
+
+/**
+ * Calculate match score between text and search term
+ * Used for relevance ranking in search results
+ *
+ * @param text - The text to check for matches
+ * @param searchTerm - The search term to match against
+ * @returns Score from 0-100 based on match quality
+ *
+ * @example
+ * calculateMatchScore('Vitalik Buterin', 'vitalik') // 90 (starts with)
+ * calculateMatchScore('About Vitalik', 'vitalik')   // ~47 (contains at position 6)
+ * calculateMatchScore('Vitalik', 'vitalik')         // 100 (exact match)
+ */
+declare function calculateMatchScore(text: string, searchTerm: string): number;
+/**
+ * Rank and sort atoms by stake amount with relevance as secondary sort
+ *
+ * Algorithm:
+ * 1. Exact term_id matches always come first
+ * 2. Primary sort: By stake (market_cap, highest first)
+ * 3. Secondary sort: By match quality score
+ *
+ * @param atoms - Array of atoms from GraphQL response
+ * @param searchTerm - The search term used for relevance scoring
+ * @returns Sorted array with ranking metadata added
+ *
+ * @example
+ * const atoms = response.data.atoms
+ * const ranked = rankAtoms(atoms, 'vitalik')
+ * // Returns atoms sorted by stake, with matchScore, stakeScore, etc. added
+ */
+declare function rankAtoms<T extends GraphQLAtom>(atoms: T[], searchTerm: string): (T & RankedAtom)[];
+/**
+ * Get the display name for an atom
+ * Checks value sub-objects first, falls back to label, then data
+ *
+ * @param atom - The atom to get display name for
+ * @returns The best display name available
+ */
+declare function getAtomDisplayName(atom: GraphQLAtom): string;
+/**
+ * Get the description for an atom from value sub-objects
+ *
+ * @param atom - The atom to get description for
+ * @returns The description if available, empty string otherwise
+ */
+declare function getAtomDescription(atom: GraphQLAtom): string;
+/**
+ * Get the image URL for an atom from value sub-objects
+ * Handles IPFS URLs by converting to gateway URLs
+ *
+ * @param atom - The atom to get image for
+ * @returns The image URL or empty string
+ */
+declare function getAtomImage(atom: GraphQLAtom): string;
+
+/**
+ * Format stake amount for display (converts from wei to TRUST with suffixes)
+ *
+ * @param marketCap - The market cap in wei (18 decimals)
+ * @returns Formatted string like "1.5K", "2.3M", etc.
+ *
+ * @example
+ * formatStake('1000000000000000000') // "1"
+ * formatStake('1500000000000000000000') // "1.5K"
+ * formatStake('2300000000000000000000000') // "2.3M"
+ */
+declare function formatStake(marketCap: string | number | undefined): string;
+/**
+ * Highlight matching text in search results
+ * Returns React elements with highlighted portions
+ *
+ * @param text - The text to highlight
+ * @param searchTerm - The search term to highlight
+ * @returns React elements with matching text highlighted
+ *
+ * @example
+ * highlightMatch('Vitalik Buterin', 'vitalik')
+ * // Returns: [<strong>Vitalik</strong>, ' Buterin']
+ */
+declare function highlightMatch(text: string, searchTerm: string): React__default.ReactNode;
+/**
+ * Format a term_id for display (first 5 characters after 0x)
+ *
+ * @param termId - The full term_id (e.g., "0x123456789...")
+ * @returns Shortened display format (e.g., "12345")
+ *
+ * @example
+ * formatTermId('0x123456789098765432') // "12345"
+ */
+declare function formatTermId(termId: string): string;
+
+export { ATOM_TYPES, type AtomCreator, type AtomType, type AtomTypeInput, type AtomValue, type AtomVault, type FormatCryptoAmountOptions, type FormattedCryptoAmount, type GraphQLAtom, type RankedAtom, type SearchResult, type SearchSummary, calculateMatchScore, capitalize, capitalizeFirstLetter, cn, ellipsizeHex, ellipsizeString, formatAtomType, formatCompact, formatCryptoAmount, formatStake, formatTermId, getAtomDescription, getAtomDisplayName, getAtomImage, getAtomType, highlightMatch, ipfsToHttp, isEntityType, isPlainTextType, isPredicateType, isRawDataType, rankAtoms, secondsToDhms, secondsToHms, shortenLabel, strengthenImageUrl, timeAgo, truncateId, truncateSignificantDigits, truncateString };

package/dist/utils/index.js

@@ -0,0 +1,5 @@
+export { ATOM_TYPES, calculateMatchScore, formatAtomType, formatStake, formatTermId, getAtomDescription, getAtomDisplayName, getAtomImage, getAtomType, highlightMatch, isEntityType, isPlainTextType, isPredicateType, isRawDataType, rankAtoms } from '../chunk-H4RMZQ2Z.js';
+export { capitalize, capitalizeFirstLetter, ellipsizeHex, ellipsizeString, formatCompact, formatCryptoAmount, ipfsToHttp, secondsToDhms, secondsToHms, shortenLabel, strengthenImageUrl, timeAgo, truncateId, truncateSignificantDigits, truncateString } from '../chunk-ERZSVDIB.js';
+export { cn } from '../chunk-VIRNUAYY.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@hivemindhq/core",
+  "version": "0.4.0",
+  "description": "Shared components, utilities, and types for hivemindhq applications",
+  "author": "Kylan Hurt <kylan@hivemindhq.io>",
+  "license": "ISC",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils/index.d.ts",
+      "import": "./dist/utils/index.js"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.ts",
+      "import": "./dist/hooks/index.js"
+    },
+    "./components/ui": {
+      "types": "./dist/components/ui/index.d.ts",
+      "import": "./dist/components/ui/index.js"
+    },
+    "./components": {
+      "types": "./dist/components/index.d.ts",
+      "import": "./dist/components/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "tailwind.config.js"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm run build"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0",
+    "tailwindcss": "^3.0.0 || ^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "tailwindcss": {
+      "optional": true
+    }
+  },
+  "dependencies": {
+    "@hookform/resolvers": "^3.0.0 || ^4.0.0 || ^5.0.0",
+    "@radix-ui/react-avatar": "^1.1.0",
+    "@radix-ui/react-checkbox": "^1.1.0",
+    "@radix-ui/react-collapsible": "^1.1.0",
+    "@radix-ui/react-dialog": "^1.1.0",
+    "@radix-ui/react-dropdown-menu": "^2.1.16",
+    "@radix-ui/react-label": "^2.1.0",
+    "@radix-ui/react-popover": "^1.1.0",
+    "@radix-ui/react-progress": "^1.1.0",
+    "@radix-ui/react-radio-group": "^1.2.0",
+    "@radix-ui/react-scroll-area": "^1.2.0",
+    "@radix-ui/react-select": "^2.1.0",
+    "@radix-ui/react-separator": "^1.1.0",
+    "@radix-ui/react-slot": "^1.1.0",
+    "@radix-ui/react-switch": "^1.1.0",
+    "@radix-ui/react-tabs": "^1.1.0",
+    "@radix-ui/react-toast": "^1.2.0",
+    "@radix-ui/react-toggle": "^1.1.0",
+    "@radix-ui/react-toggle-group": "^1.1.0",
+    "@radix-ui/react-tooltip": "^1.1.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.1.0",
+    "cmdk": "^1.0.0",
+    "embla-carousel-react": "^8.0.0",
+    "lucide-react": "^0.400.0",
+    "next-themes": "^0.3.0 || ^0.4.0",
+    "react-hook-form": "^7.50.0",
+    "recharts": "^2.10.0",
+    "sonner": "^1.5.0 || ^2.0.0",
+    "tailwind-merge": "^2.5.0 || ^3.0.0",
+    "zod": "^3.22.0 || ^4.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0 || ^19.0.0",
+    "@types/react-dom": "^18.0.0 || ^19.0.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "keywords": [
+    "hive mind",
+    "hivemind",
+    "intuition",
+    "web3",
+    "components",
+    "react"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hivemindhq-io/core.git"
+  }
+}