android dev

This commit is contained in:
babayaga 2025-09-22 22:26:57 +02:00
parent 3da0bc0d3a
commit 649c91ec35
73 changed files with 8113 additions and 1314 deletions

BIN
packages/kbot/cat_gen_0.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.2 MiB

Binary file not shown.

File diff suppressed because it is too large Load Diff

View File

@ -12,6 +12,33 @@
},
"dependencies": {
"@google/generative-ai": "^0.24.1",
"@radix-ui/react-accordion": "^1.2.0",
"@radix-ui/react-alert-dialog": "^1.1.1",
"@radix-ui/react-aspect-ratio": "^1.1.0",
"@radix-ui/react-avatar": "^1.1.0",
"@radix-ui/react-checkbox": "^1.1.1",
"@radix-ui/react-collapsible": "^1.1.0",
"@radix-ui/react-context-menu": "^2.2.1",
"@radix-ui/react-dialog": "^1.1.2",
"@radix-ui/react-dropdown-menu": "^2.1.1",
"@radix-ui/react-hover-card": "^1.1.1",
"@radix-ui/react-label": "^2.1.0",
"@radix-ui/react-menubar": "^1.1.1",
"@radix-ui/react-navigation-menu": "^1.2.0",
"@radix-ui/react-popover": "^1.1.1",
"@radix-ui/react-progress": "^1.1.0",
"@radix-ui/react-radio-group": "^1.2.0",
"@radix-ui/react-scroll-area": "^1.1.0",
"@radix-ui/react-select": "^2.1.1",
"@radix-ui/react-separator": "^1.1.0",
"@radix-ui/react-slider": "^1.2.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.1",
"@radix-ui/react-toggle": "^1.1.0",
"@radix-ui/react-toggle-group": "^1.1.0",
"@radix-ui/react-tooltip": "^1.1.4",
"@tailwindcss/vite": "^4.1.13",
"@tauri-apps/api": "^2.8.0",
"@tauri-apps/cli": "^2.8.4",
@ -34,12 +61,24 @@
"@tauri-apps/plugin-store": "^2.4.0",
"@tauri-apps/plugin-updater": "^2.9.0",
"@tauri-apps/plugin-upload": "^2.3.0",
"class-variance-authority": "^0.7.1",
"clsx": "^2.1.1",
"cmdk": "^1.1.1",
"input-otp": "^1.4.2",
"lucide-react": "^0.544.0",
"mime-types": "^2.1.35",
"next-themes": "^0.4.6",
"p-map": "^7.0.3",
"react": "^19.1.0",
"react-dom": "^19.1.0",
"react-hook-form": "^7.63.0",
"react-resizable-panels": "^2.1.3",
"react-router-dom": "^7.9.1",
"react-terminal": "^1.4.5",
"react-zoom-pan-pinch": "^3.7.0"
"react-zoom-pan-pinch": "^3.7.0",
"sonner": "^2.0.7",
"tailwind-merge": "^2.5.2",
"vaul": "^1.1.2"
},
"devDependencies": {
"@tailwindcss/postcss": "^4.1.13",

View File

@ -0,0 +1,7 @@
up to date, audited 333 packages in 1s
38 packages are looking for funding
run `npm fund` for details
found 0 vulnerabilities

View File

@ -5331,6 +5331,7 @@ dependencies = [
"tauri-plugin-log",
"tauri-plugin-notification",
"tauri-plugin-opener",
"tauri-plugin-os",
"tauri-plugin-process",
"tauri-plugin-shell",
"tauri-plugin-store",
@ -5601,6 +5602,24 @@ dependencies = [
"zbus",
]
[[package]]
name = "tauri-plugin-os"
version = "2.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77a1c77ebf6f20417ab2a74e8c310820ba52151406d0c80fbcea7df232e3f6ba"
dependencies = [
"gethostname",
"log",
"os_info",
"serde",
"serde_json",
"serialize-to-javascript",
"sys-locale",
"tauri",
"tauri-plugin",
"thiserror 2.0.16",
]
[[package]]
name = "tauri-plugin-process"
version = "2.3.0"

View File

@ -36,6 +36,7 @@ image = "0.25.8"
glob = "0.3.3"
tauri-plugin-notification = "2.3.1"
log = "0.4"
tauri-plugin-os = "2"
# Desktop-only dependencies (these may cause OpenSSL issues on Android)
[target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]

View File

@ -102,6 +102,7 @@
"path": "$APPDATA/**"
}
]
}
},
"os:default"
]
}

View File

@ -33,11 +33,7 @@ fn save_rgba_image_to_temp(
return Err(error_message.into());
};
let file_name = format!(
"kbot_clipboard_{}.{}",
nanoid::nanoid!(),
candidate_format
);
let file_name = format!("kbot_clipboard_{}.{}", nanoid::nanoid!(), candidate_format);
let temp_path = temp_dir.join(file_name);
img_buffer.save_with_format(
@ -71,7 +67,7 @@ async fn parse_clipboard_images(
}
Err(e) => {
info!("[parse_clipboard_images] No image data found: {}", e);
// Try to get file list (drag and drop from explorer/finder)
match clipboard.get().file_list() {
Ok(file_list) => {
@ -79,11 +75,12 @@ async fn parse_clipboard_images(
for file in file_list {
let path_str = file.to_string_lossy().to_string();
// Filter for image files only
if path_str.to_lowercase().ends_with(".png")
if path_str.to_lowercase().ends_with(".png")
|| path_str.to_lowercase().ends_with(".jpg")
|| path_str.to_lowercase().ends_with(".jpeg")
|| path_str.to_lowercase().ends_with(".gif")
|| path_str.to_lowercase().ends_with(".webp") {
|| path_str.to_lowercase().ends_with(".webp")
{
result.push(path_str);
}
}

View File

@ -1,222 +1,260 @@
use tauri::{Manager, Emitter};
use serde::{Serialize, Deserialize};
use dirs;
use crate::{log_json, Counter, DebugMessages, DebugPayload};
#[derive(Serialize, Deserialize)]
pub struct Payload {
pub prompt: String,
pub files: Vec<String>,
pub dst: String,
}
#[derive(Serialize, Deserialize)]
pub struct IPCMessage {
#[serde(rename = "type")]
pub message_type: String,
pub data: serde_json::Value,
pub timestamp: Option<u64>,
pub id: Option<String>,
}
// Core command handlers
#[tauri::command]
pub fn submit_prompt(prompt: &str, files: Vec<String>, dst: &str, window: tauri::Window) {
log_json("info", "submit_prompt command called", Some(serde_json::json!({
"prompt": prompt,
"files": files,
"dst": dst
})));
let payload = Payload {
prompt: prompt.to_string(),
files,
dst: dst.to_string(),
};
let json_payload = serde_json::to_string(&payload).unwrap();
log_json("info", "Sending JSON payload to stdout", Some(serde_json::json!({
"payload_length": json_payload.len()
})));
println!("{}", json_payload);
let _ = window.app_handle().exit(0);
}
#[tauri::command]
pub fn log_error_to_console(error: &str) {
eprintln!("[WebView ERROR forwarded]: {}", error);
}
#[tauri::command]
pub fn resolve_path_relative_to_home(absolute_path: String) -> Result<String, String> {
let home_dir = dirs::home_dir().ok_or_else(|| "Could not find home directory".to_string())?;
let path_to_resolve = std::path::Path::new(&absolute_path);
let relative_path = pathdiff::diff_paths(path_to_resolve, home_dir)
.ok_or_else(|| "Failed to calculate relative path from home directory".to_string())?;
Ok(relative_path.to_string_lossy().to_string())
}
// Debug message handlers
#[tauri::command]
pub fn add_debug_message(message: String, level: String, data: Option<serde_json::Value>, state: tauri::State<'_, DebugMessages>) -> Result<(), String> {
log_json(&level, &format!("Frontend: {}", message), data.clone());
let debug_payload = DebugPayload {
level,
message,
data,
};
let mut messages = state.0.lock().unwrap();
messages.push(debug_payload);
if messages.len() > 100 {
let len = messages.len();
messages.drain(0..len - 100);
}
Ok(())
}
#[tauri::command]
pub fn get_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result<Vec<DebugPayload>, String> {
let messages = state.0.lock().unwrap();
Ok(messages.clone())
}
#[tauri::command]
pub fn clear_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result<(), String> {
let mut messages = state.0.lock().unwrap();
messages.clear();
Ok(())
}
// Counter handlers (legacy)
#[tauri::command]
pub fn increment_counter(state: tauri::State<'_, Counter>) -> Result<u32, String> {
let mut counter = state.0.lock().unwrap();
*counter += 1;
Ok(*counter)
}
#[tauri::command]
pub fn get_counter(state: tauri::State<'_, Counter>) -> Result<u32, String> {
let counter = state.0.lock().unwrap();
Ok(*counter)
}
#[tauri::command]
pub fn reset_counter(state: tauri::State<'_, Counter>) -> Result<u32, String> {
let mut counter = state.0.lock().unwrap();
*counter = 0;
Ok(0)
}
// IPC communication handlers
#[tauri::command]
pub fn send_ipc_message(message_type: String, data: serde_json::Value, _window: tauri::Window) -> Result<(), String> {
let ipc_message = IPCMessage {
message_type,
data,
timestamp: Some(std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis() as u64),
id: Some(format!("msg_{}_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis(),
rand::random::<u32>())),
};
let json_message = serde_json::to_string(&ipc_message).unwrap();
println!("{}", json_message);
Ok(())
}
#[tauri::command]
pub fn send_message_to_stdout(message: String) -> Result<(), String> {
println!("{}", message);
Ok(())
}
// Image generation handlers
#[tauri::command]
pub fn generate_image_via_backend(prompt: String, files: Vec<String>, dst: String) -> Result<(), String> {
let request = serde_json::json!({
"type": "generate_request",
"prompt": prompt,
"files": files,
"dst": dst,
"timestamp": std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis()
});
println!("{}", serde_json::to_string(&request).unwrap());
Ok(())
}
#[tauri::command]
pub fn request_config_from_images(_app: tauri::AppHandle) -> Result<(), String> {
let request = serde_json::json!({
"type": "config_request",
"timestamp": std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis()
});
println!("{}", serde_json::to_string(&request).unwrap());
Ok(())
}
#[tauri::command]
pub fn request_file_deletion(path: String) -> Result<(), String> {
let request = serde_json::json!({
"type": "delete_request",
"path": path,
});
println!("{}", serde_json::to_string(&request).unwrap());
Ok(())
}
// Legacy direct handlers (not used via stdin)
#[tauri::command]
pub fn forward_config_to_frontend(prompt: Option<String>, dst: Option<String>, api_key: Option<String>, files: Vec<String>, app: tauri::AppHandle) -> Result<(), String> {
let config_data = serde_json::json!({
"prompt": prompt,
"dst": dst,
"apiKey": api_key,
"files": files
});
if let Err(e) = app.emit("config-received", &config_data) {
return Err(format!("Failed to emit config: {}", e));
}
Ok(())
}
#[tauri::command]
pub fn forward_image_to_frontend(base64: String, mime_type: String, filename: String, app: tauri::AppHandle) -> Result<(), String> {
let image_data = serde_json::json!({
"base64": base64,
"mimeType": mime_type,
"filename": filename
});
if let Err(e) = app.emit("image-received", &image_data) {
return Err(format!("Failed to emit image: {}", e));
}
Ok(())
}
use dirs;
use serde::{Deserialize, Serialize};
use tauri::{Emitter, Manager};
use crate::{log_json, Counter, DebugMessages, DebugPayload};
#[derive(Serialize, Deserialize)]
pub struct Payload {
pub prompt: String,
pub files: Vec<String>,
pub dst: String,
}
#[derive(Serialize, Deserialize)]
pub struct IPCMessage {
#[serde(rename = "type")]
pub message_type: String,
pub data: serde_json::Value,
pub timestamp: Option<u64>,
pub id: Option<String>,
}
// Core command handlers
#[tauri::command]
pub fn submit_prompt(prompt: &str, files: Vec<String>, dst: &str, window: tauri::Window) {
log_json(
"info",
"submit_prompt command called",
Some(serde_json::json!({
"prompt": prompt,
"files": files,
"dst": dst
})),
);
let payload = Payload {
prompt: prompt.to_string(),
files,
dst: dst.to_string(),
};
let json_payload = serde_json::to_string(&payload).unwrap();
log_json(
"info",
"Sending JSON payload to stdout",
Some(serde_json::json!({
"payload_length": json_payload.len()
})),
);
println!("{}", json_payload);
let _ = window.app_handle().exit(0);
}
#[tauri::command]
pub fn log_error_to_console(error: &str) {
eprintln!("[WebView ERROR forwarded]: {}", error);
}
#[tauri::command]
pub fn resolve_path_relative_to_home(absolute_path: String) -> Result<String, String> {
let home_dir = dirs::home_dir().ok_or_else(|| "Could not find home directory".to_string())?;
let path_to_resolve = std::path::Path::new(&absolute_path);
let relative_path = pathdiff::diff_paths(path_to_resolve, home_dir)
.ok_or_else(|| "Failed to calculate relative path from home directory".to_string())?;
Ok(relative_path.to_string_lossy().to_string())
}
// Debug message handlers
#[tauri::command]
pub fn add_debug_message(
message: String,
level: String,
data: Option<serde_json::Value>,
state: tauri::State<'_, DebugMessages>,
) -> Result<(), String> {
log_json(&level, &format!("Frontend: {}", message), data.clone());
let debug_payload = DebugPayload {
level,
message,
data,
};
let mut messages = state.0.lock().unwrap();
messages.push(debug_payload);
if messages.len() > 100 {
let len = messages.len();
messages.drain(0..len - 100);
}
Ok(())
}
#[tauri::command]
pub fn get_debug_messages(
state: tauri::State<'_, DebugMessages>,
) -> Result<Vec<DebugPayload>, String> {
let messages = state.0.lock().unwrap();
Ok(messages.clone())
}
#[tauri::command]
pub fn clear_debug_messages(state: tauri::State<'_, DebugMessages>) -> Result<(), String> {
let mut messages = state.0.lock().unwrap();
messages.clear();
Ok(())
}
// Counter handlers (legacy)
#[tauri::command]
pub fn increment_counter(state: tauri::State<'_, Counter>) -> Result<u32, String> {
let mut counter = state.0.lock().unwrap();
*counter += 1;
Ok(*counter)
}
#[tauri::command]
pub fn get_counter(state: tauri::State<'_, Counter>) -> Result<u32, String> {
let counter = state.0.lock().unwrap();
Ok(*counter)
}
#[tauri::command]
pub fn reset_counter(state: tauri::State<'_, Counter>) -> Result<u32, String> {
let mut counter = state.0.lock().unwrap();
*counter = 0;
Ok(0)
}
// IPC communication handlers
#[tauri::command]
pub fn send_ipc_message(
message_type: String,
data: serde_json::Value,
_window: tauri::Window,
) -> Result<(), String> {
let ipc_message = IPCMessage {
message_type,
data,
timestamp: Some(
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis() as u64,
),
id: Some(format!(
"msg_{}_{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis(),
rand::random::<u32>()
)),
};
let json_message = serde_json::to_string(&ipc_message).unwrap();
println!("{}", json_message);
Ok(())
}
#[tauri::command]
pub fn send_message_to_stdout(message: String) -> Result<(), String> {
println!("{}", message);
Ok(())
}
// Image generation handlers
#[tauri::command]
pub fn generate_image_via_backend(
prompt: String,
files: Vec<String>,
dst: String,
) -> Result<(), String> {
let request = serde_json::json!({
"type": "generate_request",
"prompt": prompt,
"files": files,
"dst": dst,
"timestamp": std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis()
});
println!("{}", serde_json::to_string(&request).unwrap());
Ok(())
}
#[tauri::command]
pub fn request_config_from_images(_app: tauri::AppHandle) -> Result<(), String> {
let request = serde_json::json!({
"type": "config_request",
"timestamp": std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_millis()
});
println!("{}", serde_json::to_string(&request).unwrap());
Ok(())
}
#[tauri::command]
pub fn request_file_deletion(path: String) -> Result<(), String> {
let request = serde_json::json!({
"type": "delete_request",
"path": path,
});
println!("{}", serde_json::to_string(&request).unwrap());
Ok(())
}
// Legacy direct handlers (not used via stdin)
#[tauri::command]
pub fn forward_config_to_frontend(
prompt: Option<String>,
dst: Option<String>,
api_key: Option<String>,
files: Vec<String>,
app: tauri::AppHandle,
) -> Result<(), String> {
let config_data = serde_json::json!({
"prompt": prompt,
"dst": dst,
"apiKey": api_key,
"files": files
});
if let Err(e) = app.emit("config-received", &config_data) {
return Err(format!("Failed to emit config: {}", e));
}
Ok(())
}
#[tauri::command]
pub fn forward_image_to_frontend(
base64: String,
mime_type: String,
filename: String,
app: tauri::AppHandle,
) -> Result<(), String> {
let image_data = serde_json::json!({
"base64": base64,
"mimeType": mime_type,
"filename": filename
});
if let Err(e) = app.emit("image-received", &image_data) {
return Err(format!("Failed to emit image: {}", e));
}
Ok(())
}

View File

@ -1,11 +1,11 @@
use serde::{Serialize, Deserialize};
use serde::{Deserialize, Serialize};
mod handlers;
mod stdin_processor;
// Desktop-only modules
#[cfg(not(any(target_os = "android", target_os = "ios")))]
mod clipboard;
use tauri::Manager;
use tauri::Manager;
pub use handlers::*;
@ -32,7 +32,12 @@ pub fn log_json(level: &str, message: &str, data: Option<serde_json::Value>) {
.unwrap()
.as_millis() as u64,
};
eprintln!("{}", serde_json::to_string(&log_msg).unwrap_or_else(|_| format!("{{\"level\":\"error\",\"message\":\"Failed to serialize log message\"}}")));
eprintln!(
"{}",
serde_json::to_string(&log_msg).unwrap_or_else(|_| format!(
"{{\"level\":\"error\",\"message\":\"Failed to serialize log message\"}}"
))
);
}
// App state structures
@ -46,17 +51,17 @@ pub struct DebugPayload {
pub data: Option<serde_json::Value>,
}
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
let mut builder = tauri::Builder::default()
.plugin(tauri_plugin_os::init())
.manage(Counter(std::sync::Mutex::new(0)))
.manage(DebugMessages(std::sync::Mutex::new(Vec::new())))
.plugin(tauri_plugin_opener::init())
.plugin(tauri_plugin_dialog::init())
.plugin(tauri_plugin_fs::init())
.plugin(tauri_plugin_http::init());
// Desktop-only plugins
#[cfg(not(any(target_os = "android", target_os = "ios")))]
{
@ -66,65 +71,63 @@ pub fn run() {
.plugin(tauri_plugin_upload::init())
.plugin(tauri_plugin_clipboard_manager::init());
}
// Desktop invoke handlers (includes clipboard functions)
#[cfg(not(any(target_os = "android", target_os = "ios")))]
let app = builder
.invoke_handler(tauri::generate_handler![
submit_prompt,
log_error_to_console,
resolve_path_relative_to_home,
increment_counter,
get_counter,
reset_counter,
add_debug_message,
get_debug_messages,
clear_debug_messages,
send_message_to_stdout,
send_ipc_message,
request_config_from_images,
forward_config_to_frontend,
forward_image_to_frontend,
generate_image_via_backend,
request_file_deletion,
ipc_parse_clipboard_images
]);
let app = builder.invoke_handler(tauri::generate_handler![
submit_prompt,
log_error_to_console,
resolve_path_relative_to_home,
increment_counter,
get_counter,
reset_counter,
add_debug_message,
get_debug_messages,
clear_debug_messages,
send_message_to_stdout,
send_ipc_message,
request_config_from_images,
forward_config_to_frontend,
forward_image_to_frontend,
generate_image_via_backend,
request_file_deletion,
ipc_parse_clipboard_images
]);
// Mobile invoke handlers (no clipboard functions)
#[cfg(any(target_os = "android", target_os = "ios"))]
let app = builder
.invoke_handler(tauri::generate_handler![
submit_prompt,
log_error_to_console,
resolve_path_relative_to_home,
increment_counter,
get_counter,
reset_counter,
add_debug_message,
get_debug_messages,
clear_debug_messages,
send_message_to_stdout,
send_ipc_message,
request_config_from_images,
forward_config_to_frontend,
forward_image_to_frontend,
generate_image_via_backend,
request_file_deletion
]);
let app = builder.invoke_handler(tauri::generate_handler![
submit_prompt,
log_error_to_console,
resolve_path_relative_to_home,
increment_counter,
get_counter,
reset_counter,
add_debug_message,
get_debug_messages,
clear_debug_messages,
send_message_to_stdout,
send_ipc_message,
request_config_from_images,
forward_config_to_frontend,
forward_image_to_frontend,
generate_image_via_backend,
request_file_deletion
]);
let app = app
.setup(|app| {
#[cfg(debug_assertions)] // only include this code on debug builds
{
let window = app.get_webview_window("main").unwrap();
window.open_devtools();
let window = app.get_webview_window("main").unwrap();
window.open_devtools();
}
let app_handle = app.handle().clone();
// Start stdin listener in separate module
stdin_processor::start_stdin_listener(app_handle);
Ok(())
})
.build(tauri::generate_context!())

View File

@ -1,7 +1,6 @@
// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
fn main() {
tauri_app_lib::run()
}
// Prevents additional console window on Windows in release, DO NOT REMOVE!!
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
fn main() {
tauri_app_lib::run()
}

View File

@ -1,147 +1,210 @@
use tauri::Emitter;
use std::io::{BufRead, BufReader};
use crate::log_json;
pub fn start_stdin_listener(app_handle: tauri::AppHandle) {
std::thread::spawn(move || {
let stdin = std::io::stdin();
let reader = BufReader::new(stdin);
for line in reader.lines() {
if let Ok(line_content) = line {
if line_content.trim().is_empty() {
continue;
}
// Parse command from images.ts
if let Ok(command) = serde_json::from_str::<serde_json::Value>(&line_content) {
if let Some(cmd) = command.get("cmd").and_then(|v| v.as_str()) {
match cmd {
"forward_config_to_frontend" => {
handle_config_forward(&command, &app_handle);
}
"forward_image_to_frontend" => {
handle_image_forward(&command, &app_handle);
}
"generation_result" => {
if let Err(e) = app_handle.emit("generation-result", &command) {
log_json("error", "Failed to emit generation-result", Some(serde_json::json!({
"error": e.to_string()
})));
}
}
"generation_error" => {
if let Err(e) = app_handle.emit("generation-error", &command) {
log_json("error", "Failed to emit generation-error", Some(serde_json::json!({
"error": e.to_string()
})));
}
}
"generation_complete" => {
if let Err(e) = app_handle.emit("generation-complete", &command) {
log_json("error", "Failed to emit generation-complete", Some(serde_json::json!({
"error": e.to_string()
})));
}
}
"file_deleted_successfully" => {
if let Some(path) = command.get("path").and_then(|v| v.as_str()) {
if let Err(e) = app_handle.emit("file-deleted-successfully", &serde_json::json!({ "path": path })) {
log_json("error", "Failed to emit file-deleted-successfully", Some(serde_json::json!({
"error": e.to_string()
})));
}
}
}
"file_deletion_error" => {
if let (Some(path), Some(error)) = (
command.get("path").and_then(|v| v.as_str()),
command.get("error").and_then(|v| v.as_str())
) {
if let Err(e) = app_handle.emit("file-deletion-error", &serde_json::json!({ "path": path, "error": error })) {
log_json("error", "Failed to emit file-deletion-error", Some(serde_json::json!({
"error": e.to_string()
})));
}
}
}
_ => {
log_json("warn", "Unknown command received", Some(serde_json::json!({
"command": cmd
})));
}
}
}
} else {
log_json("warn", "Failed to parse stdin as JSON", Some(serde_json::json!({
"content_length": line_content.len()
})));
}
}
}
log_json("info", "Stdin listener thread ended", None);
});
}
fn handle_config_forward(command: &serde_json::Value, app_handle: &tauri::AppHandle) {
log_json("info", "Forwarding config to frontend", Some(serde_json::json!({
"has_prompt": command.get("prompt").is_some(),
"has_dst": command.get("dst").is_some(),
"has_api_key": command.get("apiKey").is_some(),
"file_count": command.get("files").and_then(|f| f.as_array()).map(|a| a.len()).unwrap_or(0)
})));
// Extract values, handling both null and undefined
let prompt = command.get("prompt")
.and_then(|v| if v.is_null() { None } else { v.as_str().map(|s| s.to_string()) });
let dst = command.get("dst")
.and_then(|v| if v.is_null() { None } else { v.as_str().map(|s| s.to_string()) });
let api_key = command.get("apiKey")
.and_then(|v| if v.is_null() { None } else { v.as_str().map(|s| s.to_string()) });
let files = command.get("files")
.and_then(|v| v.as_array())
.map(|arr| arr.iter().filter_map(|f| f.as_str().map(|s| s.to_string())).collect::<Vec<String>>())
.unwrap_or_else(Vec::new);
let config_data = serde_json::json!({
"prompt": prompt,
"dst": dst,
"apiKey": api_key,
"files": files
});
if let Err(e) = app_handle.emit("config-received", &config_data) {
log_json("error", "Failed to emit config-received", Some(serde_json::json!({
"error": e.to_string()
})));
} else {
log_json("info", "Config emitted successfully to frontend", None);
}
}
fn handle_image_forward(command: &serde_json::Value, app_handle: &tauri::AppHandle) {
if let (Some(filename), Some(base64), Some(mime_type)) = (
command.get("filename").and_then(|v| v.as_str()),
command.get("base64").and_then(|v| v.as_str()),
command.get("mimeType").and_then(|v| v.as_str())
) {
let image_data = serde_json::json!({
"base64": base64,
"mimeType": mime_type,
"filename": filename
});
if let Err(e) = app_handle.emit("image-received", &image_data) {
log_json("error", "Failed to emit image-received", Some(serde_json::json!({
"error": e.to_string(),
"filename": filename
})));
} else {
}
}
}
use std::io::{BufRead, BufReader};
use tauri::Emitter;
use crate::log_json;
pub fn start_stdin_listener(app_handle: tauri::AppHandle) {
std::thread::spawn(move || {
let stdin = std::io::stdin();
let reader = BufReader::new(stdin);
for line in reader.lines() {
if let Ok(line_content) = line {
if line_content.trim().is_empty() {
continue;
}
// Parse command from images.ts
if let Ok(command) = serde_json::from_str::<serde_json::Value>(&line_content) {
if let Some(cmd) = command.get("cmd").and_then(|v| v.as_str()) {
match cmd {
"forward_config_to_frontend" => {
handle_config_forward(&command, &app_handle);
}
"forward_image_to_frontend" => {
handle_image_forward(&command, &app_handle);
}
"generation_result" => {
if let Err(e) = app_handle.emit("generation-result", &command) {
log_json(
"error",
"Failed to emit generation-result",
Some(serde_json::json!({
"error": e.to_string()
})),
);
}
}
"generation_error" => {
if let Err(e) = app_handle.emit("generation-error", &command) {
log_json(
"error",
"Failed to emit generation-error",
Some(serde_json::json!({
"error": e.to_string()
})),
);
}
}
"generation_complete" => {
if let Err(e) = app_handle.emit("generation-complete", &command) {
log_json(
"error",
"Failed to emit generation-complete",
Some(serde_json::json!({
"error": e.to_string()
})),
);
}
}
"file_deleted_successfully" => {
if let Some(path) = command.get("path").and_then(|v| v.as_str()) {
if let Err(e) = app_handle.emit(
"file-deleted-successfully",
&serde_json::json!({ "path": path }),
) {
log_json(
"error",
"Failed to emit file-deleted-successfully",
Some(serde_json::json!({
"error": e.to_string()
})),
);
}
}
}
"file_deletion_error" => {
if let (Some(path), Some(error)) = (
command.get("path").and_then(|v| v.as_str()),
command.get("error").and_then(|v| v.as_str()),
) {
if let Err(e) = app_handle.emit(
"file-deletion-error",
&serde_json::json!({ "path": path, "error": error }),
) {
log_json(
"error",
"Failed to emit file-deletion-error",
Some(serde_json::json!({
"error": e.to_string()
})),
);
}
}
}
_ => {
log_json(
"warn",
"Unknown command received",
Some(serde_json::json!({
"command": cmd
})),
);
}
}
}
} else {
log_json(
"warn",
"Failed to parse stdin as JSON",
Some(serde_json::json!({
"content_length": line_content.len()
})),
);
}
}
}
log_json("info", "Stdin listener thread ended", None);
});
}
fn handle_config_forward(command: &serde_json::Value, app_handle: &tauri::AppHandle) {
log_json(
"info",
"Forwarding config to frontend",
Some(serde_json::json!({
"has_prompt": command.get("prompt").is_some(),
"has_dst": command.get("dst").is_some(),
"has_api_key": command.get("apiKey").is_some(),
"file_count": command.get("files").and_then(|f| f.as_array()).map(|a| a.len()).unwrap_or(0)
})),
);
// Extract values, handling both null and undefined
let prompt = command.get("prompt").and_then(|v| {
if v.is_null() {
None
} else {
v.as_str().map(|s| s.to_string())
}
});
let dst = command.get("dst").and_then(|v| {
if v.is_null() {
None
} else {
v.as_str().map(|s| s.to_string())
}
});
let api_key = command.get("apiKey").and_then(|v| {
if v.is_null() {
None
} else {
v.as_str().map(|s| s.to_string())
}
});
let files = command
.get("files")
.and_then(|v| v.as_array())
.map(|arr| {
arr.iter()
.filter_map(|f| f.as_str().map(|s| s.to_string()))
.collect::<Vec<String>>()
})
.unwrap_or_else(Vec::new);
let config_data = serde_json::json!({
"prompt": prompt,
"dst": dst,
"apiKey": api_key,
"files": files
});
if let Err(e) = app_handle.emit("config-received", &config_data) {
log_json(
"error",
"Failed to emit config-received",
Some(serde_json::json!({
"error": e.to_string()
})),
);
} else {
log_json("info", "Config emitted successfully to frontend", None);
}
}
fn handle_image_forward(command: &serde_json::Value, app_handle: &tauri::AppHandle) {
if let (Some(filename), Some(base64), Some(mime_type)) = (
command.get("filename").and_then(|v| v.as_str()),
command.get("base64").and_then(|v| v.as_str()),
command.get("mimeType").and_then(|v| v.as_str()),
) {
let image_data = serde_json::json!({
"base64": base64,
"mimeType": mime_type,
"filename": filename
});
if let Err(e) = app_handle.emit("image-received", &image_data) {
log_json(
"error",
"Failed to emit image-received",
Some(serde_json::json!({
"error": e.to_string(),
"filename": filename
})),
);
} else {
}
}
}

View File

@ -1,553 +1,11 @@
import { useState, useEffect } from "react";
import { ImageFile, PromptTemplate } from "./types";
import { useTauriListeners } from "./hooks/useTauriListeners";
import { tauriApi } from "./lib/tauriApi";
import { saveToStore } from "./lib/init";
import { QUICK_STYLES, QUICK_ACTIONS } from "./constants";
import log from "./lib/log";
import Header from "./components/Header";
import PromptForm from "./components/PromptForm";
import DebugPanel from "./components/DebugPanel";
function arrayBufferToBase64(buffer: number[]) {
let binary = '';
const bytes = new Uint8Array(buffer);
const len = bytes.byteLength;
for (let i = 0; i < len; i++) {
binary += String.fromCharCode(bytes[i]);
}
return window.btoa(binary);
}
import { BrowserRouter as Router, Routes, Route } from "react-router-dom";
import ImageWizard from "./components/ImageWizard";
import Settings from "./components/Settings";
function App() {
const [prompt, setPrompt] = useState("");
const [files, setFiles] = useState<ImageFile[]>([]);
const [dst, setDst] = useState("");
const [isGenerating, setIsGenerating] = useState(false);
const [apiKey, setApiKey] = useState("");
const [isDarkMode, setIsDarkMode] = useState(false);
const [debugMessages, setDebugMessages] = useState<any[]>([]);
const [showDebugPanel, setShowDebugPanel] = useState(false); // Hidden in production
const [errorMessage, setErrorMessage] = useState<string | null>(null);
// Initialize logging system and connect to UI
useEffect(() => {
log.setMessageCallback((message) => {
setDebugMessages(prev => [...prev.slice(-99), message]); // Keep last 100 messages
});
// Load existing messages
setDebugMessages(log.getLocalMessages());
}, []);
const [ipcInitialized, setIpcInitialized] = useState(false);
const [messageToSend, setMessageToSend] = useState("");
const [generationTimeoutId, setGenerationTimeoutId] = useState<NodeJS.Timeout | null>(null);
const [currentIndex, setCurrentIndex] = useState(0);
const [prompts, setPrompts] = useState<PromptTemplate[]>([]);
const [promptHistory, setPromptHistory] = useState<string[]>([]);
const [historyIndex, setHistoryIndex] = useState(-1);
const [fileHistory, setFileHistory] = useState<string[]>([]);
// Debug wrapper for setFileHistory
const setFileHistoryWithLogging = (history: string[]) => {
log.debug(`🔧 setFileHistory called with ${history.length} files`, {
files: history.map(f => f.split(/[/\\]/).pop())
});
setFileHistory(history);
};
const [showFileHistory, setShowFileHistory] = useState(false);
const appendStyle = (style: string) => {
setPrompt(prev => {
const trimmed = prev.trim();
// Remove any existing styles from QUICK_STYLES
let cleanPrompt = trimmed;
QUICK_STYLES.forEach(existingStyle => {
// Remove style if it exists (with or without comma)
const patterns = [
new RegExp(`,\\s*${existingStyle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*`, 'gi'),
new RegExp(`^${existingStyle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*,?\\s*`, 'gi'),
new RegExp(`\\s*,\\s*${existingStyle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'gi')
];
patterns.forEach(pattern => {
cleanPrompt = cleanPrompt.replace(pattern, '');
});
});
// Clean up any double commas or trailing/leading commas
cleanPrompt = cleanPrompt.replace(/,\s*,/g, ',').replace(/^,\s*|,\s*$/g, '').trim();
// Add the new style
if (cleanPrompt) {
return `${cleanPrompt}, ${style}`;
} else {
return style;
}
});
log.info(`🎨 Style replaced with: ${style}`);
};
const executeQuickAction = async (action: { name: string; prompt: string; iconName: string }) => {
const selectedImages = getSelectedImages();
if (selectedImages.length === 0) {
log.warn('Please select an image first to use quick actions');
return;
}
// Use the first selected image
const targetImage = selectedImages[0];
// Set the action prompt
setPrompt(action.prompt);
// Generate with the selected image
log.info(`🚀 Executing quick action: ${action.name} on selected image ${targetImage.path}`);
await generateImage(action.prompt, [targetImage]);
};
const addToHistory = async (promptText: string) => {
if (promptText.trim() && !promptHistory.includes(promptText.trim())) {
const newHistory = [...promptHistory, promptText.trim()];
setPromptHistory(newHistory);
setHistoryIndex(-1); // Reset to end of history
log.info(`📝 Added to history: "${promptText.substring(0, 50)}..."`);
// Auto-save to store
try {
await saveToStore({ history: newHistory });
log.info('💾 History saved to store');
} catch (error) {
log.error('Failed to save history', { error: (error as Error).message });
}
}
};
const navigateHistory = (direction: 'up' | 'down') => {
if (promptHistory.length === 0) return;
let newIndex = historyIndex;
if (direction === 'up') {
newIndex = historyIndex === -1 ? promptHistory.length - 1 : Math.max(0, historyIndex - 1);
} else {
newIndex = historyIndex === -1 ? -1 : historyIndex + 1;
if (newIndex >= promptHistory.length) newIndex = -1;
}
setHistoryIndex(newIndex);
if (newIndex === -1) {
setPrompt('');
} else {
setPrompt(promptHistory[newIndex]);
log.info(`📜 History: ${newIndex + 1}/${promptHistory.length}`);
}
};
const addToFileHistory = async (filePath: string) => {
if (!filePath) return;
// Use functional update to get current state
setFileHistory(currentHistory => {
// Remove if already exists, then add to front, then limit to 8
const filteredHistory = currentHistory.filter(path => path !== filePath);
const newFileHistory = [filePath, ...filteredHistory].slice(0, 8);
log.info(`📁 Adding to file history: ${filePath.split(/[/\\]/).pop()}`, {
currentHistoryLength: currentHistory.length,
newHistoryLength: newFileHistory.length,
fullPath: filePath,
maxEntries: 8
});
// Auto-save to store
saveToStore({ fileHistory: newFileHistory }).then(() => {
log.info('💾 File history saved to store', {
savedCount: newFileHistory.length,
savedFiles: newFileHistory.map(f => f.split(/[/\\]/).pop())
});
}).catch(error => {
log.error('Failed to save file history', { error: error.message });
});
return newFileHistory;
});
};
const openFileFromHistory = async (filePath: string) => {
try {
if (await tauriApi.fs.readFile(filePath)) {
await addFiles([filePath]);
setShowFileHistory(false);
log.info(`📂 Reopened from history: ${filePath.split(/[/\\]/).pop()}`);
}
} catch (error) {
log.error(`File no longer exists: ${filePath.split(/[/\\]/).pop()}`);
// Remove from history if file doesn't exist
const updatedHistory = fileHistory.filter(f => f !== filePath);
setFileHistoryWithLogging(updatedHistory);
await saveToStore({ fileHistory: updatedHistory });
}
};
const onFileHistoryCleanup = async (validFiles: string[]) => {
setFileHistoryWithLogging(validFiles);
await saveToStore({ fileHistory: validFiles });
};
const handleLightboxPromptSubmit = async (promptText: string, imagePath: string) => {
// Set the prompt and select the image for editing
setPrompt(promptText);
// Find and select the image
setFiles(prev => prev.map(file => ({
...file,
selected: file.path === imagePath
})));
// Add to history and generate
await addToHistory(promptText);
await generateImage(promptText, [{ path: imagePath, src: '', isGenerated: false }]);
log.info(`🎨 Lightbox edit: "${promptText}" on ${imagePath.split(/[/\\]/).pop()}`);
};
const importPrompts = async () => {
try {
const selected = await tauriApi.dialog.open({
multiple: false,
filters: [{ name: 'JSON', extensions: ['json'] }]
});
if (typeof selected === 'string') {
const contents = await tauriApi.fs.readTextFile(selected);
const newPrompts = JSON.parse(contents);
if (newPrompts.prompts && Array.isArray(newPrompts.prompts)) {
setPrompts(newPrompts.prompts);
savePrompts(newPrompts.prompts);
log.info(`✅ Prompts imported successfully from: ${selected}`);
} else {
log.error('Invalid prompts file format.');
}
}
} catch (error) {
log.error('Failed to import prompts', { error: (error as Error).message });
}
};
const exportPrompts = async () => {
log.info('Attempting to export prompts...');
try {
const path = await tauriApi.dialog.save({
defaultPath: 'kbot-prompts.json',
filters: [{ name: 'JSON', extensions: ['json'] }]
});
if (path) {
log.debug(`📂 Export path selected: ${path}`);
const dataToWrite = JSON.stringify({ prompts }, null, 2);
log.debug('📋 Data to be exported:', { promptCount: prompts.length, dataLength: dataToWrite.length });
log.debug('💾 About to call writeTextFile...');
await tauriApi.fs.writeTextFile(path, dataToWrite);
log.info(`✅ Prompts exported successfully to: ${path}`);
} else {
log.info('Export dialog was cancelled.');
}
} catch (error) {
log.error('Failed to export prompts', { error: (error as Error).message });
}
};
const deleteFilePermanently = async (pathToDelete: string) => {
log.info(`Requesting deletion of file: ${pathToDelete}`);
// This will be the new tauri command
await tauriApi.requestFileDeletion({ path: pathToDelete });
};
const saveImageAs = async (imagePath: string) => {
const imageFile = files.find(f => f.path === imagePath);
if (!imageFile) {
log.error(`Could not find image to save: ${imagePath}`);
return;
}
try {
const defaultPath = imagePath.split(/[/\\]/).pop() || 'saved_image.png';
const newPath = await tauriApi.dialog.save({
defaultPath,
filters: [{ name: 'Images', extensions: ['png', 'jpg', 'jpeg'] }]
});
if (newPath) {
// Convert data URL to binary using fetch
const response = await fetch(imageFile.src);
const blob = await response.blob();
const buffer = await blob.arrayBuffer();
const uint8Array = new Uint8Array(buffer);
await tauriApi.fs.writeFile(newPath, uint8Array);
log.info(`✅ Image saved successfully to: ${newPath}`);
} else {
log.info('Save dialog was cancelled.');
}
} catch (error) {
log.error(`Failed to save image: ${(error as Error).message}`);
}
};
const generateDefaultDst = (fileCount: number, firstFilePath?: string) => {
if (fileCount === 1 && firstFilePath) {
const parsedPath = firstFilePath.split(/[/\\]/).pop() || 'image';
const nameWithoutExt = parsedPath.replace(/\.[^/.]+$/, "");
return `${nameWithoutExt}_out.png`;
} else {
const now = new Date();
const hours = now.getHours().toString().padStart(2, '0');
const minutes = now.getMinutes().toString().padStart(2, '0');
return `data_${hours}_${minutes}.png`;
}
};
const addImageFromUrl = async (url: string) => {
try {
const response = await fetch(url);
if (!response.ok) {
throw new Error(`Failed to fetch image: ${response.statusText}`);
}
const blob = await response.blob();
const reader = new FileReader();
reader.readAsDataURL(blob);
reader.onloadend = () => {
const base64data = reader.result as string;
const newImageFile: ImageFile = {
path: `url_${Date.now()}.jpg`,
src: base64data,
};
setFiles(prevFiles => [...prevFiles, newImageFile]);
};
} catch (error) {
console.error('Failed to add image from URL:', error);
}
};
useTauriListeners({
setPrompt,
setDst,
setApiKey,
setIpcInitialized,
setPrompts,
setFiles,
isGenerating,
generationTimeoutId,
setGenerationTimeoutId,
setIsGenerating,
prompt,
setCurrentIndex,
setPromptHistory,
setFileHistory: setFileHistoryWithLogging,
addToFileHistory,
setErrorMessage,
});
const addFiles = async (newPaths: string[]) => {
const uniqueNewPaths = newPaths.filter(newPath => !files.some(f => f.path === newPath));
if (uniqueNewPaths.length === 0) {
return;
}
// Update destination directory
const firstPath = uniqueNewPaths[0];
// Check if this is a clipboard image (from temp directory)
const isClipboardImage = firstPath.includes('kbot_clipboard_') ||
firstPath.includes('\\Temp\\') || // Windows temp
firstPath.includes('/tmp/') || // Unix/Linux temp
firstPath.includes('AppData\\Local\\Temp') || // Windows user temp
firstPath.includes('/var/folders/'); // macOS temp
let newDir: string;
if (isClipboardImage) {
// For clipboard images, use current working directory or user's Documents folder
newDir = './'; // Use current working directory
log.info('📋 Clipboard image detected, using current working directory for output');
} else {
// For regular files, use the directory of the first file
const lastSeparatorIndex = Math.max(firstPath.lastIndexOf('/'), firstPath.lastIndexOf('\\'));
newDir = firstPath.substring(0, lastSeparatorIndex);
}
const currentFilename = dst.split(/[/\\]/).pop() || generateDefaultDst(1, firstPath);
const separator = firstPath.includes('\\') ? '\\' : '/';
const newDst = newDir === './' ? currentFilename : `${newDir}${separator}${currentFilename}`;
setDst(newDst);
// Read files
const newImageFiles: ImageFile[] = [];
for (const path of uniqueNewPaths) {
try {
const buffer = await tauriApi.fs.readFile(path);
const base64 = arrayBufferToBase64(Array.from(buffer));
const mimeType = path.toLowerCase().endsWith('.png') ? 'image/png' :
path.toLowerCase().endsWith('.jpg') || path.toLowerCase().endsWith('.jpeg') ? 'image/jpeg' :
'image/png';
const src = `data:${mimeType};base64,${base64}`;
newImageFiles.push({ path, src, selected: false, isGenerated: false });
} catch (e) {
const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
console.error(`Failed to read file: ${path}`, e);
tauriApi.logErrorToConsole(`[Frontend Error] Failed to read file ${path}: ${errorMessage}`);
}
}
const lastPath = uniqueNewPaths[uniqueNewPaths.length - 1];
setFiles(prevFiles => {
const combinedFiles = [...prevFiles, ...newImageFiles];
const newIndex = combinedFiles.findIndex(f => f.path === lastPath);
if (newIndex !== -1) {
setCurrentIndex(newIndex);
}
return combinedFiles.map(file => ({
...file,
selected: file.path === lastPath
}));
});
};
const removeFile = (pathToRemove: string) => {
setFiles(prevFiles => prevFiles.filter(file => file.path !== pathToRemove));
};
const clearAllFiles = () => {
setFiles([]);
};
const handleImageSelection = (imagePath: string, isMultiSelect: boolean) => {
setFiles(prev =>
prev.map(file => {
if (file.path === imagePath) {
// For multi-select, toggle the current state. For single-select, always select it.
return { ...file, selected: isMultiSelect ? !file.selected : true };
}
// For single-select, deselect all other images.
if (!isMultiSelect) {
return { ...file, selected: false };
}
// For multi-select, leave other images as they are.
return file;
})
);
};
const getSelectedImages = () => {
return files.filter(file => file.selected);
};
const saveAndClose = async () => {
// Find the last generated image
const generatedFiles = files.filter(file => file.isGenerated);
if (generatedFiles.length === 0) {
log.warn('No generated images to save');
return;
}
const lastGenerated = generatedFiles[generatedFiles.length - 1];
log.info(`💾 Saving and closing with: ${lastGenerated.path}`);
try {
// Send the final result back to images.ts for saving
const result = {
prompt,
files: files.filter(f => !f.isGenerated).map(f => f.path),
dst,
generatedImage: {
src: lastGenerated.src,
filename: lastGenerated.path
}
};
await tauriApi.submitPrompt(result);
log.info('✅ Final result sent, closing app');
} catch (error) {
log.error('Failed to save and close', { error: (error as Error).message });
}
};
const generateImage = async (promptText: string, includeImages: ImageFile[] = []) => {
if (!apiKey) {
log.error('No API key available for image generation');
return;
}
setIsGenerating(true);
setErrorMessage(null); // Clear any previous error messages
log.info(`🎨 Starting image generation via backend: "${promptText}"`);
// Add placeholder image with spinner to the files grid
const placeholderFile: ImageFile = {
path: `generating_${Date.now()}`,
src: 'data:image/svg+xml;base64,' + btoa(`
<svg width="200" height="200" xmlns="http://www.w3.org/2000/svg">
<rect width="200" height="200" fill="#f1f5f9"/>
<circle cx="100" cy="100" r="20" fill="none" stroke="#3b82f6" stroke-width="3" stroke-linecap="round">
<animate attributeName="stroke-dasharray" values="0 126;63 63;0 126" dur="1.5s" repeatCount="indefinite"/>
<animate attributeName="stroke-dashoffset" values="0;-63;-126" dur="1.5s" repeatCount="indefinite"/>
</circle>
<text x="100" y="140" text-anchor="middle" fill="#64748b" font-size="12">Generating...</text>
</svg>
`)
};
setFiles(prev => [...prev, placeholderFile]);
try {
// Use the images.ts backend instead of direct API calls
const filePaths = includeImages.map(img => img.path);
const genDst = dst || `generated_${Date.now()}.png`;
log.info('Sending generation request to images.ts backend', {
prompt: promptText,
files: filePaths,
dst: genDst
});
// Send generation request via Tauri command
await tauriApi.generateImageViaBackend({
prompt: promptText,
files: filePaths,
dst: genDst
});
log.info('📤 Generation request sent to backend');
// Clear any existing timeout
if (generationTimeoutId) {
clearTimeout(generationTimeoutId);
}
const timeoutId = setTimeout(() => {
log.warn('⏰ Generation timeout - resetting state');
setIsGenerating(false);
setFiles(prev => prev.filter(file => !file.path.startsWith('generating_')));
setGenerationTimeoutId(null);
}, 30000);
setGenerationTimeoutId(timeoutId);
} catch (error) {
log.error('Failed to send generation request', {
error: error instanceof Error ? error.message : JSON.stringify(error)
});
setIsGenerating(false);
setFiles(prev => prev.filter(file => !file.path.startsWith('generating_')));
}
};
// Theme management
useEffect(() => {
@ -582,273 +40,33 @@ function App() {
}
};
// Auto-generate default destination file when files change
useEffect(() => {
if (files.length > 0 && !dst) {
const defaultDst = generateDefaultDst(files.length, files[0]?.path);
setDst(defaultDst);
}
}, [files, dst]);
useEffect(() => {
const logBaseDirectories = async () => {
};
logBaseDirectories();
}, []);
async function submit() {
if (!prompt.trim()) {
log.warn('Please enter a prompt first');
return;
}
if (apiKey) {
// Add to history before generating
await addToHistory(prompt);
// Generate image via backend (always chat mode now)
// Only use explicitly selected images. If none are selected, generate from prompt alone.
const imagesToUse = getSelectedImages();
await generateImage(prompt, imagesToUse);
// Don't clear prompt - let user iterate
} else {
log.error('API key required for image generation');
}
}
const clearDebugMessages = async () => {
setDebugMessages([]);
log.clearLocalMessages();
await tauriApi.clearDebugMessages();
};
const sendIPCMessage = async (messageType: string, data: any) => {
await tauriApi.sendIPCMessage(messageType, data);
log.info(`IPC message sent: ${messageType}`, data);
};
const sendMessageToImages = async () => {
if (!messageToSend.trim()) return;
const message = {
message: messageToSend,
timestamp: Date.now(),
source: 'gui'
};
try {
await tauriApi.sendMessageToStdout(JSON.stringify(message));
log.info(`📤 Sent to images.ts: ${messageToSend}`, message);
} catch (error) {
const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
log.error(`Failed to send message: ${errorMessage}`);
}
// Clear the input
setMessageToSend('');
};
const savePrompts = async (promptsToSave: PromptTemplate[]) => {
try {
await saveToStore({ prompts: promptsToSave });
} catch (error) {
log.error('Failed to save prompts', {
error: (error as Error).message
});
}
};
async function openFilePicker() {
const { isTauri: isTauriEnv } = await tauriApi.ensureTauriApi();
if (!isTauriEnv) {
// Browser fallback: create file input
const input = document.createElement('input');
input.type = 'file';
input.multiple = true;
input.accept = 'image/*';
input.onchange = (e) => {
const target = e.target as HTMLInputElement;
if (target.files) {
const fileArray = Array.from(target.files);
const newImageFiles: ImageFile[] = [];
let loadedCount = 0;
fileArray.forEach(file => {
const reader = new FileReader();
reader.onload = (e) => {
if (e.target?.result) {
newImageFiles.push({
path: file.name,
src: e.target.result as string
});
loadedCount++;
if (loadedCount === fileArray.length) {
setFiles(prevFiles => [...prevFiles, ...newImageFiles]);
}
}
};
reader.readAsDataURL(file);
});
}
};
input.click();
return;
}
try {
if (!tauriApi.dialog.open) {
console.error('Open function not available');
return;
}
const selected = await tauriApi.dialog.open({
multiple: true,
filters: [{
name: 'Images',
extensions: ['png', 'jpeg', 'jpg']
}]
});
if (Array.isArray(selected)) {
addFiles(selected);
}
} catch (e) {
console.error('File picker error:', e);
tauriApi.logErrorToConsole(`[Frontend Error] File picker error: ${JSON.stringify(e)}`);
}
}
async function openSaveDialog() {
try {
// Extract current filename from dst for default, or use smart default
const currentFilename = dst.split(/[/\\]/).pop() || generateDefaultDst(files.length, files[0]?.path);
const selected = await tauriApi.dialog.save({
defaultPath: currentFilename,
filters: [{
name: 'Images',
extensions: ['png', 'jpg']
}]
});
if (selected) {
setDst(selected);
}
} catch (e) {
console.error('Save dialog error:', e);
tauriApi.logErrorToConsole(`[Frontend Error] Save dialog error: ${JSON.stringify(e)}`);
}
}
return (
<main className="min-h-screen bg-gradient-to-br from-indigo-50 via-white to-cyan-50 dark:from-slate-900 dark:via-slate-800 dark:to-indigo-900 flex flex-col items-center p-6 transition-colors duration-500">
{/* Background decoration */}
<div className="fixed inset-0 overflow-hidden pointer-events-none">
<div className="absolute -top-40 -right-40 w-80 h-80 bg-gradient-to-br from-indigo-200/30 to-purple-200/30 dark:from-indigo-500/20 dark:to-purple-500/20 rounded-full blur-3xl"></div>
<div className="absolute -bottom-40 -left-40 w-80 h-80 bg-gradient-to-tr from-cyan-200/30 to-blue-200/30 dark:from-cyan-500/20 dark:to-blue-500/20 rounded-full blur-3xl"></div>
</div>
<div className="w-full max-w-4xl relative z-10 mt-8">
<Header
showDebugPanel={showDebugPanel}
setShowDebugPanel={setShowDebugPanel}
isDarkMode={isDarkMode}
toggleTheme={toggleTheme}
apiKey={apiKey}
<Router>
<Routes>
<Route
path="/"
element={
<ImageWizard
apiKey={apiKey}
setApiKey={setApiKey}
isDarkMode={isDarkMode}
toggleTheme={toggleTheme}
/>
}
/>
{/* Error Message Display */}
{errorMessage && (
<div className="mb-6 p-4 bg-red-50 dark:bg-red-900/30 border border-red-200 dark:border-red-700 rounded-xl">
<div className="flex justify-between items-start">
<div className="flex">
<div className="flex-shrink-0">
<svg className="h-5 w-5 text-red-400" viewBox="0 0 20 20" fill="currentColor">
<path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
</svg>
</div>
<div className="ml-3">
<h3 className="text-sm font-medium text-red-800 dark:text-red-200">
Generation Error
</h3>
<div className="mt-2 text-sm text-red-700 dark:text-red-300">
<p>{errorMessage}</p>
</div>
</div>
</div>
<div className="ml-auto pl-3">
<button
type="button"
className="inline-flex bg-red-50 dark:bg-red-900/30 rounded-md p-1.5 text-red-500 hover:bg-red-100 dark:hover:bg-red-900/50 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-red-500"
onClick={() => setErrorMessage(null)}
>
<span className="sr-only">Dismiss</span>
<svg className="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
<path fillRule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clipRule="evenodd" />
</svg>
</button>
</div>
</div>
</div>
)}
<PromptForm
prompt={prompt}
setPrompt={setPrompt}
dst={dst}
setDst={setDst}
openSaveDialog={openSaveDialog}
openFilePicker={openFilePicker}
files={files}
getSelectedImages={getSelectedImages}
clearAllFiles={clearAllFiles}
handleImageSelection={handleImageSelection}
removeFile={removeFile}
isGenerating={isGenerating}
saveAndClose={saveAndClose}
submit={submit}
addImageFromUrl={addImageFromUrl}
onImageDelete={deleteFilePermanently}
onImageSaveAs={saveImageAs}
addFiles={addFiles}
currentIndex={currentIndex}
setCurrentIndex={setCurrentIndex}
prompts={prompts}
setPrompts={setPrompts}
savePrompts={savePrompts}
importPrompts={importPrompts}
exportPrompts={exportPrompts}
quickStyles={QUICK_STYLES}
appendStyle={appendStyle}
quickActions={QUICK_ACTIONS}
executeQuickAction={executeQuickAction}
promptHistory={promptHistory}
historyIndex={historyIndex}
navigateHistory={navigateHistory}
fileHistory={fileHistory}
showFileHistory={showFileHistory}
setShowFileHistory={setShowFileHistory}
openFileFromHistory={openFileFromHistory}
onFileHistoryCleanup={onFileHistoryCleanup}
onLightboxPromptSubmit={handleLightboxPromptSubmit}
errorMessage={errorMessage}
setErrorMessage={setErrorMessage}
<Route
path="/settings"
element={
<Settings
apiKey={apiKey}
setApiKey={setApiKey}
isDarkMode={isDarkMode}
toggleTheme={toggleTheme}
/>
}
/>
{/* Debug Panel */}
{showDebugPanel && (
<DebugPanel
debugMessages={debugMessages}
sendIPCMessage={sendIPCMessage}
clearDebugMessages={clearDebugMessages}
ipcInitialized={ipcInitialized}
messageToSend={messageToSend}
setMessageToSend={setMessageToSend}
sendMessageToImages={sendMessageToImages}
/>
)}
</div>
</main>
</Routes>
</Router>
);
}

View File

@ -1,11 +1,11 @@
import React from 'react';
import { useNavigate } from 'react-router-dom';
interface HeaderProps {
showDebugPanel: boolean;
setShowDebugPanel: (show: boolean) => void;
isDarkMode: boolean;
toggleTheme: () => void;
apiKey: string;
}
const Header: React.FC<HeaderProps> = ({
@ -13,58 +13,66 @@ const Header: React.FC<HeaderProps> = ({
setShowDebugPanel,
isDarkMode,
toggleTheme,
apiKey,
}) => {
const navigate = useNavigate();
return (
<div className="flex justify-between items-center mb-8">
<h1 className="text-5xl font-bold accent-text drop-shadow-sm">Image Prompt</h1>
<div className="flex items-center gap-4">
{/* Debug Panel Toggle */}
<button
onClick={() => setShowDebugPanel(!showDebugPanel)}
className="glass-button p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title="Toggle Debug Panel"
>
<svg className="w-5 h-5 text-slate-700 dark:text-slate-300" fill="currentColor" viewBox="0 0 20 20">
<path
fillRule="evenodd"
d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-8-3a1 1 0 00-.867.5 1 1 0 11-1.731-1A3 3 0 0113 8a3.001 3.001 0 01-2 2.83V11a1 1 0 11-2 0v-1a1 1 0 011-1 1 1 0 100-2zm0 8a1 1 0 100-2 1 1 0 000 2z"
clipRule="evenodd"
/>
</svg>
</button>
{/* Theme Toggle */}
<button
onClick={toggleTheme}
className="glass-button p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title={isDarkMode ? 'Switch to Light Mode' : 'Switch to Dark Mode'}
>
{isDarkMode ? (
<svg className="w-5 h-5 text-slate-300" fill="currentColor" viewBox="0 0 20 20">
<div className="mb-8 space-y-4">
{/* Title on its own row */}
<div className="text-center">
<h1 className="text-2xl md:text-3xl font-bold accent-text drop-shadow-sm">Image Wizard</h1>
</div>
{/* Controls row - single row layout */}
<div className="flex justify-center sm:justify-end items-center gap-2">
{/* Button group - single row */}
<div className="flex items-center gap-2 flex-shrink-0">
{/* Debug Panel Toggle */}
<button
onClick={() => setShowDebugPanel(!showDebugPanel)}
className="glass-button p-2 sm:p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title="Toggle Debug Panel"
>
<svg className="w-4 h-4 sm:w-5 sm:h-5 text-slate-700 dark:text-slate-300" fill="currentColor" viewBox="0 0 20 20">
<path
fillRule="evenodd"
d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z"
d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-8-3a1 1 0 00-.867.5 1 1 0 11-1.731-1A3 3 0 0113 8a3.001 3.001 0 01-2 2.83V11a1 1 0 11-2 0v-1a1 1 0 011-1 1 1 0 100-2zm0 8a1 1 0 100-2 1 1 0 000 2z"
clipRule="evenodd"
/>
</svg>
) : (
<svg className="w-5 h-5 text-slate-700" fill="currentColor" viewBox="0 0 20 20">
<path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z" />
</svg>
)}
</button>
</button>
{/* Status Indicator */}
<div className="flex items-center gap-4 glass-card p-4 shadow-lg">
<span className="text-sm font-semibold text-slate-800 dark:text-slate-200">Interactive Mode</span>
<div className={`h-3 w-3 rounded-full ${apiKey ? 'bg-green-500' : 'bg-red-500'}`}></div>
{!apiKey && (
<span className="text-xs text-slate-400 dark:text-slate-500 bg-slate-100/50 dark:bg-slate-800/50 px-2 py-1 rounded-full">
(API key required)
</span>
)}
{/* Theme Toggle */}
<button
onClick={toggleTheme}
className="glass-button p-2 sm:p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title={isDarkMode ? 'Switch to Light Mode' : 'Switch to Dark Mode'}
>
{isDarkMode ? (
<svg className="w-4 h-4 sm:w-5 sm:h-5 text-slate-300" fill="currentColor" viewBox="0 0 20 20">
<path
fillRule="evenodd"
d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z"
clipRule="evenodd"
/>
</svg>
) : (
<svg className="w-4 h-4 sm:w-5 sm:h-5 text-slate-700" fill="currentColor" viewBox="0 0 20 20">
<path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z" />
</svg>
)}
</button>
</div>
{/* Settings Button */}
<button
onClick={() => navigate('/settings')}
className="glass-button p-2 sm:p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title="Settings"
>
<svg className="w-4 h-4 sm:w-5 sm:h-5 text-slate-700 dark:text-slate-300" fill="currentColor" viewBox="0 0 20 20">
<path fillRule="evenodd" d="M11.49 3.17c-.38-1.56-2.6-1.56-2.98 0a1.532 1.532 0 01-2.286.948c-1.372-.836-2.942.734-2.106 2.106.54.886.061 2.042-.947 2.287-1.561.379-1.561 2.6 0 2.978a1.532 1.532 0 01.947 2.287c-.836 1.372.734 2.942 2.106 2.106a1.532 1.532 0 012.287.947c.379 1.561 2.6 1.561 2.978 0a1.533 1.533 0 012.287-.947c1.372.836 2.942-.734 2.106-2.106a1.533 1.533 0 01.947-2.287c1.561-.379 1.561-2.6 0-2.978a1.532 1.532 0 01-.947-2.287c.836-1.372-.734-2.942-2.106-2.106a1.532 1.532 0 01-2.287-.947zM10 13a3 3 0 100-6 3 3 0 000 6z" clipRule="evenodd" />
</svg>
</button>
</div>
</div>
);

View File

@ -0,0 +1,831 @@
import React, { useState, useEffect } from "react";
import { ImageFile, PromptTemplate } from "../types";
import { useTauriListeners } from "../hooks/useTauriListeners";
import { tauriApi } from "../lib/tauriApi";
import { saveToStore } from "../lib/init";
import { QUICK_STYLES, QUICK_ACTIONS } from "../constants";
import log from "../lib/log";
import Header from "./Header";
import PromptForm from "./PromptForm";
import DebugPanel from "./DebugPanel";
function arrayBufferToBase64(buffer: number[]) {
let binary = '';
const bytes = new Uint8Array(buffer);
const len = bytes.byteLength;
for (let i = 0; i < len; i++) {
binary += String.fromCharCode(bytes[i]);
}
return window.btoa(binary);
}
interface ImageWizardProps {
apiKey: string;
setApiKey: (key: string) => void;
isDarkMode: boolean;
toggleTheme: () => void;
}
const ImageWizard: React.FC<ImageWizardProps> = ({
apiKey,
setApiKey,
isDarkMode,
toggleTheme,
}) => {
const [prompt, setPrompt] = useState("");
const [files, setFiles] = useState<ImageFile[]>([]);
const [dst, setDst] = useState("");
const [isGenerating, setIsGenerating] = useState(false);
const [debugMessages, setDebugMessages] = useState<any[]>([]);
const [showDebugPanel, setShowDebugPanel] = useState(false);
const [errorMessage, setErrorMessage] = useState<string | null>(null);
// Initialize logging system and connect to UI
useEffect(() => {
log.setMessageCallback((message) => {
setDebugMessages(prev => [...prev.slice(-99), message]);
});
// Load existing messages
setDebugMessages(log.getLocalMessages());
}, []);
const [ipcInitialized, setIpcInitialized] = useState(false);
const [messageToSend, setMessageToSend] = useState("");
const [generationTimeoutId, setGenerationTimeoutId] = useState<NodeJS.Timeout | null>(null);
const [currentIndex, setCurrentIndex] = useState(0);
const [prompts, setPrompts] = useState<PromptTemplate[]>([]);
const [promptHistory, setPromptHistory] = useState<string[]>([]);
const [historyIndex, setHistoryIndex] = useState(-1);
const [fileHistory, setFileHistory] = useState<string[]>([]);
// Debug wrapper for setFileHistory
const setFileHistoryWithLogging = (history: string[]) => {
log.debug(`🔧 setFileHistory called with ${history.length} files`, {
files: history.map(f => f.split(/[/\\]/).pop())
});
setFileHistory(history);
};
const [showFileHistory, setShowFileHistory] = useState(false);
// All the existing functions from App.tsx...
const appendStyle = (style: string) => {
setPrompt(prev => {
const trimmed = prev.trim();
// Remove any existing styles from QUICK_STYLES
let cleanPrompt = trimmed;
QUICK_STYLES.forEach(existingStyle => {
// Remove style if it exists (with or without comma)
const patterns = [
new RegExp(`,\\s*${existingStyle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*`, 'gi'),
new RegExp(`^${existingStyle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*,?\\s*`, 'gi'),
new RegExp(`\\s*,\\s*${existingStyle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`, 'gi')
];
patterns.forEach(pattern => {
cleanPrompt = cleanPrompt.replace(pattern, '');
});
});
// Clean up any double commas or trailing/leading commas
cleanPrompt = cleanPrompt.replace(/,\s*,/g, ',').replace(/^,\s*|,\s*$/g, '').trim();
// Add the new style
if (cleanPrompt) {
return `${cleanPrompt}, ${style}`;
} else {
return style;
}
});
log.info(`🎨 Style replaced with: ${style}`);
};
const executeQuickAction = async (action: { name: string; prompt: string; iconName: string }) => {
const selectedImages = getSelectedImages();
if (selectedImages.length === 0) {
log.warn('Please select an image first to use quick actions');
return;
}
// Use the first selected image
const targetImage = selectedImages[0];
// Set the action prompt
setPrompt(action.prompt);
// Generate with the selected image
log.info(`🚀 Executing quick action: ${action.name} on selected image ${targetImage.path}`);
await generateImage(action.prompt, [targetImage]);
};
const addToHistory = async (promptText: string) => {
if (promptText.trim() && !promptHistory.includes(promptText.trim())) {
const newHistory = [...promptHistory, promptText.trim()];
setPromptHistory(newHistory);
setHistoryIndex(-1); // Reset to end of history
log.info(`📝 Added to history: "${promptText.substring(0, 50)}..."`);
// Auto-save to store
try {
await saveToStore({ history: newHistory });
log.info('💾 History saved to store');
} catch (error) {
log.error('Failed to save history', { error: (error as Error).message });
}
}
};
const navigateHistory = (direction: 'up' | 'down') => {
if (promptHistory.length === 0) return;
let newIndex = historyIndex;
if (direction === 'up') {
newIndex = historyIndex === -1 ? promptHistory.length - 1 : Math.max(0, historyIndex - 1);
} else {
newIndex = historyIndex === -1 ? -1 : historyIndex + 1;
if (newIndex >= promptHistory.length) newIndex = -1;
}
setHistoryIndex(newIndex);
if (newIndex === -1) {
setPrompt('');
} else {
setPrompt(promptHistory[newIndex]);
log.info(`📜 History: ${newIndex + 1}/${promptHistory.length}`);
}
};
const addToFileHistory = async (filePath: string) => {
if (!filePath) return;
// Use functional update to get current state
setFileHistory(currentHistory => {
// Remove if already exists, then add to front, then limit to 8
const filteredHistory = currentHistory.filter(path => path !== filePath);
const newFileHistory = [filePath, ...filteredHistory].slice(0, 8);
log.info(`📁 Adding to file history: ${filePath.split(/[/\\]/).pop()}`, {
currentHistoryLength: currentHistory.length,
newHistoryLength: newFileHistory.length,
fullPath: filePath,
maxEntries: 8
});
// Auto-save to store
saveToStore({ fileHistory: newFileHistory }).then(() => {
log.info('💾 File history saved to store', {
savedCount: newFileHistory.length,
savedFiles: newFileHistory.map(f => f.split(/[/\\]/).pop())
});
}).catch(error => {
log.error('Failed to save file history', { error: error.message });
});
return newFileHistory;
});
};
const openFileFromHistory = async (filePath: string) => {
try {
if (await tauriApi.fs.readFile(filePath)) {
await addFiles([filePath]);
setShowFileHistory(false);
log.info(`📂 Reopened from history: ${filePath.split(/[/\\]/).pop()}`);
}
} catch (error) {
log.error(`File no longer exists: ${filePath.split(/[/\\]/).pop()}`);
// Remove from history if file doesn't exist
const updatedHistory = fileHistory.filter(f => f !== filePath);
setFileHistoryWithLogging(updatedHistory);
await saveToStore({ fileHistory: updatedHistory });
}
};
const onFileHistoryCleanup = async (validFiles: string[]) => {
setFileHistoryWithLogging(validFiles);
await saveToStore({ fileHistory: validFiles });
};
const handleLightboxPromptSubmit = async (promptText: string, imagePath: string) => {
// Set the prompt and select the image for editing
setPrompt(promptText);
// Find and select the image
setFiles(prev => prev.map(file => ({
...file,
selected: file.path === imagePath
})));
// Add to history and generate
await addToHistory(promptText);
await generateImage(promptText, [{ path: imagePath, src: '', isGenerated: false }]);
log.info(`🎨 Lightbox edit: "${promptText}" on ${imagePath.split(/[/\\]/).pop()}`);
};
const importPrompts = async () => {
try {
const selected = await tauriApi.dialog.open({
multiple: false,
filters: [{ name: 'JSON', extensions: ['json'] }]
});
if (typeof selected === 'string') {
const contents = await tauriApi.fs.readTextFile(selected);
const newPrompts = JSON.parse(contents);
if (newPrompts.prompts && Array.isArray(newPrompts.prompts)) {
setPrompts(newPrompts.prompts);
savePrompts(newPrompts.prompts);
log.info(`✅ Prompts imported successfully from: ${selected}`);
} else {
log.error('Invalid prompts file format.');
}
}
} catch (error) {
log.error('Failed to import prompts', { error: (error as Error).message });
}
};
const exportPrompts = async () => {
log.info('Attempting to export prompts...');
try {
const path = await tauriApi.dialog.save({
defaultPath: 'kbot-prompts.json',
filters: [{ name: 'JSON', extensions: ['json'] }]
});
if (path) {
log.debug(`📂 Export path selected: ${path}`);
const dataToWrite = JSON.stringify({ prompts }, null, 2);
log.debug('📋 Data to be exported:', { promptCount: prompts.length, dataLength: dataToWrite.length });
log.debug('💾 About to call writeTextFile...');
await tauriApi.fs.writeTextFile(path, dataToWrite);
log.info(`✅ Prompts exported successfully to: ${path}`);
} else {
log.info('Export dialog was cancelled.');
}
} catch (error) {
log.error('Failed to export prompts', { error: (error as Error).message });
}
};
const deleteFilePermanently = async (pathToDelete: string) => {
log.info(`Requesting deletion of file: ${pathToDelete}`);
// This will be the new tauri command
await tauriApi.requestFileDeletion({ path: pathToDelete });
};
const saveImageAs = async (imagePath: string) => {
const imageFile = files.find(f => f.path === imagePath);
if (!imageFile) {
log.error(`Could not find image to save: ${imagePath}`);
return;
}
try {
const defaultPath = imagePath.split(/[/\\]/).pop() || 'saved_image.png';
const newPath = await tauriApi.dialog.save({
defaultPath,
filters: [{ name: 'Images', extensions: ['png', 'jpg', 'jpeg'] }]
});
if (newPath) {
// Convert data URL to binary using fetch
const response = await fetch(imageFile.src);
const blob = await response.blob();
const buffer = await blob.arrayBuffer();
const uint8Array = new Uint8Array(buffer);
await tauriApi.fs.writeFile(newPath, uint8Array);
log.info(`✅ Image saved successfully to: ${newPath}`);
} else {
log.info('Save dialog was cancelled.');
}
} catch (error) {
log.error(`Failed to save image: ${(error as Error).message}`);
}
};
const generateDefaultDst = (fileCount: number, firstFilePath?: string) => {
if (fileCount === 1 && firstFilePath) {
const parsedPath = firstFilePath.split(/[/\\]/).pop() || 'image';
const nameWithoutExt = parsedPath.replace(/\.[^/.]+$/, "");
return `${nameWithoutExt}_out.png`;
} else {
const now = new Date();
const hours = now.getHours().toString().padStart(2, '0');
const minutes = now.getMinutes().toString().padStart(2, '0');
return `data_${hours}_${minutes}.png`;
}
};
const addImageFromUrl = async (url: string) => {
try {
const response = await fetch(url);
if (!response.ok) {
throw new Error(`Failed to fetch image: ${response.statusText}`);
}
const blob = await response.blob();
const reader = new FileReader();
reader.readAsDataURL(blob);
reader.onloadend = () => {
const base64data = reader.result as string;
const newImageFile: ImageFile = {
path: `url_${Date.now()}.jpg`,
src: base64data,
};
setFiles(prevFiles => [...prevFiles, newImageFile]);
};
} catch (error) {
console.error('Failed to add image from URL:', error);
}
};
useTauriListeners({
setPrompt,
setDst,
setApiKey,
setIpcInitialized,
setPrompts,
setFiles,
isGenerating,
generationTimeoutId,
setGenerationTimeoutId,
setIsGenerating,
prompt,
setCurrentIndex,
setPromptHistory,
setFileHistory: setFileHistoryWithLogging,
addToFileHistory,
setErrorMessage,
});
const addFiles = async (newPaths: string[]) => {
const uniqueNewPaths = newPaths.filter(newPath => !files.some(f => f.path === newPath));
if (uniqueNewPaths.length === 0) {
return;
}
// Update destination directory
const firstPath = uniqueNewPaths[0];
// Check if this is a clipboard image (from temp directory)
const isClipboardImage = firstPath.includes('kbot_clipboard_') ||
firstPath.includes('\\Temp\\') || // Windows temp
firstPath.includes('/tmp/') || // Unix/Linux temp
firstPath.includes('AppData\\Local\\Temp') || // Windows user temp
firstPath.includes('/var/folders/'); // macOS temp
let newDir: string;
if (isClipboardImage) {
// For clipboard images, use current working directory or user's Documents folder
newDir = './'; // Use current working directory
log.info('📋 Clipboard image detected, using current working directory for output');
} else {
// For regular files, use the directory of the first file
const lastSeparatorIndex = Math.max(firstPath.lastIndexOf('/'), firstPath.lastIndexOf('\\'));
newDir = firstPath.substring(0, lastSeparatorIndex);
}
const currentFilename = dst.split(/[/\\]/).pop() || generateDefaultDst(1, firstPath);
const separator = firstPath.includes('\\') ? '\\' : '/';
const newDst = newDir === './' ? currentFilename : `${newDir}${separator}${currentFilename}`;
setDst(newDst);
// Read files
const newImageFiles: ImageFile[] = [];
for (const path of uniqueNewPaths) {
try {
const buffer = await tauriApi.fs.readFile(path);
const base64 = arrayBufferToBase64(Array.from(buffer));
const mimeType = path.toLowerCase().endsWith('.png') ? 'image/png' :
path.toLowerCase().endsWith('.jpg') || path.toLowerCase().endsWith('.jpeg') ? 'image/jpeg' :
'image/png';
const src = `data:${mimeType};base64,${base64}`;
newImageFiles.push({ path, src, selected: false, isGenerated: false });
} catch (e) {
const errorMessage = e instanceof Error ? e.message : JSON.stringify(e);
console.error(`Failed to read file: ${path}`, e);
tauriApi.logErrorToConsole(`[Frontend Error] Failed to read file ${path}: ${errorMessage}`);
}
}
const lastPath = uniqueNewPaths[uniqueNewPaths.length - 1];
setFiles(prevFiles => {
const combinedFiles = [...prevFiles, ...newImageFiles];
const newIndex = combinedFiles.findIndex(f => f.path === lastPath);
if (newIndex !== -1) {
setCurrentIndex(newIndex);
}
return combinedFiles.map(file => ({
...file,
selected: file.path === lastPath
}));
});
};
const removeFile = (pathToRemove: string) => {
setFiles(prevFiles => prevFiles.filter(file => file.path !== pathToRemove));
};
const clearAllFiles = () => {
setFiles([]);
};
const handleImageSelection = (imagePath: string, isMultiSelect: boolean) => {
setFiles(prev =>
prev.map(file => {
if (file.path === imagePath) {
// For multi-select, toggle the current state. For single-select, always select it.
return { ...file, selected: isMultiSelect ? !file.selected : true };
}
// For single-select, deselect all other images.
if (!isMultiSelect) {
return { ...file, selected: false };
}
// For multi-select, leave other images as they are.
return file;
})
);
};
const getSelectedImages = () => {
return files.filter(file => file.selected);
};
const saveAndClose = async () => {
// Find the last generated image
const generatedFiles = files.filter(file => file.isGenerated);
if (generatedFiles.length === 0) {
log.warn('No generated images to save');
return;
}
const lastGenerated = generatedFiles[generatedFiles.length - 1];
log.info(`💾 Saving and closing with: ${lastGenerated.path}`);
try {
// Send the final result back to images.ts for saving
const result = {
prompt,
files: files.filter(f => !f.isGenerated).map(f => f.path),
dst,
generatedImage: {
src: lastGenerated.src,
filename: lastGenerated.path
}
};
await tauriApi.submitPrompt(result);
log.info('✅ Final result sent, closing app');
} catch (error) {
log.error('Failed to save and close', { error: (error as Error).message });
}
};
const generateImage = async (promptText: string, includeImages: ImageFile[] = []) => {
if (!apiKey) {
log.error('No API key available for image generation');
return;
}
setIsGenerating(true);
setErrorMessage(null); // Clear any previous error messages
log.info(`🎨 Starting image generation via backend: "${promptText}"`);
// Add placeholder image with spinner to the files grid
const placeholderFile: ImageFile = {
path: `generating_${Date.now()}`,
src: 'data:image/svg+xml;base64,' + btoa(`
<svg width="200" height="200" xmlns="http://www.w3.org/2000/svg">
<rect width="200" height="200" fill="#f1f5f9"/>
<circle cx="100" cy="100" r="20" fill="none" stroke="#3b82f6" stroke-width="3" stroke-linecap="round">
<animate attributeName="stroke-dasharray" values="0 126;63 63;0 126" dur="1.5s" repeatCount="indefinite"/>
<animate attributeName="stroke-dashoffset" values="0;-63;-126" dur="1.5s" repeatCount="indefinite"/>
</circle>
<text x="100" y="140" text-anchor="middle" fill="#64748b" font-size="12">Generating...</text>
</svg>
`)
};
setFiles(prev => [...prev, placeholderFile]);
try {
// Use the images.ts backend instead of direct API calls
const filePaths = includeImages.map(img => img.path);
const genDst = dst || `generated_${Date.now()}.png`;
log.info('Sending generation request to images.ts backend', {
prompt: promptText,
files: filePaths,
dst: genDst
});
// Send generation request via Tauri command
await tauriApi.generateImageViaBackend({
prompt: promptText,
files: filePaths,
dst: genDst
});
log.info('📤 Generation request sent to backend');
// Clear any existing timeout
if (generationTimeoutId) {
clearTimeout(generationTimeoutId);
}
const timeoutId = setTimeout(() => {
log.warn('⏰ Generation timeout - resetting state');
setIsGenerating(false);
setFiles(prev => prev.filter(file => !file.path.startsWith('generating_')));
setGenerationTimeoutId(null);
}, 30000);
setGenerationTimeoutId(timeoutId);
} catch (error) {
log.error('Failed to send generation request', {
error: error instanceof Error ? error.message : JSON.stringify(error)
});
setIsGenerating(false);
setFiles(prev => prev.filter(file => !file.path.startsWith('generating_')));
}
};
// Auto-generate default destination file when files change
useEffect(() => {
if (files.length > 0 && !dst) {
const defaultDst = generateDefaultDst(files.length, files[0]?.path);
setDst(defaultDst);
}
}, [files, dst]);
useEffect(() => {
const logBaseDirectories = async () => {
};
logBaseDirectories();
}, []);
async function submit() {
if (!prompt.trim()) {
log.warn('Please enter a prompt first');
return;
}
if (apiKey) {
// Add to history before generating
await addToHistory(prompt);
// Generate image via backend (always chat mode now)
// Only use explicitly selected images. If none are selected, generate from prompt alone.
const imagesToUse = getSelectedImages();
await generateImage(prompt, imagesToUse);
// Don't clear prompt - let user iterate
} else {
log.error('API key required for image generation');
}
}
const clearDebugMessages = async () => {
setDebugMessages([]);
log.clearLocalMessages();
await tauriApi.clearDebugMessages();
};
const sendIPCMessage = async (messageType: string, data: any) => {
await tauriApi.sendIPCMessage(messageType, data);
log.info(`IPC message sent: ${messageType}`, data);
};
const sendMessageToImages = async () => {
if (!messageToSend.trim()) return;
const message = {
message: messageToSend,
timestamp: Date.now(),
source: 'gui'
};
try {
await tauriApi.sendMessageToStdout(JSON.stringify(message));
log.info(`📤 Sent to images.ts: ${messageToSend}`, message);
} catch (error) {
const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
log.error(`Failed to send message: ${errorMessage}`);
}
// Clear the input
setMessageToSend('');
};
const savePrompts = async (promptsToSave: PromptTemplate[]) => {
try {
await saveToStore({ prompts: promptsToSave });
} catch (error) {
log.error('Failed to save prompts', {
error: (error as Error).message
});
}
};
async function openFilePicker() {
const { isTauri: isTauriEnv } = await tauriApi.ensureTauriApi();
if (!isTauriEnv) {
// Browser fallback: create file input
const input = document.createElement('input');
input.type = 'file';
input.multiple = true;
input.accept = 'image/*';
input.onchange = (e) => {
const target = e.target as HTMLInputElement;
if (target.files) {
const fileArray = Array.from(target.files);
const newImageFiles: ImageFile[] = [];
let loadedCount = 0;
fileArray.forEach(file => {
const reader = new FileReader();
reader.onload = (e) => {
if (e.target?.result) {
newImageFiles.push({
path: file.name,
src: e.target.result as string
});
loadedCount++;
if (loadedCount === fileArray.length) {
setFiles(prevFiles => [...prevFiles, ...newImageFiles]);
}
}
};
reader.readAsDataURL(file);
});
}
};
input.click();
return;
}
try {
if (!tauriApi.dialog.open) {
console.error('Open function not available');
return;
}
const selected = await tauriApi.dialog.open({
multiple: true,
filters: [{
name: 'Images',
extensions: ['png', 'jpeg', 'jpg']
}]
});
if (Array.isArray(selected)) {
addFiles(selected);
}
} catch (e) {
console.error('File picker error:', e);
tauriApi.logErrorToConsole(`[Frontend Error] File picker error: ${JSON.stringify(e)}`);
}
}
async function openSaveDialog() {
try {
// Extract current filename from dst for default, or use smart default
const currentFilename = dst.split(/[/\\]/).pop() || generateDefaultDst(files.length, files[0]?.path);
const selected = await tauriApi.dialog.save({
defaultPath: currentFilename,
filters: [{
name: 'Images',
extensions: ['png', 'jpg']
}]
});
if (selected) {
setDst(selected);
}
} catch (e) {
console.error('Save dialog error:', e);
tauriApi.logErrorToConsole(`[Frontend Error] Save dialog error: ${JSON.stringify(e)}`);
}
}
return (
<main className="min-h-screen bg-gradient-to-br from-indigo-50 via-white to-cyan-50 dark:from-slate-900 dark:via-slate-800 dark:to-indigo-900 flex flex-col items-center p-6 transition-colors duration-500">
{/* Background decoration */}
<div className="fixed inset-0 overflow-hidden pointer-events-none">
<div className="absolute -top-40 -right-40 w-80 h-80 bg-gradient-to-br from-indigo-200/30 to-purple-200/30 dark:from-indigo-500/20 dark:to-purple-500/20 rounded-full blur-3xl"></div>
<div className="absolute -bottom-40 -left-40 w-80 h-80 bg-gradient-to-tr from-cyan-200/30 to-blue-200/30 dark:from-cyan-500/20 dark:to-blue-500/20 rounded-full blur-3xl"></div>
</div>
<div className="w-full max-w-4xl relative z-10 mt-8">
<Header
showDebugPanel={showDebugPanel}
setShowDebugPanel={setShowDebugPanel}
isDarkMode={isDarkMode}
toggleTheme={toggleTheme}
/>
{/* Error Message Display */}
{errorMessage && (
<div className="mb-6 p-4 bg-red-50 dark:bg-red-900/30 border border-red-200 dark:border-red-700 rounded-xl">
<div className="flex justify-between items-start">
<div className="flex">
<div className="flex-shrink-0">
<svg className="h-5 w-5 text-red-400" viewBox="0 0 20 20" fill="currentColor">
<path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
</svg>
</div>
<div className="ml-3">
<h3 className="text-sm font-medium text-red-800 dark:text-red-200">
Generation Error
</h3>
<div className="mt-2 text-sm text-red-700 dark:text-red-300">
<p>{errorMessage}</p>
</div>
</div>
</div>
<div className="ml-auto pl-3">
<button
type="button"
className="inline-flex bg-red-50 dark:bg-red-900/30 rounded-md p-1.5 text-red-500 hover:bg-red-100 dark:hover:bg-red-900/50 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-red-500"
onClick={() => setErrorMessage(null)}
>
<span className="sr-only">Dismiss</span>
<svg className="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
<path fillRule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clipRule="evenodd" />
</svg>
</button>
</div>
</div>
</div>
)}
<PromptForm
prompt={prompt}
setPrompt={setPrompt}
dst={dst}
setDst={setDst}
openSaveDialog={openSaveDialog}
openFilePicker={openFilePicker}
files={files}
getSelectedImages={getSelectedImages}
clearAllFiles={clearAllFiles}
handleImageSelection={handleImageSelection}
removeFile={removeFile}
isGenerating={isGenerating}
saveAndClose={saveAndClose}
submit={submit}
addImageFromUrl={addImageFromUrl}
onImageDelete={deleteFilePermanently}
onImageSaveAs={saveImageAs}
addFiles={addFiles}
currentIndex={currentIndex}
setCurrentIndex={setCurrentIndex}
prompts={prompts}
setPrompts={setPrompts}
savePrompts={savePrompts}
importPrompts={importPrompts}
exportPrompts={exportPrompts}
quickStyles={QUICK_STYLES}
appendStyle={appendStyle}
quickActions={QUICK_ACTIONS}
executeQuickAction={executeQuickAction}
promptHistory={promptHistory}
historyIndex={historyIndex}
navigateHistory={navigateHistory}
fileHistory={fileHistory}
showFileHistory={showFileHistory}
setShowFileHistory={setShowFileHistory}
openFileFromHistory={openFileFromHistory}
onFileHistoryCleanup={onFileHistoryCleanup}
onLightboxPromptSubmit={handleLightboxPromptSubmit}
errorMessage={errorMessage}
setErrorMessage={setErrorMessage}
/>
{/* Debug Panel */}
{showDebugPanel && (
<DebugPanel
debugMessages={debugMessages}
sendIPCMessage={sendIPCMessage}
clearDebugMessages={clearDebugMessages}
ipcInitialized={ipcInitialized}
messageToSend={messageToSend}
setMessageToSend={setMessageToSend}
sendMessageToImages={sendMessageToImages}
/>
)}
</div>
</main>
);
};
export default ImageWizard;

View File

@ -0,0 +1,149 @@
import React, { useState, useEffect } from 'react';
import { ArrowLeft } from 'lucide-react';
import { useNavigate } from 'react-router-dom';
import { saveToStore } from '../lib/init';
interface SettingsProps {
apiKey: string;
setApiKey: (key: string) => void;
isDarkMode: boolean;
toggleTheme: () => void;
}
const Settings: React.FC<SettingsProps> = ({
apiKey,
setApiKey,
isDarkMode,
toggleTheme,
}) => {
const navigate = useNavigate();
const [localApiKey, setLocalApiKey] = useState(apiKey);
useEffect(() => {
setLocalApiKey(apiKey);
}, [apiKey]);
const handleSave = async () => {
console.log('💾 Saving API key:', localApiKey ? '***configured***' : 'empty');
setApiKey(localApiKey);
// Save API key to persistent store
try {
await saveToStore({ apiKey: localApiKey });
console.log('✅ API key saved to store successfully');
} catch (error) {
console.error('❌ Failed to save API key:', error);
// Don't navigate if save failed
return;
}
// Navigate back to main view
navigate('/');
};
return (
<div className="min-h-screen bg-gradient-to-br from-indigo-50 via-white to-cyan-50 dark:from-slate-900 dark:via-slate-800 dark:to-indigo-900 flex flex-col items-center p-6 transition-colors duration-500">
{/* Background decoration */}
<div className="fixed inset-0 overflow-hidden pointer-events-none">
<div className="absolute -top-40 -right-40 w-80 h-80 bg-gradient-to-br from-indigo-200/30 to-purple-200/30 dark:from-indigo-500/20 dark:to-purple-500/20 rounded-full blur-3xl"></div>
<div className="absolute -bottom-40 -left-40 w-80 h-80 bg-gradient-to-tr from-cyan-200/30 to-blue-200/30 dark:from-cyan-500/20 dark:to-blue-500/20 rounded-full blur-3xl"></div>
</div>
<div className="w-full max-w-2xl relative z-10 mt-8">
{/* Header */}
<div className="mb-8 space-y-4">
<div className="flex items-center gap-4">
<button
onClick={() => navigate('/')}
className="glass-button p-2 sm:p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title="Back to Image Wizard"
>
<ArrowLeft className="w-4 h-4 sm:w-5 sm:h-5 text-slate-700 dark:text-slate-300" />
</button>
<h1 className="text-2xl md:text-3xl font-bold accent-text drop-shadow-sm">Settings</h1>
</div>
</div>
{/* Settings Form */}
<div className="glass-card p-8 glass-shimmer shadow-2xl space-y-6">
{/* API Key Section */}
<div className="space-y-4">
<div>
<label htmlFor="api-key" className="block text-sm font-semibold text-slate-700 dark:text-slate-300 mb-2">
Google AI API Key
</label>
<div className="space-y-2">
<input
id="api-key"
type="password"
value={localApiKey}
onChange={(e) => setLocalApiKey(e.target.value)}
placeholder="Enter your Google AI API key"
className="w-full glass-input p-4 rounded-xl"
/>
<div className="flex items-center gap-2">
<div className={`h-2 w-2 rounded-full ${localApiKey ? 'bg-green-500' : 'bg-red-500'}`}></div>
<span className="text-xs text-slate-500 dark:text-slate-400">
{localApiKey ? 'API key configured' : 'API key required for image generation'}
</span>
</div>
</div>
<p className="text-xs text-slate-500 dark:text-slate-400 mt-2">
Get your API key from{' '}
<a
href="https://aistudio.google.com/app/apikey"
target="_blank"
rel="noopener noreferrer"
className="text-blue-600 dark:text-blue-400 hover:underline"
>
Google AI Studio
</a>
</p>
</div>
</div>
{/* Theme Section */}
<div className="border-t border-slate-200/50 dark:border-slate-700/50 pt-6">
<div className="flex items-center justify-between">
<div>
<h3 className="text-sm font-semibold text-slate-700 dark:text-slate-300">Theme</h3>
<p className="text-xs text-slate-500 dark:text-slate-400">Choose your preferred color scheme</p>
</div>
<button
onClick={toggleTheme}
className="glass-button p-3 rounded-xl hover:shadow-lg transition-all duration-300"
title={isDarkMode ? 'Switch to Light Mode' : 'Switch to Dark Mode'}
>
{isDarkMode ? (
<svg className="w-5 h-5 text-slate-300" fill="currentColor" viewBox="0 0 20 20">
<path
fillRule="evenodd"
d="M10 2a1 1 0 011 1v1a1 1 0 11-2 0V3a1 1 0 011-1zm4 8a4 4 0 11-8 0 4 4 0 018 0zm-.464 4.95l.707.707a1 1 0 001.414-1.414l-.707-.707a1 1 0 00-1.414 1.414zm2.12-10.607a1 1 0 010 1.414l-.706.707a1 1 0 11-1.414-1.414l.707-.707a1 1 0 011.414 0zM17 11a1 1 0 100-2h-1a1 1 0 100 2h1zm-7 4a1 1 0 011 1v1a1 1 0 11-2 0v-1a1 1 0 011-1zM5.05 6.464A1 1 0 106.465 5.05l-.708-.707a1 1 0 00-1.414 1.414l.707.707zm1.414 8.486l-.707.707a1 1 0 01-1.414-1.414l.707-.707a1 1 0 011.414 1.414zM4 11a1 1 0 100-2H3a1 1 0 000 2h1z"
clipRule="evenodd"
/>
</svg>
) : (
<svg className="w-5 h-5 text-slate-700" fill="currentColor" viewBox="0 0 20 20">
<path d="M17.293 13.293A8 8 0 016.707 2.707a8.001 8.001 0 1010.586 10.586z" />
</svg>
)}
</button>
</div>
</div>
{/* Save Button */}
<div className="border-t border-slate-200/50 dark:border-slate-700/50 pt-6">
<button
onClick={handleSave}
className="w-full glass-button bg-gradient-to-r from-indigo-500 to-purple-600 hover:from-indigo-600 hover:to-purple-700 text-white px-6 py-3 rounded-xl font-semibold transition-all duration-300"
>
Save Settings
</button>
</div>
</div>
</div>
</div>
);
};
export default Settings;

View File

@ -0,0 +1,46 @@
import React from 'react';
import { cn } from '@/lib/utils';
interface LedBarProps extends React.HTMLAttributes<HTMLDivElement> {
value: number;
max?: number;
}
const LedBar = React.forwardRef<HTMLDivElement, LedBarProps>(
({ className, value, max = 100, ...props }, ref) => {
const percentage = max > 0 ? (value / max) * 100 : 0;
const isOverload = percentage > 100;
const displayPercentage = Math.min(percentage, 200);
const normalWidth = isOverload ? '100%' : `${displayPercentage}%`;
const overloadWidth = isOverload ? `${Math.min(displayPercentage - 100, 100)}%` : '0%';
return (
<div
ref={ref}
className={cn('relative h-4 w-full overflow-hidden rounded-full bg-slate-200', className)}
{...props}
>
<div
className="h-full bg-green-500 transition-all duration-300"
style={{ width: normalWidth }}
/>
{isOverload && (
<div
className="absolute top-0 left-0 h-full bg-yellow-400 transition-all duration-300"
style={{ width: normalWidth }}
>
<div
className="h-full bg-red-500 transition-all duration-300"
style={{ width: overloadWidth }}
/>
</div>
)}
</div>
);
}
);
LedBar.displayName = 'LedBar';
export { LedBar };

View File

@ -0,0 +1,56 @@
import * as React from "react"
import * as AccordionPrimitive from "@radix-ui/react-accordion"
import { ChevronDown } from "lucide-react"
import { cn } from "@/lib/utils"
const Accordion = AccordionPrimitive.Root
const AccordionItem = React.forwardRef<
React.ElementRef<typeof AccordionPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Item>
>(({ className, ...props }, ref) => (
<AccordionPrimitive.Item
ref={ref}
className={cn("border-b", className)}
{...props}
/>
))
AccordionItem.displayName = "AccordionItem"
const AccordionTrigger = React.forwardRef<
React.ElementRef<typeof AccordionPrimitive.Trigger>,
React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Trigger>
>(({ className, children, ...props }, ref) => (
<AccordionPrimitive.Header className="flex">
<AccordionPrimitive.Trigger
ref={ref}
className={cn(
"flex flex-1 items-center justify-between py-4 font-medium transition-all hover:underline [&[data-state=open]>svg]:rotate-180",
className
)}
{...props}
>
{children}
<ChevronDown className="h-4 w-4 shrink-0 transition-transform duration-200" />
</AccordionPrimitive.Trigger>
</AccordionPrimitive.Header>
))
AccordionTrigger.displayName = AccordionPrimitive.Trigger.displayName
const AccordionContent = React.forwardRef<
React.ElementRef<typeof AccordionPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof AccordionPrimitive.Content>
>(({ className, children, ...props }, ref) => (
<AccordionPrimitive.Content
ref={ref}
className="overflow-hidden text-sm transition-all data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down"
{...props}
>
<div className={cn("pb-4 pt-0", className)}>{children}</div>
</AccordionPrimitive.Content>
))
AccordionContent.displayName = AccordionPrimitive.Content.displayName
export { Accordion, AccordionItem, AccordionTrigger, AccordionContent }

View File

@ -0,0 +1,139 @@
import * as React from "react"
import * as AlertDialogPrimitive from "@radix-ui/react-alert-dialog"
import { cn } from "@/lib/utils"
import { buttonVariants } from "@/components/ui/button"
const AlertDialog = AlertDialogPrimitive.Root
const AlertDialogTrigger = AlertDialogPrimitive.Trigger
const AlertDialogPortal = AlertDialogPrimitive.Portal
const AlertDialogOverlay = React.forwardRef<
React.ElementRef<typeof AlertDialogPrimitive.Overlay>,
React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Overlay>
>(({ className, ...props }, ref) => (
<AlertDialogPrimitive.Overlay
className={cn(
"fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
className
)}
{...props}
ref={ref}
/>
))
AlertDialogOverlay.displayName = AlertDialogPrimitive.Overlay.displayName
const AlertDialogContent = React.forwardRef<
React.ElementRef<typeof AlertDialogPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Content>
>(({ className, ...props }, ref) => (
<AlertDialogPortal>
<AlertDialogOverlay />
<AlertDialogPrimitive.Content
ref={ref}
className={cn(
"fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
className
)}
{...props}
/>
</AlertDialogPortal>
))
AlertDialogContent.displayName = AlertDialogPrimitive.Content.displayName
const AlertDialogHeader = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn(
"flex flex-col space-y-2 text-center sm:text-left",
className
)}
{...props}
/>
)
AlertDialogHeader.displayName = "AlertDialogHeader"
const AlertDialogFooter = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn(
"flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
className
)}
{...props}
/>
)
AlertDialogFooter.displayName = "AlertDialogFooter"
const AlertDialogTitle = React.forwardRef<
React.ElementRef<typeof AlertDialogPrimitive.Title>,
React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Title>
>(({ className, ...props }, ref) => (
<AlertDialogPrimitive.Title
ref={ref}
className={cn("text-lg font-semibold", className)}
{...props}
/>
))
AlertDialogTitle.displayName = AlertDialogPrimitive.Title.displayName
const AlertDialogDescription = React.forwardRef<
React.ElementRef<typeof AlertDialogPrimitive.Description>,
React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Description>
>(({ className, ...props }, ref) => (
<AlertDialogPrimitive.Description
ref={ref}
className={cn("text-sm text-muted-foreground", className)}
{...props}
/>
))
AlertDialogDescription.displayName =
AlertDialogPrimitive.Description.displayName
const AlertDialogAction = React.forwardRef<
React.ElementRef<typeof AlertDialogPrimitive.Action>,
React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Action>
>(({ className, ...props }, ref) => (
<AlertDialogPrimitive.Action
ref={ref}
className={cn(buttonVariants(), className)}
{...props}
/>
))
AlertDialogAction.displayName = AlertDialogPrimitive.Action.displayName
const AlertDialogCancel = React.forwardRef<
React.ElementRef<typeof AlertDialogPrimitive.Cancel>,
React.ComponentPropsWithoutRef<typeof AlertDialogPrimitive.Cancel>
>(({ className, ...props }, ref) => (
<AlertDialogPrimitive.Cancel
ref={ref}
className={cn(
buttonVariants({ variant: "outline" }),
"mt-2 sm:mt-0",
className
)}
{...props}
/>
))
AlertDialogCancel.displayName = AlertDialogPrimitive.Cancel.displayName
export {
AlertDialog,
AlertDialogPortal,
AlertDialogOverlay,
AlertDialogTrigger,
AlertDialogContent,
AlertDialogHeader,
AlertDialogFooter,
AlertDialogTitle,
AlertDialogDescription,
AlertDialogAction,
AlertDialogCancel,
}

View File

@ -0,0 +1,59 @@
import * as React from "react"
import { cva, type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"
const alertVariants = cva(
"relative w-full rounded-lg border p-4 [&>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",
destructive:
"border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
},
},
defaultVariants: {
variant: "default",
},
}
)
const Alert = React.forwardRef<
HTMLDivElement,
React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
>(({ className, variant, ...props }, ref) => (
<div
ref={ref}
role="alert"
className={cn(alertVariants({ variant }), className)}
{...props}
/>
))
Alert.displayName = "Alert"
const AlertTitle = React.forwardRef<
HTMLParagraphElement,
React.HTMLAttributes<HTMLHeadingElement>
>(({ className, ...props }, ref) => (
<h5
ref={ref}
className={cn("mb-1 font-medium leading-none tracking-tight", className)}
{...props}
/>
))
AlertTitle.displayName = "AlertTitle"
const AlertDescription = React.forwardRef<
HTMLParagraphElement,
React.HTMLAttributes<HTMLParagraphElement>
>(({ className, ...props }, ref) => (
<div
ref={ref}
className={cn("text-sm [&_p]:leading-relaxed", className)}
{...props}
/>
))
AlertDescription.displayName = "AlertDescription"
export { Alert, AlertTitle, AlertDescription }

View File

@ -0,0 +1,5 @@
import * as AspectRatioPrimitive from "@radix-ui/react-aspect-ratio"
const AspectRatio = AspectRatioPrimitive.Root
export { AspectRatio }

View File

@ -0,0 +1,48 @@
import * as React from "react"
import * as AvatarPrimitive from "@radix-ui/react-avatar"
import { cn } from "@/lib/utils"
const Avatar = React.forwardRef<
React.ElementRef<typeof AvatarPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>
>(({ className, ...props }, ref) => (
<AvatarPrimitive.Root
ref={ref}
className={cn(
"relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full",
className
)}
{...props}
/>
))
Avatar.displayName = AvatarPrimitive.Root.displayName
const AvatarImage = React.forwardRef<
React.ElementRef<typeof AvatarPrimitive.Image>,
React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>
>(({ className, ...props }, ref) => (
<AvatarPrimitive.Image
ref={ref}
className={cn("aspect-square h-full w-full", className)}
{...props}
/>
))
AvatarImage.displayName = AvatarPrimitive.Image.displayName
const AvatarFallback = React.forwardRef<
React.ElementRef<typeof AvatarPrimitive.Fallback>,
React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>
>(({ className, ...props }, ref) => (
<AvatarPrimitive.Fallback
ref={ref}
className={cn(
"flex h-full w-full items-center justify-center rounded-full bg-muted",
className
)}
{...props}
/>
))
AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName
export { Avatar, AvatarImage, AvatarFallback }

View File

@ -0,0 +1,36 @@
import * as React from "react"
import { cva, type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"
const badgeVariants = cva(
"inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2",
{
variants: {
variant: {
default:
"border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
secondary:
"border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
destructive:
"border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
outline: "text-foreground",
},
},
defaultVariants: {
variant: "default",
},
}
)
export interface BadgeProps
extends React.HTMLAttributes<HTMLDivElement>,
VariantProps<typeof badgeVariants> {}
function Badge({ className, variant, ...props }: BadgeProps) {
return (
<div className={cn(badgeVariants({ variant }), className)} {...props} />
)
}
export { Badge, badgeVariants }

View File

@ -0,0 +1,115 @@
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { ChevronRight, MoreHorizontal } from "lucide-react"
import { cn } from "@/lib/utils"
const Breadcrumb = React.forwardRef<
HTMLElement,
React.ComponentPropsWithoutRef<"nav"> & {
separator?: React.ReactNode
}
>(({ ...props }, ref) => <nav ref={ref} aria-label="breadcrumb" {...props} />)
Breadcrumb.displayName = "Breadcrumb"
const BreadcrumbList = React.forwardRef<
HTMLOListElement,
React.ComponentPropsWithoutRef<"ol">
>(({ className, ...props }, ref) => (
<ol
ref={ref}
className={cn(
"flex flex-wrap items-center gap-1.5 break-words text-sm text-muted-foreground sm:gap-2.5",
className
)}
{...props}
/>
))
BreadcrumbList.displayName = "BreadcrumbList"
const BreadcrumbItem = React.forwardRef<
HTMLLIElement,
React.ComponentPropsWithoutRef<"li">
>(({ className, ...props }, ref) => (
<li
ref={ref}
className={cn("inline-flex items-center gap-1.5", className)}
{...props}
/>
))
BreadcrumbItem.displayName = "BreadcrumbItem"
const BreadcrumbLink = React.forwardRef<
HTMLAnchorElement,
React.ComponentPropsWithoutRef<"a"> & {
asChild?: boolean
}
>(({ asChild, className, ...props }, ref) => {
const Comp = asChild ? Slot : "a"
return (
<Comp
ref={ref}
className={cn("transition-colors hover:text-foreground", className)}
{...props}
/>
)
})
BreadcrumbLink.displayName = "BreadcrumbLink"
const BreadcrumbPage = React.forwardRef<
HTMLSpanElement,
React.ComponentPropsWithoutRef<"span">
>(({ className, ...props }, ref) => (
<span
ref={ref}
role="link"
aria-disabled="true"
aria-current="page"
className={cn("font-normal text-foreground", className)}
{...props}
/>
))
BreadcrumbPage.displayName = "BreadcrumbPage"
const BreadcrumbSeparator = ({
children,
className,
...props
}: React.ComponentProps<"li">) => (
<li
role="presentation"
aria-hidden="true"
className={cn("[&>svg]:size-3.5", className)}
{...props}
>
{children ?? <ChevronRight />}
</li>
)
BreadcrumbSeparator.displayName = "BreadcrumbSeparator"
const BreadcrumbEllipsis = ({
className,
...props
}: React.ComponentProps<"span">) => (
<span
role="presentation"
aria-hidden="true"
className={cn("flex h-9 w-9 items-center justify-center", className)}
{...props}
>
<MoreHorizontal className="h-4 w-4" />
<span className="sr-only">More</span>
</span>
)
BreadcrumbEllipsis.displayName = "BreadcrumbElipssis"
export {
Breadcrumb,
BreadcrumbList,
BreadcrumbItem,
BreadcrumbLink,
BreadcrumbPage,
BreadcrumbSeparator,
BreadcrumbEllipsis,
}

View File

@ -0,0 +1,56 @@
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { cva, type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"
const buttonVariants = cva(
"inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
{
variants: {
variant: {
default: "bg-primary text-primary-foreground hover:bg-primary/90",
destructive:
"bg-destructive text-destructive-foreground hover:bg-destructive/90",
outline:
"border border-input bg-background hover:bg-accent hover:text-accent-foreground",
secondary:
"bg-secondary text-secondary-foreground hover:bg-secondary/80",
ghost: "hover:bg-accent hover:text-accent-foreground",
link: "text-primary underline-offset-4 hover:underline",
},
size: {
default: "h-10 px-4 py-2",
sm: "h-9 rounded-md px-3",
lg: "h-11 rounded-md px-8",
icon: "h-10 w-10",
},
},
defaultVariants: {
variant: "default",
size: "default",
},
}
)
export interface ButtonProps
extends React.ButtonHTMLAttributes<HTMLButtonElement>,
VariantProps<typeof buttonVariants> {
asChild?: boolean
}
const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
({ className, variant, size, asChild = false, ...props }, ref) => {
const Comp = asChild ? Slot : "button"
return (
<Comp
className={cn(buttonVariants({ variant, size, className }))}
ref={ref}
{...props}
/>
)
}
)
Button.displayName = "Button"
export { Button, buttonVariants }

View File

@ -0,0 +1,79 @@
import * as React from "react"
import { cn } from "@/lib/utils"
const Card = React.forwardRef<
HTMLDivElement,
React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
<div
ref={ref}
className={cn(
"rounded-lg border bg-card text-card-foreground shadow-sm",
className
)}
{...props}
/>
))
Card.displayName = "Card"
const CardHeader = React.forwardRef<
HTMLDivElement,
React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
<div
ref={ref}
className={cn("flex flex-col space-y-1.5 p-6", className)}
{...props}
/>
))
CardHeader.displayName = "CardHeader"
const CardTitle = React.forwardRef<
HTMLParagraphElement,
React.HTMLAttributes<HTMLHeadingElement>
>(({ className, ...props }, ref) => (
<h3
ref={ref}
className={cn(
"text-2xl font-semibold leading-none tracking-tight",
className
)}
{...props}
/>
))
CardTitle.displayName = "CardTitle"
const CardDescription = React.forwardRef<
HTMLParagraphElement,
React.HTMLAttributes<HTMLParagraphElement>
>(({ className, ...props }, ref) => (
<p
ref={ref}
className={cn("text-sm text-muted-foreground", className)}
{...props}
/>
))
CardDescription.displayName = "CardDescription"
const CardContent = React.forwardRef<
HTMLDivElement,
React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
<div ref={ref} className={cn("p-6 pt-0", className)} {...props} />
))
CardContent.displayName = "CardContent"
const CardFooter = React.forwardRef<
HTMLDivElement,
React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => (
<div
ref={ref}
className={cn("flex items-center p-6 pt-0", className)}
{...props}
/>
))
CardFooter.displayName = "CardFooter"
export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }

View File

@ -0,0 +1,28 @@
import * as React from "react"
import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
import { Check } from "lucide-react"
import { cn } from "@/lib/utils"
const Checkbox = React.forwardRef<
React.ElementRef<typeof CheckboxPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
>(({ className, ...props }, ref) => (
<CheckboxPrimitive.Root
ref={ref}
className={cn(
"peer h-4 w-4 shrink-0 rounded-sm border border-primary ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
className
)}
{...props}
>
<CheckboxPrimitive.Indicator
className={cn("flex items-center justify-center text-current")}
>
<Check className="h-4 w-4" />
</CheckboxPrimitive.Indicator>
</CheckboxPrimitive.Root>
))
Checkbox.displayName = CheckboxPrimitive.Root.displayName
export { Checkbox }

View File

@ -0,0 +1,9 @@
import * as CollapsiblePrimitive from "@radix-ui/react-collapsible"
const Collapsible = CollapsiblePrimitive.Root
const CollapsibleTrigger = CollapsiblePrimitive.CollapsibleTrigger
const CollapsibleContent = CollapsiblePrimitive.CollapsibleContent
export { Collapsible, CollapsibleTrigger, CollapsibleContent }

View File

@ -0,0 +1,153 @@
import * as React from "react"
import { type DialogProps } from "@radix-ui/react-dialog"
import { Command as CommandPrimitive } from "cmdk"
import { Search } from "lucide-react"
import { cn } from "@/lib/utils"
import { Dialog, DialogContent } from "@/components/ui/dialog"
const Command = React.forwardRef<
React.ElementRef<typeof CommandPrimitive>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive>
>(({ className, ...props }, ref) => (
<CommandPrimitive
ref={ref}
className={cn(
"flex h-full w-full flex-col overflow-hidden rounded-md bg-popover text-popover-foreground",
className
)}
{...props}
/>
))
Command.displayName = CommandPrimitive.displayName
interface CommandDialogProps extends DialogProps {}
const CommandDialog = ({ children, ...props }: CommandDialogProps) => {
return (
<Dialog {...props}>
<DialogContent className="overflow-hidden p-0 shadow-lg">
<Command className="[&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground [&_[cmdk-group]:not([hidden])_~[cmdk-group]]:pt-0 [&_[cmdk-group]]:px-2 [&_[cmdk-input-wrapper]_svg]:h-5 [&_[cmdk-input-wrapper]_svg]:w-5 [&_[cmdk-input]]:h-12 [&_[cmdk-item]]:px-2 [&_[cmdk-item]]:py-3 [&_[cmdk-item]_svg]:h-5 [&_[cmdk-item]_svg]:w-5">
{children}
</Command>
</DialogContent>
</Dialog>
)
}
const CommandInput = React.forwardRef<
React.ElementRef<typeof CommandPrimitive.Input>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive.Input>
>(({ className, ...props }, ref) => (
<div className="flex items-center border-b px-3" cmdk-input-wrapper="">
<Search className="mr-2 h-4 w-4 shrink-0 opacity-50" />
<CommandPrimitive.Input
ref={ref}
className={cn(
"flex h-11 w-full rounded-md bg-transparent py-3 text-sm outline-none placeholder:text-muted-foreground disabled:cursor-not-allowed disabled:opacity-50",
className
)}
{...props}
/>
</div>
))
CommandInput.displayName = CommandPrimitive.Input.displayName
const CommandList = React.forwardRef<
React.ElementRef<typeof CommandPrimitive.List>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive.List>
>(({ className, ...props }, ref) => (
<CommandPrimitive.List
ref={ref}
className={cn("max-h-[300px] overflow-y-auto overflow-x-hidden", className)}
{...props}
/>
))
CommandList.displayName = CommandPrimitive.List.displayName
const CommandEmpty = React.forwardRef<
React.ElementRef<typeof CommandPrimitive.Empty>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive.Empty>
>((props, ref) => (
<CommandPrimitive.Empty
ref={ref}
className="py-6 text-center text-sm"
{...props}
/>
))
CommandEmpty.displayName = CommandPrimitive.Empty.displayName
const CommandGroup = React.forwardRef<
React.ElementRef<typeof CommandPrimitive.Group>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive.Group>
>(({ className, ...props }, ref) => (
<CommandPrimitive.Group
ref={ref}
className={cn(
"overflow-hidden p-1 text-foreground [&_[cmdk-group-heading]]:px-2 [&_[cmdk-group-heading]]:py-1.5 [&_[cmdk-group-heading]]:text-xs [&_[cmdk-group-heading]]:font-medium [&_[cmdk-group-heading]]:text-muted-foreground",
className
)}
{...props}
/>
))
CommandGroup.displayName = CommandPrimitive.Group.displayName
const CommandSeparator = React.forwardRef<
React.ElementRef<typeof CommandPrimitive.Separator>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive.Separator>
>(({ className, ...props }, ref) => (
<CommandPrimitive.Separator
ref={ref}
className={cn("-mx-1 h-px bg-border", className)}
{...props}
/>
))
CommandSeparator.displayName = CommandPrimitive.Separator.displayName
const CommandItem = React.forwardRef<
React.ElementRef<typeof CommandPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof CommandPrimitive.Item>
>(({ className, ...props }, ref) => (
<CommandPrimitive.Item
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none data-[disabled=true]:pointer-events-none data-[selected='true']:bg-accent data-[selected=true]:text-accent-foreground data-[disabled=true]:opacity-50",
className
)}
{...props}
/>
))
CommandItem.displayName = CommandPrimitive.Item.displayName
const CommandShortcut = ({
className,
...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
return (
<span
className={cn(
"ml-auto text-xs tracking-widest text-muted-foreground",
className
)}
{...props}
/>
)
}
CommandShortcut.displayName = "CommandShortcut"
export {
Command,
CommandDialog,
CommandInput,
CommandList,
CommandEmpty,
CommandGroup,
CommandItem,
CommandShortcut,
CommandSeparator,
}

View File

@ -0,0 +1,198 @@
import * as React from "react"
import * as ContextMenuPrimitive from "@radix-ui/react-context-menu"
import { Check, ChevronRight, Circle } from "lucide-react"
import { cn } from "@/lib/utils"
const ContextMenu = ContextMenuPrimitive.Root
const ContextMenuTrigger = ContextMenuPrimitive.Trigger
const ContextMenuGroup = ContextMenuPrimitive.Group
const ContextMenuPortal = ContextMenuPrimitive.Portal
const ContextMenuSub = ContextMenuPrimitive.Sub
const ContextMenuRadioGroup = ContextMenuPrimitive.RadioGroup
const ContextMenuSubTrigger = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.SubTrigger>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubTrigger> & {
inset?: boolean
}
>(({ className, inset, children, ...props }, ref) => (
<ContextMenuPrimitive.SubTrigger
ref={ref}
className={cn(
"flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground",
inset && "pl-8",
className
)}
{...props}
>
{children}
<ChevronRight className="ml-auto h-4 w-4" />
</ContextMenuPrimitive.SubTrigger>
))
ContextMenuSubTrigger.displayName = ContextMenuPrimitive.SubTrigger.displayName
const ContextMenuSubContent = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.SubContent>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubContent>
>(({ className, ...props }, ref) => (
<ContextMenuPrimitive.SubContent
ref={ref}
className={cn(
"z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
))
ContextMenuSubContent.displayName = ContextMenuPrimitive.SubContent.displayName
const ContextMenuContent = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content>
>(({ className, ...props }, ref) => (
<ContextMenuPrimitive.Portal>
<ContextMenuPrimitive.Content
ref={ref}
className={cn(
"z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md animate-in fade-in-80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
</ContextMenuPrimitive.Portal>
))
ContextMenuContent.displayName = ContextMenuPrimitive.Content.displayName
const ContextMenuItem = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item> & {
inset?: boolean
}
>(({ className, inset, ...props }, ref) => (
<ContextMenuPrimitive.Item
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
inset && "pl-8",
className
)}
{...props}
/>
))
ContextMenuItem.displayName = ContextMenuPrimitive.Item.displayName
const ContextMenuCheckboxItem = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.CheckboxItem>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.CheckboxItem>
>(({ className, children, checked, ...props }, ref) => (
<ContextMenuPrimitive.CheckboxItem
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
checked={checked}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<ContextMenuPrimitive.ItemIndicator>
<Check className="h-4 w-4" />
</ContextMenuPrimitive.ItemIndicator>
</span>
{children}
</ContextMenuPrimitive.CheckboxItem>
))
ContextMenuCheckboxItem.displayName =
ContextMenuPrimitive.CheckboxItem.displayName
const ContextMenuRadioItem = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.RadioItem>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.RadioItem>
>(({ className, children, ...props }, ref) => (
<ContextMenuPrimitive.RadioItem
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<ContextMenuPrimitive.ItemIndicator>
<Circle className="h-2 w-2 fill-current" />
</ContextMenuPrimitive.ItemIndicator>
</span>
{children}
</ContextMenuPrimitive.RadioItem>
))
ContextMenuRadioItem.displayName = ContextMenuPrimitive.RadioItem.displayName
const ContextMenuLabel = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.Label>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Label> & {
inset?: boolean
}
>(({ className, inset, ...props }, ref) => (
<ContextMenuPrimitive.Label
ref={ref}
className={cn(
"px-2 py-1.5 text-sm font-semibold text-foreground",
inset && "pl-8",
className
)}
{...props}
/>
))
ContextMenuLabel.displayName = ContextMenuPrimitive.Label.displayName
const ContextMenuSeparator = React.forwardRef<
React.ElementRef<typeof ContextMenuPrimitive.Separator>,
React.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Separator>
>(({ className, ...props }, ref) => (
<ContextMenuPrimitive.Separator
ref={ref}
className={cn("-mx-1 my-1 h-px bg-border", className)}
{...props}
/>
))
ContextMenuSeparator.displayName = ContextMenuPrimitive.Separator.displayName
const ContextMenuShortcut = ({
className,
...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
return (
<span
className={cn(
"ml-auto text-xs tracking-widest text-muted-foreground",
className
)}
{...props}
/>
)
}
ContextMenuShortcut.displayName = "ContextMenuShortcut"
export {
ContextMenu,
ContextMenuTrigger,
ContextMenuContent,
ContextMenuItem,
ContextMenuCheckboxItem,
ContextMenuRadioItem,
ContextMenuLabel,
ContextMenuSeparator,
ContextMenuShortcut,
ContextMenuGroup,
ContextMenuPortal,
ContextMenuSub,
ContextMenuSubContent,
ContextMenuSubTrigger,
ContextMenuRadioGroup,
}

View File

@ -0,0 +1,120 @@
import * as React from "react"
import * as DialogPrimitive from "@radix-ui/react-dialog"
import { X } from "lucide-react"
import { cn } from "@/lib/utils"
const Dialog = DialogPrimitive.Root
const DialogTrigger = DialogPrimitive.Trigger
const DialogPortal = DialogPrimitive.Portal
const DialogClose = DialogPrimitive.Close
const DialogOverlay = React.forwardRef<
React.ElementRef<typeof DialogPrimitive.Overlay>,
React.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay>
>(({ className, ...props }, ref) => (
<DialogPrimitive.Overlay
ref={ref}
className={cn(
"fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
className
)}
{...props}
/>
))
DialogOverlay.displayName = DialogPrimitive.Overlay.displayName
const DialogContent = React.forwardRef<
React.ElementRef<typeof DialogPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>
>(({ className, children, ...props }, ref) => (
<DialogPortal>
<DialogOverlay />
<DialogPrimitive.Content
ref={ref}
className={cn(
"fixed left-[50%] top-[50%] z-50 grid w-full max-w-lg translate-x-[-50%] translate-y-[-50%] gap-4 border bg-background p-6 shadow-lg duration-200 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[state=closed]:slide-out-to-left-1/2 data-[state=closed]:slide-out-to-top-[48%] data-[state=open]:slide-in-from-left-1/2 data-[state=open]:slide-in-from-top-[48%] sm:rounded-lg",
className
)}
{...props}
>
{children}
<DialogPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-accent data-[state=open]:text-muted-foreground">
<X className="h-4 w-4" />
<span className="sr-only">Close</span>
</DialogPrimitive.Close>
</DialogPrimitive.Content>
</DialogPortal>
))
DialogContent.displayName = DialogPrimitive.Content.displayName
const DialogHeader = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn(
"flex flex-col space-y-1.5 text-center sm:text-left",
className
)}
{...props}
/>
)
DialogHeader.displayName = "DialogHeader"
const DialogFooter = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn(
"flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
className
)}
{...props}
/>
)
DialogFooter.displayName = "DialogFooter"
const DialogTitle = React.forwardRef<
React.ElementRef<typeof DialogPrimitive.Title>,
React.ComponentPropsWithoutRef<typeof DialogPrimitive.Title>
>(({ className, ...props }, ref) => (
<DialogPrimitive.Title
ref={ref}
className={cn(
"text-lg font-semibold leading-none tracking-tight",
className
)}
{...props}
/>
))
DialogTitle.displayName = DialogPrimitive.Title.displayName
const DialogDescription = React.forwardRef<
React.ElementRef<typeof DialogPrimitive.Description>,
React.ComponentPropsWithoutRef<typeof DialogPrimitive.Description>
>(({ className, ...props }, ref) => (
<DialogPrimitive.Description
ref={ref}
className={cn("text-sm text-muted-foreground", className)}
{...props}
/>
))
DialogDescription.displayName = DialogPrimitive.Description.displayName
export {
Dialog,
DialogPortal,
DialogOverlay,
DialogClose,
DialogTrigger,
DialogContent,
DialogHeader,
DialogFooter,
DialogTitle,
DialogDescription,
}

View File

@ -0,0 +1,116 @@
import * as React from "react"
import { Drawer as DrawerPrimitive } from "vaul"
import { cn } from "@/lib/utils"
const Drawer = ({
shouldScaleBackground = true,
...props
}: React.ComponentProps<typeof DrawerPrimitive.Root>) => (
<DrawerPrimitive.Root
shouldScaleBackground={shouldScaleBackground}
{...props}
/>
)
Drawer.displayName = "Drawer"
const DrawerTrigger = DrawerPrimitive.Trigger
const DrawerPortal = DrawerPrimitive.Portal
const DrawerClose = DrawerPrimitive.Close
const DrawerOverlay = React.forwardRef<
React.ElementRef<typeof DrawerPrimitive.Overlay>,
React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Overlay>
>(({ className, ...props }, ref) => (
<DrawerPrimitive.Overlay
ref={ref}
className={cn("fixed inset-0 z-50 bg-black/80", className)}
{...props}
/>
))
DrawerOverlay.displayName = DrawerPrimitive.Overlay.displayName
const DrawerContent = React.forwardRef<
React.ElementRef<typeof DrawerPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Content>
>(({ className, children, ...props }, ref) => (
<DrawerPortal>
<DrawerOverlay />
<DrawerPrimitive.Content
ref={ref}
className={cn(
"fixed inset-x-0 bottom-0 z-50 mt-24 flex h-auto flex-col rounded-t-[10px] border bg-background",
className
)}
{...props}
>
<div className="mx-auto mt-4 h-2 w-[100px] rounded-full bg-muted" />
{children}
</DrawerPrimitive.Content>
</DrawerPortal>
))
DrawerContent.displayName = "DrawerContent"
const DrawerHeader = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn("grid gap-1.5 p-4 text-center sm:text-left", className)}
{...props}
/>
)
DrawerHeader.displayName = "DrawerHeader"
const DrawerFooter = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn("mt-auto flex flex-col gap-2 p-4", className)}
{...props}
/>
)
DrawerFooter.displayName = "DrawerFooter"
const DrawerTitle = React.forwardRef<
React.ElementRef<typeof DrawerPrimitive.Title>,
React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Title>
>(({ className, ...props }, ref) => (
<DrawerPrimitive.Title
ref={ref}
className={cn(
"text-lg font-semibold leading-none tracking-tight",
className
)}
{...props}
/>
))
DrawerTitle.displayName = DrawerPrimitive.Title.displayName
const DrawerDescription = React.forwardRef<
React.ElementRef<typeof DrawerPrimitive.Description>,
React.ComponentPropsWithoutRef<typeof DrawerPrimitive.Description>
>(({ className, ...props }, ref) => (
<DrawerPrimitive.Description
ref={ref}
className={cn("text-sm text-muted-foreground", className)}
{...props}
/>
))
DrawerDescription.displayName = DrawerPrimitive.Description.displayName
export {
Drawer,
DrawerPortal,
DrawerOverlay,
DrawerTrigger,
DrawerClose,
DrawerContent,
DrawerHeader,
DrawerFooter,
DrawerTitle,
DrawerDescription,
}

View File

@ -0,0 +1,198 @@
import * as React from "react"
import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu"
import { Check, ChevronRight, Circle } from "lucide-react"
import { cn } from "@/lib/utils"
const DropdownMenu = DropdownMenuPrimitive.Root
const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger
const DropdownMenuGroup = DropdownMenuPrimitive.Group
const DropdownMenuPortal = DropdownMenuPrimitive.Portal
const DropdownMenuSub = DropdownMenuPrimitive.Sub
const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup
const DropdownMenuSubTrigger = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.SubTrigger>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubTrigger> & {
inset?: boolean
}
>(({ className, inset, children, ...props }, ref) => (
<DropdownMenuPrimitive.SubTrigger
ref={ref}
className={cn(
"flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent data-[state=open]:bg-accent",
inset && "pl-8",
className
)}
{...props}
>
{children}
<ChevronRight className="ml-auto h-4 w-4" />
</DropdownMenuPrimitive.SubTrigger>
))
DropdownMenuSubTrigger.displayName =
DropdownMenuPrimitive.SubTrigger.displayName
const DropdownMenuSubContent = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.SubContent>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.SubContent>
>(({ className, ...props }, ref) => (
<DropdownMenuPrimitive.SubContent
ref={ref}
className={cn(
"z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
))
DropdownMenuSubContent.displayName =
DropdownMenuPrimitive.SubContent.displayName
const DropdownMenuContent = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Content>
>(({ className, sideOffset = 4, ...props }, ref) => (
<DropdownMenuPrimitive.Portal>
<DropdownMenuPrimitive.Content
ref={ref}
sideOffset={sideOffset}
className={cn(
"z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
</DropdownMenuPrimitive.Portal>
))
DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName
const DropdownMenuItem = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Item> & {
inset?: boolean
}
>(({ className, inset, ...props }, ref) => (
<DropdownMenuPrimitive.Item
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
inset && "pl-8",
className
)}
{...props}
/>
))
DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName
const DropdownMenuCheckboxItem = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.CheckboxItem>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.CheckboxItem>
>(({ className, children, checked, ...props }, ref) => (
<DropdownMenuPrimitive.CheckboxItem
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
checked={checked}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<DropdownMenuPrimitive.ItemIndicator>
<Check className="h-4 w-4" />
</DropdownMenuPrimitive.ItemIndicator>
</span>
{children}
</DropdownMenuPrimitive.CheckboxItem>
))
DropdownMenuCheckboxItem.displayName =
DropdownMenuPrimitive.CheckboxItem.displayName
const DropdownMenuRadioItem = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.RadioItem>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.RadioItem>
>(({ className, children, ...props }, ref) => (
<DropdownMenuPrimitive.RadioItem
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none transition-colors focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<DropdownMenuPrimitive.ItemIndicator>
<Circle className="h-2 w-2 fill-current" />
</DropdownMenuPrimitive.ItemIndicator>
</span>
{children}
</DropdownMenuPrimitive.RadioItem>
))
DropdownMenuRadioItem.displayName = DropdownMenuPrimitive.RadioItem.displayName
const DropdownMenuLabel = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.Label>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Label> & {
inset?: boolean
}
>(({ className, inset, ...props }, ref) => (
<DropdownMenuPrimitive.Label
ref={ref}
className={cn(
"px-2 py-1.5 text-sm font-semibold",
inset && "pl-8",
className
)}
{...props}
/>
))
DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName
const DropdownMenuSeparator = React.forwardRef<
React.ElementRef<typeof DropdownMenuPrimitive.Separator>,
React.ComponentPropsWithoutRef<typeof DropdownMenuPrimitive.Separator>
>(({ className, ...props }, ref) => (
<DropdownMenuPrimitive.Separator
ref={ref}
className={cn("-mx-1 my-1 h-px bg-muted", className)}
{...props}
/>
))
DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName
const DropdownMenuShortcut = ({
className,
...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
return (
<span
className={cn("ml-auto text-xs tracking-widest opacity-60", className)}
{...props}
/>
)
}
DropdownMenuShortcut.displayName = "DropdownMenuShortcut"
export {
DropdownMenu,
DropdownMenuTrigger,
DropdownMenuContent,
DropdownMenuItem,
DropdownMenuCheckboxItem,
DropdownMenuRadioItem,
DropdownMenuLabel,
DropdownMenuSeparator,
DropdownMenuShortcut,
DropdownMenuGroup,
DropdownMenuPortal,
DropdownMenuSub,
DropdownMenuSubContent,
DropdownMenuSubTrigger,
DropdownMenuRadioGroup,
}

View File

@ -0,0 +1,176 @@
import * as React from "react"
import * as LabelPrimitive from "@radix-ui/react-label"
import { Slot } from "@radix-ui/react-slot"
import {
Controller,
ControllerProps,
FieldPath,
FieldValues,
FormProvider,
useFormContext,
} from "react-hook-form"
import { cn } from "@/lib/utils"
import { Label } from "@/components/ui/label"
const Form = FormProvider
type FormFieldContextValue<
TFieldValues extends FieldValues = FieldValues,
TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
> = {
name: TName
}
const FormFieldContext = React.createContext<FormFieldContextValue>(
{} as FormFieldContextValue
)
const FormField = <
TFieldValues extends FieldValues = FieldValues,
TName extends FieldPath<TFieldValues> = FieldPath<TFieldValues>
>({
...props
}: ControllerProps<TFieldValues, TName>) => {
return (
<FormFieldContext.Provider value={{ name: props.name }}>
<Controller {...props} />
</FormFieldContext.Provider>
)
}
const useFormField = () => {
const fieldContext = React.useContext(FormFieldContext)
const itemContext = React.useContext(FormItemContext)
const { getFieldState, formState } = useFormContext()
const fieldState = getFieldState(fieldContext.name, formState)
if (!fieldContext) {
throw new Error("useFormField should be used within <FormField>")
}
const { id } = itemContext
return {
id,
name: fieldContext.name,
formItemId: `${id}-form-item`,
formDescriptionId: `${id}-form-item-description`,
formMessageId: `${id}-form-item-message`,
...fieldState,
}
}
type FormItemContextValue = {
id: string
}
const FormItemContext = React.createContext<FormItemContextValue>(
{} as FormItemContextValue
)
const FormItem = React.forwardRef<
HTMLDivElement,
React.HTMLAttributes<HTMLDivElement>
>(({ className, ...props }, ref) => {
const id = React.useId()
return (
<FormItemContext.Provider value={{ id }}>
<div ref={ref} className={cn("space-y-2", className)} {...props} />
</FormItemContext.Provider>
)
})
FormItem.displayName = "FormItem"
const FormLabel = React.forwardRef<
React.ElementRef<typeof LabelPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>
>(({ className, ...props }, ref) => {
const { error, formItemId } = useFormField()
return (
<Label
ref={ref}
className={cn(error && "text-destructive", className)}
htmlFor={formItemId}
{...props}
/>
)
})
FormLabel.displayName = "FormLabel"
const FormControl = React.forwardRef<
React.ElementRef<typeof Slot>,
React.ComponentPropsWithoutRef<typeof Slot>
>(({ ...props }, ref) => {
const { error, formItemId, formDescriptionId, formMessageId } = useFormField()
return (
<Slot
ref={ref}
id={formItemId}
aria-describedby={
!error
? `${formDescriptionId}`
: `${formDescriptionId} ${formMessageId}`
}
aria-invalid={!!error}
{...props}
/>
)
})
FormControl.displayName = "FormControl"
const FormDescription = React.forwardRef<
HTMLParagraphElement,
React.HTMLAttributes<HTMLParagraphElement>
>(({ className, ...props }, ref) => {
const { formDescriptionId } = useFormField()
return (
<p
ref={ref}
id={formDescriptionId}
className={cn("text-sm text-muted-foreground", className)}
{...props}
/>
)
})
FormDescription.displayName = "FormDescription"
const FormMessage = React.forwardRef<
HTMLParagraphElement,
React.HTMLAttributes<HTMLParagraphElement>
>(({ className, children, ...props }, ref) => {
const { error, formMessageId } = useFormField()
const body = error ? String(error?.message) : children
if (!body) {
return null
}
return (
<p
ref={ref}
id={formMessageId}
className={cn("text-sm font-medium text-destructive", className)}
{...props}
>
{body}
</p>
)
})
FormMessage.displayName = "FormMessage"
export {
useFormField,
Form,
FormItem,
FormLabel,
FormControl,
FormDescription,
FormMessage,
FormField,
}

View File

@ -0,0 +1,27 @@
import * as React from "react"
import * as HoverCardPrimitive from "@radix-ui/react-hover-card"
import { cn } from "@/lib/utils"
const HoverCard = HoverCardPrimitive.Root
const HoverCardTrigger = HoverCardPrimitive.Trigger
const HoverCardContent = React.forwardRef<
React.ElementRef<typeof HoverCardPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof HoverCardPrimitive.Content>
>(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
<HoverCardPrimitive.Content
ref={ref}
align={align}
sideOffset={sideOffset}
className={cn(
"z-50 w-64 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
))
HoverCardContent.displayName = HoverCardPrimitive.Content.displayName
export { HoverCard, HoverCardTrigger, HoverCardContent }

View File

@ -0,0 +1,69 @@
import * as React from "react"
import { OTPInput, OTPInputContext } from "input-otp"
import { Dot } from "lucide-react"
import { cn } from "@/lib/utils"
const InputOTP = React.forwardRef<
React.ElementRef<typeof OTPInput>,
React.ComponentPropsWithoutRef<typeof OTPInput>
>(({ className, containerClassName, ...props }, ref) => (
<OTPInput
ref={ref}
containerClassName={cn(
"flex items-center gap-2 has-[:disabled]:opacity-50",
containerClassName
)}
className={cn("disabled:cursor-not-allowed", className)}
{...props}
/>
))
InputOTP.displayName = "InputOTP"
const InputOTPGroup = React.forwardRef<
React.ElementRef<"div">,
React.ComponentPropsWithoutRef<"div">
>(({ className, ...props }, ref) => (
<div ref={ref} className={cn("flex items-center", className)} {...props} />
))
InputOTPGroup.displayName = "InputOTPGroup"
const InputOTPSlot = React.forwardRef<
React.ElementRef<"div">,
React.ComponentPropsWithoutRef<"div"> & { index: number }
>(({ index, className, ...props }, ref) => {
const inputOTPContext = React.useContext(OTPInputContext)
const { char, hasFakeCaret, isActive } = inputOTPContext.slots[index]
return (
<div
ref={ref}
className={cn(
"relative flex h-10 w-10 items-center justify-center border-y border-r border-input text-sm transition-all first:rounded-l-md first:border-l last:rounded-r-md",
isActive && "z-10 ring-2 ring-ring ring-offset-background",
className
)}
{...props}
>
{char}
{hasFakeCaret && (
<div className="pointer-events-none absolute inset-0 flex items-center justify-center">
<div className="h-4 w-px animate-caret-blink bg-foreground duration-1000" />
</div>
)}
</div>
)
})
InputOTPSlot.displayName = "InputOTPSlot"
const InputOTPSeparator = React.forwardRef<
React.ElementRef<"div">,
React.ComponentPropsWithoutRef<"div">
>(({ ...props }, ref) => (
<div ref={ref} role="separator" {...props}>
<Dot />
</div>
))
InputOTPSeparator.displayName = "InputOTPSeparator"
export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator }

View File

@ -0,0 +1,22 @@
import * as React from "react"
import { cn } from "@/lib/utils"
const Input = React.forwardRef<HTMLInputElement, React.ComponentProps<"input">>(
({ className, type, ...props }, ref) => {
return (
<input
type={type}
className={cn(
"flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-base ring-offset-background file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
className
)}
ref={ref}
{...props}
/>
)
}
)
Input.displayName = "Input"
export { Input }

View File

@ -0,0 +1,24 @@
import * as React from "react"
import * as LabelPrimitive from "@radix-ui/react-label"
import { cva, type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"
const labelVariants = cva(
"text-sm font-medium leading-none peer-disabled:cursor-not-allowed peer-disabled:opacity-70"
)
const Label = React.forwardRef<
React.ElementRef<typeof LabelPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof LabelPrimitive.Root> &
VariantProps<typeof labelVariants>
>(({ className, ...props }, ref) => (
<LabelPrimitive.Root
ref={ref}
className={cn(labelVariants(), className)}
{...props}
/>
))
Label.displayName = LabelPrimitive.Root.displayName
export { Label }

View File

@ -0,0 +1,234 @@
import * as React from "react"
import * as MenubarPrimitive from "@radix-ui/react-menubar"
import { Check, ChevronRight, Circle } from "lucide-react"
import { cn } from "@/lib/utils"
const MenubarMenu = MenubarPrimitive.Menu
const MenubarGroup = MenubarPrimitive.Group
const MenubarPortal = MenubarPrimitive.Portal
const MenubarSub = MenubarPrimitive.Sub
const MenubarRadioGroup = MenubarPrimitive.RadioGroup
const Menubar = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Root>
>(({ className, ...props }, ref) => (
<MenubarPrimitive.Root
ref={ref}
className={cn(
"flex h-10 items-center space-x-1 rounded-md border bg-background p-1",
className
)}
{...props}
/>
))
Menubar.displayName = MenubarPrimitive.Root.displayName
const MenubarTrigger = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.Trigger>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Trigger>
>(({ className, ...props }, ref) => (
<MenubarPrimitive.Trigger
ref={ref}
className={cn(
"flex cursor-default select-none items-center rounded-sm px-3 py-1.5 text-sm font-medium outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground",
className
)}
{...props}
/>
))
MenubarTrigger.displayName = MenubarPrimitive.Trigger.displayName
const MenubarSubTrigger = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.SubTrigger>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubTrigger> & {
inset?: boolean
}
>(({ className, inset, children, ...props }, ref) => (
<MenubarPrimitive.SubTrigger
ref={ref}
className={cn(
"flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[state=open]:bg-accent data-[state=open]:text-accent-foreground",
inset && "pl-8",
className
)}
{...props}
>
{children}
<ChevronRight className="ml-auto h-4 w-4" />
</MenubarPrimitive.SubTrigger>
))
MenubarSubTrigger.displayName = MenubarPrimitive.SubTrigger.displayName
const MenubarSubContent = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.SubContent>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.SubContent>
>(({ className, ...props }, ref) => (
<MenubarPrimitive.SubContent
ref={ref}
className={cn(
"z-50 min-w-[8rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
))
MenubarSubContent.displayName = MenubarPrimitive.SubContent.displayName
const MenubarContent = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Content>
>(
(
{ className, align = "start", alignOffset = -4, sideOffset = 8, ...props },
ref
) => (
<MenubarPrimitive.Portal>
<MenubarPrimitive.Content
ref={ref}
align={align}
alignOffset={alignOffset}
sideOffset={sideOffset}
className={cn(
"z-50 min-w-[12rem] overflow-hidden rounded-md border bg-popover p-1 text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
</MenubarPrimitive.Portal>
)
)
MenubarContent.displayName = MenubarPrimitive.Content.displayName
const MenubarItem = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Item> & {
inset?: boolean
}
>(({ className, inset, ...props }, ref) => (
<MenubarPrimitive.Item
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm px-2 py-1.5 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
inset && "pl-8",
className
)}
{...props}
/>
))
MenubarItem.displayName = MenubarPrimitive.Item.displayName
const MenubarCheckboxItem = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.CheckboxItem>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.CheckboxItem>
>(({ className, children, checked, ...props }, ref) => (
<MenubarPrimitive.CheckboxItem
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
checked={checked}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<MenubarPrimitive.ItemIndicator>
<Check className="h-4 w-4" />
</MenubarPrimitive.ItemIndicator>
</span>
{children}
</MenubarPrimitive.CheckboxItem>
))
MenubarCheckboxItem.displayName = MenubarPrimitive.CheckboxItem.displayName
const MenubarRadioItem = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.RadioItem>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.RadioItem>
>(({ className, children, ...props }, ref) => (
<MenubarPrimitive.RadioItem
ref={ref}
className={cn(
"relative flex cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<MenubarPrimitive.ItemIndicator>
<Circle className="h-2 w-2 fill-current" />
</MenubarPrimitive.ItemIndicator>
</span>
{children}
</MenubarPrimitive.RadioItem>
))
MenubarRadioItem.displayName = MenubarPrimitive.RadioItem.displayName
const MenubarLabel = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.Label>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Label> & {
inset?: boolean
}
>(({ className, inset, ...props }, ref) => (
<MenubarPrimitive.Label
ref={ref}
className={cn(
"px-2 py-1.5 text-sm font-semibold",
inset && "pl-8",
className
)}
{...props}
/>
))
MenubarLabel.displayName = MenubarPrimitive.Label.displayName
const MenubarSeparator = React.forwardRef<
React.ElementRef<typeof MenubarPrimitive.Separator>,
React.ComponentPropsWithoutRef<typeof MenubarPrimitive.Separator>
>(({ className, ...props }, ref) => (
<MenubarPrimitive.Separator
ref={ref}
className={cn("-mx-1 my-1 h-px bg-muted", className)}
{...props}
/>
))
MenubarSeparator.displayName = MenubarPrimitive.Separator.displayName
const MenubarShortcut = ({
className,
...props
}: React.HTMLAttributes<HTMLSpanElement>) => {
return (
<span
className={cn(
"ml-auto text-xs tracking-widest text-muted-foreground",
className
)}
{...props}
/>
)
}
MenubarShortcut.displayname = "MenubarShortcut"
export {
Menubar,
MenubarMenu,
MenubarTrigger,
MenubarContent,
MenubarItem,
MenubarSeparator,
MenubarLabel,
MenubarCheckboxItem,
MenubarRadioGroup,
MenubarRadioItem,
MenubarPortal,
MenubarSubContent,
MenubarSubTrigger,
MenubarGroup,
MenubarSub,
MenubarShortcut,
}

View File

@ -0,0 +1,292 @@
import * as React from 'react';
import { cva, type VariantProps } from 'class-variance-authority';
import { CheckIcon, XCircle, ChevronDown, XIcon } from 'lucide-react';
import { cn } from '@/lib/utils';
import { Separator } from '@/components/ui/separator';
import { Button } from '@/components/ui/button';
import { Badge } from '@/components/ui/badge';
import {
Popover,
PopoverContent,
PopoverTrigger,
} from '@/components/ui/popover';
import {
Command,
CommandEmpty,
CommandGroup,
CommandInput,
CommandItem,
CommandList,
CommandSeparator,
} from '@/components/ui/command';
const multiSelectVariants = cva(
'm-1 transition ease-in-out delay-150 hover:-translate-y-1 hover:scale-110 duration-300',
{
variants: {
variant: {
default:
'border-foreground/10 text-foreground bg-card hover:bg-card/80',
secondary:
'border-foreground/10 bg-secondary text-secondary-foreground hover:bg-secondary/80',
destructive:
'border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80',
inverted: 'inverted',
},
},
defaultVariants: {
variant: 'default',
},
},
);
interface MultiSelectProps
extends React.ButtonHTMLAttributes<HTMLButtonElement>,
VariantProps<typeof multiSelectVariants> {
options: {
label: string;
value: string;
icon?: React.ComponentType<{ className?: string }>;
}[];
onValueChange: (value: string[]) => void;
defaultValue: string[];
placeholder?: string;
animation?: number;
maxCount?: number;
asChild?: boolean;
className?: string;
}
const MultipleSelector = React.forwardRef<
HTMLButtonElement,
MultiSelectProps
>(
(
{
options,
onValueChange,
variant,
defaultValue = [],
placeholder = 'Select options',
animation = 0,
maxCount = 3,
asChild = false,
className,
...props
},
ref,
) => {
const [selectedValues, setSelectedValues] =
React.useState<string[]>(defaultValue);
const [isPopoverOpen, setIsPopoverOpen] = React.useState(false);
const [isAnimating, setIsAnimating] = React.useState(false);
React.useEffect(() => {
if (JSON.stringify(selectedValues) !== JSON.stringify(defaultValue)) {
setSelectedValues(defaultValue);
}
}, [defaultValue, selectedValues]);
const handleInputKeyDown = (
event: React.KeyboardEvent<HTMLInputElement>,
) => {
if (event.key === 'Enter') {
setIsPopoverOpen(true);
} else if (
event.key === 'Backspace' &&
!event.currentTarget.value &&
selectedValues.length > 0
) {
const newSelectedValues = [...selectedValues];
newSelectedValues.pop();
setSelectedValues(newSelectedValues);
onValueChange(newSelectedValues);
}
};
const toggleOption = (value: string) => {
const newSelectedValues = selectedValues.includes(value)
? selectedValues.filter((v) => v !== value)
: [...selectedValues, value];
setSelectedValues(newSelectedValues);
onValueChange(newSelectedValues);
};
const handleClear = () => {
setSelectedValues([]);
onValueChange([]);
};
const handleTogglePopover = () => {
setIsPopoverOpen((prev) => !prev);
};
React.useEffect(() => {
if (animation > 0) {
setIsAnimating(true);
const timer = setTimeout(() => setIsAnimating(false), animation);
return () => clearTimeout(timer);
}
}, [selectedValues, animation]);
return (
<Popover open={isPopoverOpen} onOpenChange={setIsPopoverOpen}>
<PopoverTrigger asChild>
<Button
ref={ref}
{...props}
onClick={handleTogglePopover}
className={cn(
'flex w-full p-1 rounded-md border min-h-10 h-auto items-center justify-between bg-inherit hover:bg-inherit',
className,
)}
>
{selectedValues.length > 0 ? (
<div className="flex justify-between items-center w-full">
<div className="flex flex-wrap items-center">
{selectedValues.slice(0, maxCount).map((value) => {
const option = options.find((o) => o.value === value);
const IconComponent = option?.icon;
return (
<Badge
key={value}
className={cn(
isAnimating ? 'animate-bounce' : '',
multiSelectVariants({ variant }),
)}
style={{
animationDuration: `${animation}s`,
}}
>
{IconComponent && (
<IconComponent className="h-4 w-4 mr-2" />
)}
{option?.label}
<XCircle
className="ml-2 h-4 w-4 cursor-pointer"
onClick={(event) => {
event.stopPropagation();
toggleOption(value);
}}
/>
</Badge>
);
})}
{selectedValues.length > maxCount && (
<Badge
className={cn(
'bg-transparent text-foreground border-foreground/10',
isAnimating ? 'animate-bounce' : '',
multiSelectVariants({ variant }),
)}
style={{
animationDuration: `${animation}s`,
}}
>
{`+ ${selectedValues.length - maxCount} more`}
</Badge>
)}
</div>
<div className="flex items-center justify-between">
<XIcon
className="h-4 mx-2 cursor-pointer text-muted-foreground"
onClick={(event) => {
event.stopPropagation();
handleClear();
}}
/>
<Separator
orientation="vertical"
className="flex min-h-6 h-full"
/>
<ChevronDown className="h-4 mx-2 cursor-pointer text-muted-foreground" />
</div>
</div>
) : (
<div className="flex items-center justify-between w-full mx-auto">
<span className="text-sm text-muted-foreground mx-3">
{placeholder}
</span>
<ChevronDown className="h-4 cursor-pointer text-muted-foreground mx-2" />
</div>
)}
</Button>
</PopoverTrigger>
<PopoverContent
className="w-[var(--radix-popover-trigger-width)] p-0"
align="start"
>
<Command>
<CommandInput
placeholder="Search..."
onKeyDown={handleInputKeyDown}
/>
<CommandList>
<CommandEmpty>No results found.</CommandEmpty>
<CommandGroup>
{options && options.map((option) => {
const isSelected = selectedValues.includes(option.value);
return (
<CommandItem
key={option.value}
onSelect={() => toggleOption(option.value)}
style={{
pointerEvents: 'auto',
opacity: 1,
}}
className="cursor-pointer"
>
<div
className={cn(
'mr-2 flex h-4 w-4 items-center justify-center rounded-sm border border-primary',
isSelected
? 'bg-primary text-primary-foreground'
: 'opacity-50 [&_svg]:invisible',
)}
>
<CheckIcon className="h-4 w-4" />
</div>
{option.icon && (
<option.icon className="mr-2 h-4 w-4 text-muted-foreground" />
)}
<span>{option.label}</span>
</CommandItem>
);
})}
</CommandGroup>
{selectedValues.length > 0 && (
<>
<CommandSeparator />
<CommandGroup>
<CommandItem
onSelect={handleClear}
style={{
pointerEvents: 'auto',
opacity: 1,
}}
className="justify-center text-center cursor-pointer"
>
Clear
</CommandItem>
</CommandGroup>
</>
)}
</CommandList>
</Command>
</PopoverContent>
</Popover>
);
},
);
MultipleSelector.displayName = 'MultipleSelector';
export { MultipleSelector };
export type { Option };
// Add Option type definition
type Option = {
label: string;
value: string;
icon?: React.ComponentType<{ className?: string }>;
};

View File

@ -0,0 +1,128 @@
import * as React from "react"
import * as NavigationMenuPrimitive from "@radix-ui/react-navigation-menu"
import { cva } from "class-variance-authority"
import { ChevronDown } from "lucide-react"
import { cn } from "@/lib/utils"
const NavigationMenu = React.forwardRef<
React.ElementRef<typeof NavigationMenuPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Root>
>(({ className, children, ...props }, ref) => (
<NavigationMenuPrimitive.Root
ref={ref}
className={cn(
"relative z-10 flex max-w-max flex-1 items-center justify-center",
className
)}
{...props}
>
{children}
<NavigationMenuViewport />
</NavigationMenuPrimitive.Root>
))
NavigationMenu.displayName = NavigationMenuPrimitive.Root.displayName
const NavigationMenuList = React.forwardRef<
React.ElementRef<typeof NavigationMenuPrimitive.List>,
React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.List>
>(({ className, ...props }, ref) => (
<NavigationMenuPrimitive.List
ref={ref}
className={cn(
"group flex flex-1 list-none items-center justify-center space-x-1",
className
)}
{...props}
/>
))
NavigationMenuList.displayName = NavigationMenuPrimitive.List.displayName
const NavigationMenuItem = NavigationMenuPrimitive.Item
const navigationMenuTriggerStyle = cva(
"group inline-flex h-10 w-max items-center justify-center rounded-md bg-background px-4 py-2 text-sm font-medium transition-colors hover:bg-accent hover:text-accent-foreground focus:bg-accent focus:text-accent-foreground focus:outline-none disabled:pointer-events-none disabled:opacity-50 data-[active]:bg-accent/50 data-[state=open]:bg-accent/50"
)
const NavigationMenuTrigger = React.forwardRef<
React.ElementRef<typeof NavigationMenuPrimitive.Trigger>,
React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Trigger>
>(({ className, children, ...props }, ref) => (
<NavigationMenuPrimitive.Trigger
ref={ref}
className={cn(navigationMenuTriggerStyle(), "group", className)}
{...props}
>
{children}{" "}
<ChevronDown
className="relative top-[1px] ml-1 h-3 w-3 transition duration-200 group-data-[state=open]:rotate-180"
aria-hidden="true"
/>
</NavigationMenuPrimitive.Trigger>
))
NavigationMenuTrigger.displayName = NavigationMenuPrimitive.Trigger.displayName
const NavigationMenuContent = React.forwardRef<
React.ElementRef<typeof NavigationMenuPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Content>
>(({ className, ...props }, ref) => (
<NavigationMenuPrimitive.Content
ref={ref}
className={cn(
"left-0 top-0 w-full data-[motion^=from-]:animate-in data-[motion^=to-]:animate-out data-[motion^=from-]:fade-in data-[motion^=to-]:fade-out data-[motion=from-end]:slide-in-from-right-52 data-[motion=from-start]:slide-in-from-left-52 data-[motion=to-end]:slide-out-to-right-52 data-[motion=to-start]:slide-out-to-left-52 md:absolute md:w-auto ",
className
)}
{...props}
/>
))
NavigationMenuContent.displayName = NavigationMenuPrimitive.Content.displayName
const NavigationMenuLink = NavigationMenuPrimitive.Link
const NavigationMenuViewport = React.forwardRef<
React.ElementRef<typeof NavigationMenuPrimitive.Viewport>,
React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Viewport>
>(({ className, ...props }, ref) => (
<div className={cn("absolute left-0 top-full flex justify-center")}>
<NavigationMenuPrimitive.Viewport
className={cn(
"origin-top-center relative mt-1.5 h-[var(--radix-navigation-menu-viewport-height)] w-full overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-lg data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-90 md:w-[var(--radix-navigation-menu-viewport-width)]",
className
)}
ref={ref}
{...props}
/>
</div>
))
NavigationMenuViewport.displayName =
NavigationMenuPrimitive.Viewport.displayName
const NavigationMenuIndicator = React.forwardRef<
React.ElementRef<typeof NavigationMenuPrimitive.Indicator>,
React.ComponentPropsWithoutRef<typeof NavigationMenuPrimitive.Indicator>
>(({ className, ...props }, ref) => (
<NavigationMenuPrimitive.Indicator
ref={ref}
className={cn(
"top-full z-[1] flex h-1.5 items-end justify-center overflow-hidden data-[state=visible]:animate-in data-[state=hidden]:animate-out data-[state=hidden]:fade-out data-[state=visible]:fade-in",
className
)}
{...props}
>
<div className="relative top-[60%] h-2 w-2 rotate-45 rounded-tl-sm bg-border shadow-md" />
</NavigationMenuPrimitive.Indicator>
))
NavigationMenuIndicator.displayName =
NavigationMenuPrimitive.Indicator.displayName
export {
navigationMenuTriggerStyle,
NavigationMenu,
NavigationMenuList,
NavigationMenuItem,
NavigationMenuContent,
NavigationMenuTrigger,
NavigationMenuLink,
NavigationMenuIndicator,
NavigationMenuViewport,
}

View File

@ -0,0 +1,117 @@
import * as React from "react"
import { ChevronLeft, ChevronRight, MoreHorizontal } from "lucide-react"
import { cn } from "@/lib/utils"
import { ButtonProps, buttonVariants } from "@/components/ui/button"
const Pagination = ({ className, ...props }: React.ComponentProps<"nav">) => (
<nav
role="navigation"
aria-label="pagination"
className={cn("mx-auto flex w-full justify-center", className)}
{...props}
/>
)
Pagination.displayName = "Pagination"
const PaginationContent = React.forwardRef<
HTMLUListElement,
React.ComponentProps<"ul">
>(({ className, ...props }, ref) => (
<ul
ref={ref}
className={cn("flex flex-row items-center gap-1", className)}
{...props}
/>
))
PaginationContent.displayName = "PaginationContent"
const PaginationItem = React.forwardRef<
HTMLLIElement,
React.ComponentProps<"li">
>(({ className, ...props }, ref) => (
<li ref={ref} className={cn("", className)} {...props} />
))
PaginationItem.displayName = "PaginationItem"
type PaginationLinkProps = {
isActive?: boolean
} & Pick<ButtonProps, "size"> &
React.ComponentProps<"a">
const PaginationLink = ({
className,
isActive,
size = "icon",
...props
}: PaginationLinkProps) => (
<a
aria-current={isActive ? "page" : undefined}
className={cn(
buttonVariants({
variant: isActive ? "outline" : "ghost",
size,
}),
className
)}
{...props}
/>
)
PaginationLink.displayName = "PaginationLink"
const PaginationPrevious = ({
className,
...props
}: React.ComponentProps<typeof PaginationLink>) => (
<PaginationLink
aria-label="Go to previous page"
size="default"
className={cn("gap-1 pl-2.5", className)}
{...props}
>
<ChevronLeft className="h-4 w-4" />
<span>Previous</span>
</PaginationLink>
)
PaginationPrevious.displayName = "PaginationPrevious"
const PaginationNext = ({
className,
...props
}: React.ComponentProps<typeof PaginationLink>) => (
<PaginationLink
aria-label="Go to next page"
size="default"
className={cn("gap-1 pr-2.5", className)}
{...props}
>
<span>Next</span>
<ChevronRight className="h-4 w-4" />
</PaginationLink>
)
PaginationNext.displayName = "PaginationNext"
const PaginationEllipsis = ({
className,
...props
}: React.ComponentProps<"span">) => (
<span
aria-hidden
className={cn("flex h-9 w-9 items-center justify-center", className)}
{...props}
>
<MoreHorizontal className="h-4 w-4" />
<span className="sr-only">More pages</span>
</span>
)
PaginationEllipsis.displayName = "PaginationEllipsis"
export {
Pagination,
PaginationContent,
PaginationEllipsis,
PaginationItem,
PaginationLink,
PaginationNext,
PaginationPrevious,
}

View File

@ -0,0 +1,29 @@
import * as React from "react"
import * as PopoverPrimitive from "@radix-ui/react-popover"
import { cn } from "@/lib/utils"
const Popover = PopoverPrimitive.Root
const PopoverTrigger = PopoverPrimitive.Trigger
const PopoverContent = React.forwardRef<
React.ElementRef<typeof PopoverPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof PopoverPrimitive.Content>
>(({ className, align = "center", sideOffset = 4, ...props }, ref) => (
<PopoverPrimitive.Portal>
<PopoverPrimitive.Content
ref={ref}
align={align}
sideOffset={sideOffset}
className={cn(
"z-50 w-72 rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
</PopoverPrimitive.Portal>
))
PopoverContent.displayName = PopoverPrimitive.Content.displayName
export { Popover, PopoverTrigger, PopoverContent }

View File

@ -0,0 +1,26 @@
import * as React from "react"
import * as ProgressPrimitive from "@radix-ui/react-progress"
import { cn } from "@/lib/utils"
const Progress = React.forwardRef<
React.ElementRef<typeof ProgressPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof ProgressPrimitive.Root>
>(({ className, value, ...props }, ref) => (
<ProgressPrimitive.Root
ref={ref}
className={cn(
"relative h-4 w-full overflow-hidden rounded-full bg-secondary",
className
)}
{...props}
>
<ProgressPrimitive.Indicator
className="h-full w-full flex-1 bg-primary transition-all"
style={{ transform: `translateX(-${100 - (value || 0)}%)` }}
/>
</ProgressPrimitive.Root>
))
Progress.displayName = ProgressPrimitive.Root.displayName
export { Progress }

View File

@ -0,0 +1,42 @@
import * as React from "react"
import * as RadioGroupPrimitive from "@radix-ui/react-radio-group"
import { Circle } from "lucide-react"
import { cn } from "@/lib/utils"
const RadioGroup = React.forwardRef<
React.ElementRef<typeof RadioGroupPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root>
>(({ className, ...props }, ref) => {
return (
<RadioGroupPrimitive.Root
className={cn("grid gap-2", className)}
{...props}
ref={ref}
/>
)
})
RadioGroup.displayName = RadioGroupPrimitive.Root.displayName
const RadioGroupItem = React.forwardRef<
React.ElementRef<typeof RadioGroupPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>
>(({ className, ...props }, ref) => {
return (
<RadioGroupPrimitive.Item
ref={ref}
className={cn(
"aspect-square h-4 w-4 rounded-full border border-primary text-primary ring-offset-background focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
className
)}
{...props}
>
<RadioGroupPrimitive.Indicator className="flex items-center justify-center">
<Circle className="h-2.5 w-2.5 fill-current text-current" />
</RadioGroupPrimitive.Indicator>
</RadioGroupPrimitive.Item>
)
})
RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName
export { RadioGroup, RadioGroupItem }

View File

@ -0,0 +1,43 @@
import { GripVertical } from "lucide-react"
import * as ResizablePrimitive from "react-resizable-panels"
import { cn } from "@/lib/utils"
const ResizablePanelGroup = ({
className,
...props
}: React.ComponentProps<typeof ResizablePrimitive.PanelGroup>) => (
<ResizablePrimitive.PanelGroup
className={cn(
"flex h-full w-full data-[panel-group-direction=vertical]:flex-col",
className
)}
{...props}
/>
)
const ResizablePanel = ResizablePrimitive.Panel
const ResizableHandle = ({
withHandle,
className,
...props
}: React.ComponentProps<typeof ResizablePrimitive.PanelResizeHandle> & {
withHandle?: boolean
}) => (
<ResizablePrimitive.PanelResizeHandle
className={cn(
"relative flex w-px items-center justify-center bg-border after:absolute after:inset-y-0 after:left-1/2 after:w-1 after:-translate-x-1/2 focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring focus-visible:ring-offset-1 data-[panel-group-direction=vertical]:h-px data-[panel-group-direction=vertical]:w-full data-[panel-group-direction=vertical]:after:left-0 data-[panel-group-direction=vertical]:after:h-1 data-[panel-group-direction=vertical]:after:w-full data-[panel-group-direction=vertical]:after:-translate-y-1/2 data-[panel-group-direction=vertical]:after:translate-x-0 [&[data-panel-group-direction=vertical]>div]:rotate-90",
className
)}
{...props}
>
{withHandle && (
<div className="z-10 flex h-4 w-3 items-center justify-center rounded-sm border bg-border">
<GripVertical className="h-2.5 w-2.5" />
</div>
)}
</ResizablePrimitive.PanelResizeHandle>
)
export { ResizablePanelGroup, ResizablePanel, ResizableHandle }

View File

@ -0,0 +1,46 @@
import * as React from "react"
import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area"
import { cn } from "@/lib/utils"
const ScrollArea = React.forwardRef<
React.ElementRef<typeof ScrollAreaPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root>
>(({ className, children, ...props }, ref) => (
<ScrollAreaPrimitive.Root
ref={ref}
className={cn("relative overflow-hidden", className)}
{...props}
>
<ScrollAreaPrimitive.Viewport className="h-full w-full rounded-[inherit]">
{children}
</ScrollAreaPrimitive.Viewport>
<ScrollBar />
<ScrollAreaPrimitive.Corner />
</ScrollAreaPrimitive.Root>
))
ScrollArea.displayName = ScrollAreaPrimitive.Root.displayName
const ScrollBar = React.forwardRef<
React.ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,
React.ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>
>(({ className, orientation = "vertical", ...props }, ref) => (
<ScrollAreaPrimitive.ScrollAreaScrollbar
ref={ref}
orientation={orientation}
className={cn(
"flex touch-none select-none transition-colors",
orientation === "vertical" &&
"h-full w-2.5 border-l border-l-transparent p-[1px]",
orientation === "horizontal" &&
"h-2.5 flex-col border-t border-t-transparent p-[1px]",
className
)}
{...props}
>
<ScrollAreaPrimitive.ScrollAreaThumb className="relative flex-1 rounded-full bg-border" />
</ScrollAreaPrimitive.ScrollAreaScrollbar>
))
ScrollBar.displayName = ScrollAreaPrimitive.ScrollAreaScrollbar.displayName
export { ScrollArea, ScrollBar }

View File

@ -0,0 +1,162 @@
import * as React from "react"
import * as SelectPrimitive from "@radix-ui/react-select"
import { Check, ChevronDown, ChevronUp } from "lucide-react"
import { cn } from "@/lib/utils"
const Select = SelectPrimitive.Root
const SelectGroup = SelectPrimitive.Group
const SelectValue = SelectPrimitive.Value
const SelectTrigger = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.Trigger>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>
>(({ className, children, ...props }, ref) => (
<SelectPrimitive.Trigger
ref={ref}
className={cn(
"flex h-10 w-full items-center justify-between rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50 [&>span]:line-clamp-1",
className
)}
{...props}
>
{children}
<SelectPrimitive.Icon asChild>
<ChevronDown className="h-4 w-4 opacity-50" />
</SelectPrimitive.Icon>
</SelectPrimitive.Trigger>
))
SelectTrigger.displayName = SelectPrimitive.Trigger.displayName
const SelectScrollUpButton = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.ScrollUpButton>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollUpButton>
>(({ className, ...props }, ref) => (
<SelectPrimitive.ScrollUpButton
ref={ref}
className={cn(
"flex cursor-default items-center justify-center py-1",
className
)}
{...props}
>
<ChevronUp className="h-4 w-4" />
</SelectPrimitive.ScrollUpButton>
))
SelectScrollUpButton.displayName = SelectPrimitive.ScrollUpButton.displayName
const SelectScrollDownButton = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.ScrollDownButton>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.ScrollDownButton>
>(({ className, ...props }, ref) => (
<SelectPrimitive.ScrollDownButton
ref={ref}
className={cn(
"flex cursor-default items-center justify-center py-1",
className
)}
{...props}
>
<ChevronDown className="h-4 w-4" />
</SelectPrimitive.ScrollDownButton>
))
SelectScrollDownButton.displayName =
SelectPrimitive.ScrollDownButton.displayName
const SelectContent = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>
>(({ className, children, position = "popper", ...props }, ref) => (
<SelectPrimitive.Portal>
<SelectPrimitive.Content
ref={ref}
className={cn(
"relative z-50 max-h-96 min-w-[8rem] overflow-hidden rounded-md border bg-popover text-popover-foreground shadow-md data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
position === "popper" &&
"data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1",
className
)}
position={position}
{...props}
>
<SelectScrollUpButton />
<SelectPrimitive.Viewport
className={cn(
"p-1",
position === "popper" &&
"h-[var(--radix-select-trigger-height)] w-full min-w-[var(--radix-select-trigger-width)]"
)}
>
{children}
</SelectPrimitive.Viewport>
<SelectScrollDownButton />
</SelectPrimitive.Content>
</SelectPrimitive.Portal>
))
SelectContent.displayName = SelectPrimitive.Content.displayName
const SelectLabel = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.Label>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.Label>
>(({ className, ...props }, ref) => (
<SelectPrimitive.Label
ref={ref}
className={cn("py-1.5 pl-8 pr-2 text-sm font-semibold", className)}
{...props}
/>
))
SelectLabel.displayName = SelectPrimitive.Label.displayName
const SelectItem = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.Item>
>(({ className, children, ...props }, ref) => (
<SelectPrimitive.Item
ref={ref}
className={cn(
"relative flex w-full cursor-default select-none items-center rounded-sm py-1.5 pl-8 pr-2 text-sm outline-none focus:bg-accent focus:text-accent-foreground data-[disabled]:pointer-events-none data-[disabled]:opacity-50",
className
)}
{...props}
>
<span className="absolute left-2 flex h-3.5 w-3.5 items-center justify-center">
<SelectPrimitive.ItemIndicator>
<Check className="h-4 w-4" />
</SelectPrimitive.ItemIndicator>
</span>
<SelectPrimitive.ItemText>
<div className="flex flex-col">
{children}
</div>
</SelectPrimitive.ItemText>
</SelectPrimitive.Item>
))
SelectItem.displayName = SelectPrimitive.Item.displayName
const SelectSeparator = React.forwardRef<
React.ElementRef<typeof SelectPrimitive.Separator>,
React.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator>
>(({ className, ...props }, ref) => (
<SelectPrimitive.Separator
ref={ref}
className={cn("-mx-1 my-1 h-px bg-muted", className)}
{...props}
/>
))
SelectSeparator.displayName = SelectPrimitive.Separator.displayName
export {
Select,
SelectGroup,
SelectValue,
SelectTrigger,
SelectContent,
SelectLabel,
SelectItem,
SelectSeparator,
SelectScrollUpButton,
SelectScrollDownButton,
}

View File

@ -0,0 +1,29 @@
import * as React from "react"
import * as SeparatorPrimitive from "@radix-ui/react-separator"
import { cn } from "@/lib/utils"
const Separator = React.forwardRef<
React.ElementRef<typeof SeparatorPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof SeparatorPrimitive.Root>
>(
(
{ className, orientation = "horizontal", decorative = true, ...props },
ref
) => (
<SeparatorPrimitive.Root
ref={ref}
decorative={decorative}
orientation={orientation}
className={cn(
"shrink-0 bg-border",
orientation === "horizontal" ? "h-[1px] w-full" : "h-full w-[1px]",
className
)}
{...props}
/>
)
)
Separator.displayName = SeparatorPrimitive.Root.displayName
export { Separator }

View File

@ -0,0 +1,131 @@
import * as SheetPrimitive from "@radix-ui/react-dialog"
import { cva, type VariantProps } from "class-variance-authority"
import { X } from "lucide-react"
import * as React from "react"
import { cn } from "@/lib/utils"
const Sheet = SheetPrimitive.Root
const SheetTrigger = SheetPrimitive.Trigger
const SheetClose = SheetPrimitive.Close
const SheetPortal = SheetPrimitive.Portal
const SheetOverlay = React.forwardRef<
React.ElementRef<typeof SheetPrimitive.Overlay>,
React.ComponentPropsWithoutRef<typeof SheetPrimitive.Overlay>
>(({ className, ...props }, ref) => (
<SheetPrimitive.Overlay
className={cn(
"fixed inset-0 z-50 bg-black/80 data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0",
className
)}
{...props}
ref={ref}
/>
))
SheetOverlay.displayName = SheetPrimitive.Overlay.displayName
const sheetVariants = cva(
"fixed z-50 gap-4 bg-background p-6 shadow-lg transition ease-in-out data-[state=open]:animate-in data-[state=closed]:animate-out data-[state=closed]:duration-300 data-[state=open]:duration-500",
{
variants: {
side: {
top: "inset-x-0 top-0 border-b data-[state=closed]:slide-out-to-top data-[state=open]:slide-in-from-top",
bottom:
"inset-x-0 bottom-0 border-t data-[state=closed]:slide-out-to-bottom data-[state=open]:slide-in-from-bottom",
left: "inset-y-0 left-0 h-full w-3/4 border-r data-[state=closed]:slide-out-to-left data-[state=open]:slide-in-from-left sm:max-w-sm",
right:
"inset-y-0 right-0 h-full w-3/4 border-l data-[state=closed]:slide-out-to-right data-[state=open]:slide-in-from-right sm:max-w-sm",
},
},
defaultVariants: {
side: "right",
},
}
)
interface SheetContentProps
extends React.ComponentPropsWithoutRef<typeof SheetPrimitive.Content>,
VariantProps<typeof sheetVariants> { }
const SheetContent = React.forwardRef<
React.ElementRef<typeof SheetPrimitive.Content>,
SheetContentProps
>(({ side = "right", className, children, ...props }, ref) => (
<SheetPortal>
<SheetOverlay />
<SheetPrimitive.Content
ref={ref}
className={cn(sheetVariants({ side }), className)}
{...props}
>
{children}
<SheetPrimitive.Close className="absolute right-4 top-4 rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none data-[state=open]:bg-secondary">
<X className="h-4 w-4" />
<span className="sr-only">Close</span>
</SheetPrimitive.Close>
</SheetPrimitive.Content>
</SheetPortal>
))
SheetContent.displayName = SheetPrimitive.Content.displayName
const SheetHeader = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn(
"flex flex-col space-y-2 text-center sm:text-left",
className
)}
{...props}
/>
)
SheetHeader.displayName = "SheetHeader"
const SheetFooter = ({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) => (
<div
className={cn(
"flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2",
className
)}
{...props}
/>
)
SheetFooter.displayName = "SheetFooter"
const SheetTitle = React.forwardRef<
React.ElementRef<typeof SheetPrimitive.Title>,
React.ComponentPropsWithoutRef<typeof SheetPrimitive.Title>
>(({ className, ...props }, ref) => (
<SheetPrimitive.Title
ref={ref}
className={cn("text-lg font-semibold text-foreground", className)}
{...props}
/>
))
SheetTitle.displayName = SheetPrimitive.Title.displayName
const SheetDescription = React.forwardRef<
React.ElementRef<typeof SheetPrimitive.Description>,
React.ComponentPropsWithoutRef<typeof SheetPrimitive.Description>
>(({ className, ...props }, ref) => (
<SheetPrimitive.Description
ref={ref}
className={cn("text-sm text-muted-foreground", className)}
{...props}
/>
))
SheetDescription.displayName = SheetPrimitive.Description.displayName
export {
Sheet, SheetClose,
SheetContent, SheetDescription, SheetFooter, SheetHeader, SheetOverlay, SheetPortal, SheetTitle, SheetTrigger
}

View File

@ -0,0 +1,761 @@
import * as React from "react"
import { Slot } from "@radix-ui/react-slot"
import { VariantProps, cva } from "class-variance-authority"
import { PanelLeft } from "lucide-react"
import { useIsMobile } from "@/hooks/use-mobile"
import { cn } from "@/lib/utils"
import { Button } from "@/components/ui/button"
import { Input } from "@/components/ui/input"
import { Separator } from "@/components/ui/separator"
import { Sheet, SheetContent } from "@/components/ui/sheet"
import { Skeleton } from "@/components/ui/skeleton"
import {
Tooltip,
TooltipContent,
TooltipProvider,
TooltipTrigger,
} from "@/components/ui/tooltip"
const SIDEBAR_COOKIE_NAME = "sidebar:state"
const SIDEBAR_COOKIE_MAX_AGE = 60 * 60 * 24 * 7
const SIDEBAR_WIDTH = "16rem"
const SIDEBAR_WIDTH_MOBILE = "18rem"
const SIDEBAR_WIDTH_ICON = "3rem"
const SIDEBAR_KEYBOARD_SHORTCUT = "b"
type SidebarContext = {
state: "expanded" | "collapsed"
open: boolean
setOpen: (open: boolean) => void
openMobile: boolean
setOpenMobile: (open: boolean) => void
isMobile: boolean
toggleSidebar: () => void
}
const SidebarContext = React.createContext<SidebarContext | null>(null)
function useSidebar() {
const context = React.useContext(SidebarContext)
if (!context) {
throw new Error("useSidebar must be used within a SidebarProvider.")
}
return context
}
const SidebarProvider = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div"> & {
defaultOpen?: boolean
open?: boolean
onOpenChange?: (open: boolean) => void
}
>(
(
{
defaultOpen = true,
open: openProp,
onOpenChange: setOpenProp,
className,
style,
children,
...props
},
ref
) => {
const isMobile = useIsMobile()
const [openMobile, setOpenMobile] = React.useState(false)
// This is the internal state of the sidebar.
// We use openProp and setOpenProp for control from outside the component.
const [_open, _setOpen] = React.useState(defaultOpen)
const open = openProp ?? _open
const setOpen = React.useCallback(
(value: boolean | ((value: boolean) => boolean)) => {
const openState = typeof value === "function" ? value(open) : value
if (setOpenProp) {
setOpenProp(openState)
} else {
_setOpen(openState)
}
// This sets the cookie to keep the sidebar state.
document.cookie = `${SIDEBAR_COOKIE_NAME}=${openState}; path=/; max-age=${SIDEBAR_COOKIE_MAX_AGE}`
},
[setOpenProp, open]
)
// Helper to toggle the sidebar.
const toggleSidebar = React.useCallback(() => {
return isMobile
? setOpenMobile((open) => !open)
: setOpen((open) => !open)
}, [isMobile, setOpen, setOpenMobile])
// Adds a keyboard shortcut to toggle the sidebar.
React.useEffect(() => {
const handleKeyDown = (event: KeyboardEvent) => {
if (
event.key === SIDEBAR_KEYBOARD_SHORTCUT &&
(event.metaKey || event.ctrlKey)
) {
event.preventDefault()
toggleSidebar()
}
}
window.addEventListener("keydown", handleKeyDown)
return () => window.removeEventListener("keydown", handleKeyDown)
}, [toggleSidebar])
// We add a state so that we can do data-state="expanded" or "collapsed".
// This makes it easier to style the sidebar with Tailwind classes.
const state = open ? "expanded" : "collapsed"
const contextValue = React.useMemo<SidebarContext>(
() => ({
state,
open,
setOpen,
isMobile,
openMobile,
setOpenMobile,
toggleSidebar,
}),
[state, open, setOpen, isMobile, openMobile, setOpenMobile, toggleSidebar]
)
return (
<SidebarContext.Provider value={contextValue}>
<TooltipProvider delayDuration={0}>
<div
style={
{
"--sidebar-width": SIDEBAR_WIDTH,
"--sidebar-width-icon": SIDEBAR_WIDTH_ICON,
...style,
} as React.CSSProperties
}
className={cn(
"group/sidebar-wrapper flex min-h-svh w-full has-[[data-variant=inset]]:bg-sidebar",
className
)}
ref={ref}
{...props}
>
{children}
</div>
</TooltipProvider>
</SidebarContext.Provider>
)
}
)
SidebarProvider.displayName = "SidebarProvider"
const Sidebar = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div"> & {
side?: "left" | "right"
variant?: "sidebar" | "floating" | "inset"
collapsible?: "offcanvas" | "icon" | "none"
}
>(
(
{
side = "left",
variant = "sidebar",
collapsible = "offcanvas",
className,
children,
...props
},
ref
) => {
const { isMobile, state, openMobile, setOpenMobile } = useSidebar()
if (collapsible === "none") {
return (
<div
className={cn(
"flex h-full w-[--sidebar-width] flex-col bg-sidebar text-sidebar-foreground",
className
)}
ref={ref}
{...props}
>
{children}
</div>
)
}
if (isMobile) {
return (
<Sheet open={openMobile} onOpenChange={setOpenMobile} {...props}>
<SheetContent
data-sidebar="sidebar"
data-mobile="true"
className="w-[--sidebar-width] bg-sidebar p-0 text-sidebar-foreground [&>button]:hidden"
style={
{
"--sidebar-width": SIDEBAR_WIDTH_MOBILE,
} as React.CSSProperties
}
side={side}
>
<div className="flex h-full w-full flex-col">{children}</div>
</SheetContent>
</Sheet>
)
}
return (
<div
ref={ref}
className="group peer hidden md:block text-sidebar-foreground"
data-state={state}
data-collapsible={state === "collapsed" ? collapsible : ""}
data-variant={variant}
data-side={side}
>
{/* This is what handles the sidebar gap on desktop */}
<div
className={cn(
"duration-200 relative h-svh w-[--sidebar-width] bg-transparent transition-[width] ease-linear",
"group-data-[collapsible=offcanvas]:w-0",
"group-data-[side=right]:rotate-180",
variant === "floating" || variant === "inset"
? "group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)_+_theme(spacing.4))]"
: "group-data-[collapsible=icon]:w-[--sidebar-width-icon]"
)}
/>
<div
className={cn(
"duration-200 fixed inset-y-0 z-10 hidden h-svh w-[--sidebar-width] transition-[left,right,width] ease-linear md:flex",
side === "left"
? "left-0 group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]"
: "right-0 group-data-[collapsible=offcanvas]:right-[calc(var(--sidebar-width)*-1)]",
// Adjust the padding for floating and inset variants.
variant === "floating" || variant === "inset"
? "p-2 group-data-[collapsible=icon]:w-[calc(var(--sidebar-width-icon)_+_theme(spacing.4)_+2px)]"
: "group-data-[collapsible=icon]:w-[--sidebar-width-icon] group-data-[side=left]:border-r group-data-[side=right]:border-l",
className
)}
{...props}
>
<div
data-sidebar="sidebar"
className="flex h-full w-full flex-col bg-sidebar group-data-[variant=floating]:rounded-lg group-data-[variant=floating]:border group-data-[variant=floating]:border-sidebar-border group-data-[variant=floating]:shadow"
>
{children}
</div>
</div>
</div>
)
}
)
Sidebar.displayName = "Sidebar"
const SidebarTrigger = React.forwardRef<
React.ElementRef<typeof Button>,
React.ComponentProps<typeof Button>
>(({ className, onClick, ...props }, ref) => {
const { toggleSidebar } = useSidebar()
return (
<Button
ref={ref}
data-sidebar="trigger"
variant="ghost"
size="icon"
className={cn("h-7 w-7", className)}
onClick={(event) => {
onClick?.(event)
toggleSidebar()
}}
{...props}
>
<PanelLeft />
<span className="sr-only">Toggle Sidebar</span>
</Button>
)
})
SidebarTrigger.displayName = "SidebarTrigger"
const SidebarRail = React.forwardRef<
HTMLButtonElement,
React.ComponentProps<"button">
>(({ className, ...props }, ref) => {
const { toggleSidebar } = useSidebar()
return (
<button
ref={ref}
data-sidebar="rail"
aria-label="Toggle Sidebar"
tabIndex={-1}
onClick={toggleSidebar}
title="Toggle Sidebar"
className={cn(
"absolute inset-y-0 z-20 hidden w-4 -translate-x-1/2 transition-all ease-linear after:absolute after:inset-y-0 after:left-1/2 after:w-[2px] hover:after:bg-sidebar-border group-data-[side=left]:-right-4 group-data-[side=right]:left-0 sm:flex",
"[[data-side=left]_&]:cursor-w-resize [[data-side=right]_&]:cursor-e-resize",
"[[data-side=left][data-state=collapsed]_&]:cursor-e-resize [[data-side=right][data-state=collapsed]_&]:cursor-w-resize",
"group-data-[collapsible=offcanvas]:translate-x-0 group-data-[collapsible=offcanvas]:after:left-full group-data-[collapsible=offcanvas]:hover:bg-sidebar",
"[[data-side=left][data-collapsible=offcanvas]_&]:-right-2",
"[[data-side=right][data-collapsible=offcanvas]_&]:-left-2",
className
)}
{...props}
/>
)
})
SidebarRail.displayName = "SidebarRail"
const SidebarInset = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"main">
>(({ className, ...props }, ref) => {
return (
<main
ref={ref}
className={cn(
"relative flex min-h-svh flex-1 flex-col bg-background",
"peer-data-[variant=inset]:min-h-[calc(100svh-theme(spacing.4))] md:peer-data-[variant=inset]:m-2 md:peer-data-[state=collapsed]:peer-data-[variant=inset]:ml-2 md:peer-data-[variant=inset]:ml-0 md:peer-data-[variant=inset]:rounded-xl md:peer-data-[variant=inset]:shadow",
className
)}
{...props}
/>
)
})
SidebarInset.displayName = "SidebarInset"
const SidebarInput = React.forwardRef<
React.ElementRef<typeof Input>,
React.ComponentProps<typeof Input>
>(({ className, ...props }, ref) => {
return (
<Input
ref={ref}
data-sidebar="input"
className={cn(
"h-8 w-full bg-background shadow-none focus-visible:ring-2 focus-visible:ring-sidebar-ring",
className
)}
{...props}
/>
)
})
SidebarInput.displayName = "SidebarInput"
const SidebarHeader = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
return (
<div
ref={ref}
data-sidebar="header"
className={cn("flex flex-col gap-2 p-2", className)}
{...props}
/>
)
})
SidebarHeader.displayName = "SidebarHeader"
const SidebarFooter = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
return (
<div
ref={ref}
data-sidebar="footer"
className={cn("flex flex-col gap-2 p-2", className)}
{...props}
/>
)
})
SidebarFooter.displayName = "SidebarFooter"
const SidebarSeparator = React.forwardRef<
React.ElementRef<typeof Separator>,
React.ComponentProps<typeof Separator>
>(({ className, ...props }, ref) => {
return (
<Separator
ref={ref}
data-sidebar="separator"
className={cn("mx-2 w-auto bg-sidebar-border", className)}
{...props}
/>
)
})
SidebarSeparator.displayName = "SidebarSeparator"
const SidebarContent = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
return (
<div
ref={ref}
data-sidebar="content"
className={cn(
"flex min-h-0 flex-1 flex-col gap-2 overflow-auto group-data-[collapsible=icon]:overflow-hidden",
className
)}
{...props}
/>
)
})
SidebarContent.displayName = "SidebarContent"
const SidebarGroup = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div">
>(({ className, ...props }, ref) => {
return (
<div
ref={ref}
data-sidebar="group"
className={cn("relative flex w-full min-w-0 flex-col p-2", className)}
{...props}
/>
)
})
SidebarGroup.displayName = "SidebarGroup"
const SidebarGroupLabel = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div"> & { asChild?: boolean }
>(({ className, asChild = false, ...props }, ref) => {
const Comp = asChild ? Slot : "div"
return (
<Comp
ref={ref}
data-sidebar="group-label"
className={cn(
"duration-200 flex h-8 shrink-0 items-center rounded-md px-2 text-xs font-medium text-sidebar-foreground/70 outline-none ring-sidebar-ring transition-[margin,opa] ease-linear focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
"group-data-[collapsible=icon]:-mt-8 group-data-[collapsible=icon]:opacity-0",
className
)}
{...props}
/>
)
})
SidebarGroupLabel.displayName = "SidebarGroupLabel"
const SidebarGroupAction = React.forwardRef<
HTMLButtonElement,
React.ComponentProps<"button"> & { asChild?: boolean }
>(({ className, asChild = false, ...props }, ref) => {
const Comp = asChild ? Slot : "button"
return (
<Comp
ref={ref}
data-sidebar="group-action"
className={cn(
"absolute right-3 top-3.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-none ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 [&>svg]:size-4 [&>svg]:shrink-0",
// Increases the hit area of the button on mobile.
"after:absolute after:-inset-2 after:md:hidden",
"group-data-[collapsible=icon]:hidden",
className
)}
{...props}
/>
)
})
SidebarGroupAction.displayName = "SidebarGroupAction"
const SidebarGroupContent = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div">
>(({ className, ...props }, ref) => (
<div
ref={ref}
data-sidebar="group-content"
className={cn("w-full text-sm", className)}
{...props}
/>
))
SidebarGroupContent.displayName = "SidebarGroupContent"
const SidebarMenu = React.forwardRef<
HTMLUListElement,
React.ComponentProps<"ul">
>(({ className, ...props }, ref) => (
<ul
ref={ref}
data-sidebar="menu"
className={cn("flex w-full min-w-0 flex-col gap-1", className)}
{...props}
/>
))
SidebarMenu.displayName = "SidebarMenu"
const SidebarMenuItem = React.forwardRef<
HTMLLIElement,
React.ComponentProps<"li">
>(({ className, ...props }, ref) => (
<li
ref={ref}
data-sidebar="menu-item"
className={cn("group/menu-item relative", className)}
{...props}
/>
))
SidebarMenuItem.displayName = "SidebarMenuItem"
const sidebarMenuButtonVariants = cva(
"peer/menu-button flex w-full items-center gap-2 overflow-hidden rounded-md p-2 text-left text-sm outline-none ring-sidebar-ring transition-[width,height,padding] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 group-has-[[data-sidebar=menu-action]]/menu-item:pr-8 aria-disabled:pointer-events-none aria-disabled:opacity-50 data-[active=true]:bg-sidebar-accent data-[active=true]:font-medium data-[active=true]:text-sidebar-accent-foreground data-[state=open]:hover:bg-sidebar-accent data-[state=open]:hover:text-sidebar-accent-foreground group-data-[collapsible=icon]:!size-8 group-data-[collapsible=icon]:!p-2 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0",
{
variants: {
variant: {
default: "hover:bg-sidebar-accent hover:text-sidebar-accent-foreground",
outline:
"bg-background shadow-[0_0_0_1px_hsl(var(--sidebar-border))] hover:bg-sidebar-accent hover:text-sidebar-accent-foreground hover:shadow-[0_0_0_1px_hsl(var(--sidebar-accent))]",
},
size: {
default: "h-8 text-sm",
sm: "h-7 text-xs",
lg: "h-12 text-sm group-data-[collapsible=icon]:!p-0",
},
},
defaultVariants: {
variant: "default",
size: "default",
},
}
)
const SidebarMenuButton = React.forwardRef<
HTMLButtonElement,
React.ComponentProps<"button"> & {
asChild?: boolean
isActive?: boolean
tooltip?: string | React.ComponentProps<typeof TooltipContent>
} & VariantProps<typeof sidebarMenuButtonVariants>
>(
(
{
asChild = false,
isActive = false,
variant = "default",
size = "default",
tooltip,
className,
...props
},
ref
) => {
const Comp = asChild ? Slot : "button"
const { isMobile, state } = useSidebar()
const button = (
<Comp
ref={ref}
data-sidebar="menu-button"
data-size={size}
data-active={isActive}
className={cn(sidebarMenuButtonVariants({ variant, size }), className)}
{...props}
/>
)
if (!tooltip) {
return button
}
if (typeof tooltip === "string") {
tooltip = {
children: tooltip,
}
}
return (
<Tooltip>
<TooltipTrigger asChild>{button}</TooltipTrigger>
<TooltipContent
side="right"
align="center"
hidden={state !== "collapsed" || isMobile}
{...tooltip}
/>
</Tooltip>
)
}
)
SidebarMenuButton.displayName = "SidebarMenuButton"
const SidebarMenuAction = React.forwardRef<
HTMLButtonElement,
React.ComponentProps<"button"> & {
asChild?: boolean
showOnHover?: boolean
}
>(({ className, asChild = false, showOnHover = false, ...props }, ref) => {
const Comp = asChild ? Slot : "button"
return (
<Comp
ref={ref}
data-sidebar="menu-action"
className={cn(
"absolute right-1 top-1.5 flex aspect-square w-5 items-center justify-center rounded-md p-0 text-sidebar-foreground outline-none ring-sidebar-ring transition-transform hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 peer-hover/menu-button:text-sidebar-accent-foreground [&>svg]:size-4 [&>svg]:shrink-0",
// Increases the hit area of the button on mobile.
"after:absolute after:-inset-2 after:md:hidden",
"peer-data-[size=sm]/menu-button:top-1",
"peer-data-[size=default]/menu-button:top-1.5",
"peer-data-[size=lg]/menu-button:top-2.5",
"group-data-[collapsible=icon]:hidden",
showOnHover &&
"group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 peer-data-[active=true]/menu-button:text-sidebar-accent-foreground md:opacity-0",
className
)}
{...props}
/>
)
})
SidebarMenuAction.displayName = "SidebarMenuAction"
const SidebarMenuBadge = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div">
>(({ className, ...props }, ref) => (
<div
ref={ref}
data-sidebar="menu-badge"
className={cn(
"absolute right-1 flex h-5 min-w-5 items-center justify-center rounded-md px-1 text-xs font-medium tabular-nums text-sidebar-foreground select-none pointer-events-none",
"peer-hover/menu-button:text-sidebar-accent-foreground peer-data-[active=true]/menu-button:text-sidebar-accent-foreground",
"peer-data-[size=sm]/menu-button:top-1",
"peer-data-[size=default]/menu-button:top-1.5",
"peer-data-[size=lg]/menu-button:top-2.5",
"group-data-[collapsible=icon]:hidden",
className
)}
{...props}
/>
))
SidebarMenuBadge.displayName = "SidebarMenuBadge"
const SidebarMenuSkeleton = React.forwardRef<
HTMLDivElement,
React.ComponentProps<"div"> & {
showIcon?: boolean
}
>(({ className, showIcon = false, ...props }, ref) => {
// Random width between 50 to 90%.
const width = React.useMemo(() => {
return `${Math.floor(Math.random() * 40) + 50}%`
}, [])
return (
<div
ref={ref}
data-sidebar="menu-skeleton"
className={cn("rounded-md h-8 flex gap-2 px-2 items-center", className)}
{...props}
>
{showIcon && (
<Skeleton
className="size-4 rounded-md"
data-sidebar="menu-skeleton-icon"
/>
)}
<Skeleton
className="h-4 flex-1 max-w-[--skeleton-width]"
data-sidebar="menu-skeleton-text"
style={
{
"--skeleton-width": width,
} as React.CSSProperties
}
/>
</div>
)
})
SidebarMenuSkeleton.displayName = "SidebarMenuSkeleton"
const SidebarMenuSub = React.forwardRef<
HTMLUListElement,
React.ComponentProps<"ul">
>(({ className, ...props }, ref) => (
<ul
ref={ref}
data-sidebar="menu-sub"
className={cn(
"mx-3.5 flex min-w-0 translate-x-px flex-col gap-1 border-l border-sidebar-border px-2.5 py-0.5",
"group-data-[collapsible=icon]:hidden",
className
)}
{...props}
/>
))
SidebarMenuSub.displayName = "SidebarMenuSub"
const SidebarMenuSubItem = React.forwardRef<
HTMLLIElement,
React.ComponentProps<"li">
>(({ ...props }, ref) => <li ref={ref} {...props} />)
SidebarMenuSubItem.displayName = "SidebarMenuSubItem"
const SidebarMenuSubButton = React.forwardRef<
HTMLAnchorElement,
React.ComponentProps<"a"> & {
asChild?: boolean
size?: "sm" | "md"
isActive?: boolean
}
>(({ asChild = false, size = "md", isActive, className, ...props }, ref) => {
const Comp = asChild ? Slot : "a"
return (
<Comp
ref={ref}
data-sidebar="menu-sub-button"
data-size={size}
data-active={isActive}
className={cn(
"flex h-7 min-w-0 -translate-x-px items-center gap-2 overflow-hidden rounded-md px-2 text-sidebar-foreground outline-none ring-sidebar-ring hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:ring-2 active:bg-sidebar-accent active:text-sidebar-accent-foreground disabled:pointer-events-none disabled:opacity-50 aria-disabled:pointer-events-none aria-disabled:opacity-50 [&>span:last-child]:truncate [&>svg]:size-4 [&>svg]:shrink-0 [&>svg]:text-sidebar-accent-foreground",
"data-[active=true]:bg-sidebar-accent data-[active=true]:text-sidebar-accent-foreground",
size === "sm" && "text-xs",
size === "md" && "text-sm",
"group-data-[collapsible=icon]:hidden",
className
)}
{...props}
/>
)
})
SidebarMenuSubButton.displayName = "SidebarMenuSubButton"
export {
Sidebar,
SidebarContent,
SidebarFooter,
SidebarGroup,
SidebarGroupAction,
SidebarGroupContent,
SidebarGroupLabel,
SidebarHeader,
SidebarInput,
SidebarInset,
SidebarMenu,
SidebarMenuAction,
SidebarMenuBadge,
SidebarMenuButton,
SidebarMenuItem,
SidebarMenuSkeleton,
SidebarMenuSub,
SidebarMenuSubButton,
SidebarMenuSubItem,
SidebarProvider,
SidebarRail,
SidebarSeparator,
SidebarTrigger,
useSidebar,
}

View File

@ -0,0 +1,15 @@
import { cn } from "@/lib/utils"
function Skeleton({
className,
...props
}: React.HTMLAttributes<HTMLDivElement>) {
return (
<div
className={cn("animate-pulse rounded-md bg-muted", className)}
{...props}
/>
)
}
export { Skeleton }

View File

@ -0,0 +1,26 @@
import * as React from "react"
import * as SliderPrimitive from "@radix-ui/react-slider"
import { cn } from "@/lib/utils"
const Slider = React.forwardRef<
React.ElementRef<typeof SliderPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof SliderPrimitive.Root>
>(({ className, ...props }, ref) => (
<SliderPrimitive.Root
ref={ref}
className={cn(
"relative flex w-full touch-none select-none items-center",
className
)}
{...props}
>
<SliderPrimitive.Track className="relative h-2 w-full grow overflow-hidden rounded-full bg-secondary">
<SliderPrimitive.Range className="absolute h-full bg-primary" />
</SliderPrimitive.Track>
<SliderPrimitive.Thumb className="block h-5 w-5 rounded-full border-2 border-primary bg-background ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50" />
</SliderPrimitive.Root>
))
Slider.displayName = SliderPrimitive.Root.displayName
export { Slider }

View File

@ -0,0 +1,30 @@
import { useTheme } from "next-themes"
import { Toaster as Sonner } from "sonner"
type ToasterProps = React.ComponentProps<typeof Sonner>
const Toaster = ({ ...props }: ToasterProps) => {
const { theme = "system" } = useTheme()
return (
<Sonner
theme={theme as ToasterProps["theme"]}
className="toaster group"
closeButton={true}
toastOptions={{
classNames: {
toast:
"group toast group-[.toaster]:bg-background group-[.toaster]:text-foreground group-[.toaster]:border-border group-[.toaster]:shadow-lg",
description: "group-[.toast]:text-muted-foreground",
actionButton:
"group-[.toast]:bg-primary group-[.toast]:text-primary-foreground",
cancelButton:
"group-[.toast]:bg-muted group-[.toast]:text-muted-foreground",
},
}}
{...props}
/>
)
}
export { Toaster }

View File

@ -0,0 +1,27 @@
import * as React from "react"
import * as SwitchPrimitives from "@radix-ui/react-switch"
import { cn } from "@/lib/utils"
const Switch = React.forwardRef<
React.ElementRef<typeof SwitchPrimitives.Root>,
React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
>(({ className, ...props }, ref) => (
<SwitchPrimitives.Root
className={cn(
"peer inline-flex h-6 w-11 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input",
className
)}
{...props}
ref={ref}
>
<SwitchPrimitives.Thumb
className={cn(
"pointer-events-none block h-5 w-5 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-5 data-[state=unchecked]:translate-x-0"
)}
/>
</SwitchPrimitives.Root>
))
Switch.displayName = SwitchPrimitives.Root.displayName
export { Switch }

View File

@ -0,0 +1,117 @@
import * as React from "react"
import { cn } from "@/lib/utils"
const Table = React.forwardRef<
HTMLTableElement,
React.HTMLAttributes<HTMLTableElement>
>(({ className, ...props }, ref) => (
<div className="relative w-full overflow-auto">
<table
ref={ref}
className={cn("w-full caption-bottom text-sm", className)}
{...props}
/>
</div>
))
Table.displayName = "Table"
const TableHeader = React.forwardRef<
HTMLTableSectionElement,
React.HTMLAttributes<HTMLTableSectionElement>
>(({ className, ...props }, ref) => (
<thead ref={ref} className={cn("[&_tr]:border-b", className)} {...props} />
))
TableHeader.displayName = "TableHeader"
const TableBody = React.forwardRef<
HTMLTableSectionElement,
React.HTMLAttributes<HTMLTableSectionElement>
>(({ className, ...props }, ref) => (
<tbody
ref={ref}
className={cn("[&_tr:last-child]:border-0", className)}
{...props}
/>
))
TableBody.displayName = "TableBody"
const TableFooter = React.forwardRef<
HTMLTableSectionElement,
React.HTMLAttributes<HTMLTableSectionElement>
>(({ className, ...props }, ref) => (
<tfoot
ref={ref}
className={cn(
"border-t bg-muted/50 font-medium [&>tr]:last:border-b-0",
className
)}
{...props}
/>
))
TableFooter.displayName = "TableFooter"
const TableRow = React.forwardRef<
HTMLTableRowElement,
React.HTMLAttributes<HTMLTableRowElement>
>(({ className, ...props }, ref) => (
<tr
ref={ref}
className={cn(
"border-b transition-colors hover:bg-muted/50 data-[state=selected]:bg-muted",
className
)}
{...props}
/>
))
TableRow.displayName = "TableRow"
const TableHead = React.forwardRef<
HTMLTableCellElement,
React.ThHTMLAttributes<HTMLTableCellElement>
>(({ className, ...props }, ref) => (
<th
ref={ref}
className={cn(
"h-12 px-4 text-left align-middle font-medium text-muted-foreground [&:has([role=checkbox])]:pr-0",
className
)}
{...props}
/>
))
TableHead.displayName = "TableHead"
const TableCell = React.forwardRef<
HTMLTableCellElement,
React.TdHTMLAttributes<HTMLTableCellElement>
>(({ className, ...props }, ref) => (
<td
ref={ref}
className={cn("p-4 align-middle [&:has([role=checkbox])]:pr-0", className)}
{...props}
/>
))
TableCell.displayName = "TableCell"
const TableCaption = React.forwardRef<
HTMLTableCaptionElement,
React.HTMLAttributes<HTMLTableCaptionElement>
>(({ className, ...props }, ref) => (
<caption
ref={ref}
className={cn("mt-4 text-sm text-muted-foreground", className)}
{...props}
/>
))
TableCaption.displayName = "TableCaption"
export {
Table,
TableHeader,
TableBody,
TableFooter,
TableHead,
TableRow,
TableCell,
TableCaption,
}

View File

@ -0,0 +1,53 @@
import * as React from "react"
import * as TabsPrimitive from "@radix-ui/react-tabs"
import { cn } from "@/lib/utils"
const Tabs = TabsPrimitive.Root
const TabsList = React.forwardRef<
React.ElementRef<typeof TabsPrimitive.List>,
React.ComponentPropsWithoutRef<typeof TabsPrimitive.List>
>(({ className, ...props }, ref) => (
<TabsPrimitive.List
ref={ref}
className={cn(
"inline-flex h-10 items-center justify-center rounded-md glass-panel p-1 text-slate-600 dark:text-slate-300",
className
)}
{...props}
/>
))
TabsList.displayName = TabsPrimitive.List.displayName
const TabsTrigger = React.forwardRef<
React.ElementRef<typeof TabsPrimitive.Trigger>,
React.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>
>(({ className, ...props }, ref) => (
<TabsPrimitive.Trigger
ref={ref}
className={cn(
"inline-flex items-center justify-center whitespace-nowrap rounded-sm px-3 py-1.5 text-sm font-medium ring-offset-background transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=active]:glass-card data-[state=active]:text-slate-700 dark:data-[state=active]:text-white data-[state=active]:shadow-lg",
className
)}
{...props}
/>
))
TabsTrigger.displayName = TabsPrimitive.Trigger.displayName
const TabsContent = React.forwardRef<
React.ElementRef<typeof TabsPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>
>(({ className, ...props }, ref) => (
<TabsPrimitive.Content
ref={ref}
className={cn(
"mt-2 ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2",
className
)}
{...props}
/>
))
TabsContent.displayName = TabsPrimitive.Content.displayName
export { Tabs, TabsList, TabsTrigger, TabsContent }

View File

@ -0,0 +1,24 @@
import * as React from "react"
import { cn } from "@/lib/utils"
export interface TextareaProps
extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {}
const Textarea = React.forwardRef<HTMLTextAreaElement, TextareaProps>(
({ className, ...props }, ref) => {
return (
<textarea
className={cn(
"flex min-h-[80px] w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
className
)}
ref={ref}
{...props}
/>
)
}
)
Textarea.displayName = "Textarea"
export { Textarea }

View File

@ -0,0 +1,127 @@
import * as React from "react"
import * as ToastPrimitives from "@radix-ui/react-toast"
import { cva, type VariantProps } from "class-variance-authority"
import { X } from "lucide-react"
import { cn } from "@/lib/utils"
const ToastProvider = ToastPrimitives.Provider
const ToastViewport = React.forwardRef<
React.ElementRef<typeof ToastPrimitives.Viewport>,
React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
>(({ className, ...props }, ref) => (
<ToastPrimitives.Viewport
ref={ref}
className={cn(
"fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]",
className
)}
{...props}
/>
))
ToastViewport.displayName = ToastPrimitives.Viewport.displayName
const toastVariants = cva(
"group pointer-events-auto relative flex w-full items-center justify-between space-x-4 overflow-hidden rounded-md border p-6 pr-8 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full",
{
variants: {
variant: {
default: "border bg-background text-foreground",
destructive:
"destructive group border-destructive bg-destructive text-destructive-foreground",
},
},
defaultVariants: {
variant: "default",
},
}
)
const Toast = React.forwardRef<
React.ElementRef<typeof ToastPrimitives.Root>,
React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> &
VariantProps<typeof toastVariants>
>(({ className, variant, ...props }, ref) => {
return (
<ToastPrimitives.Root
ref={ref}
className={cn(toastVariants({ variant }), className)}
{...props}
/>
)
})
Toast.displayName = ToastPrimitives.Root.displayName
const ToastAction = React.forwardRef<
React.ElementRef<typeof ToastPrimitives.Action>,
React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
>(({ className, ...props }, ref) => (
<ToastPrimitives.Action
ref={ref}
className={cn(
"inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium ring-offset-background transition-colors hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive",
className
)}
{...props}
/>
))
ToastAction.displayName = ToastPrimitives.Action.displayName
const ToastClose = React.forwardRef<
React.ElementRef<typeof ToastPrimitives.Close>,
React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
>(({ className, ...props }, ref) => (
<ToastPrimitives.Close
ref={ref}
className={cn(
"absolute right-2 top-2 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-2 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600",
className
)}
toast-close=""
{...props}
>
<X className="h-4 w-4" />
</ToastPrimitives.Close>
))
ToastClose.displayName = ToastPrimitives.Close.displayName
const ToastTitle = React.forwardRef<
React.ElementRef<typeof ToastPrimitives.Title>,
React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
>(({ className, ...props }, ref) => (
<ToastPrimitives.Title
ref={ref}
className={cn("text-sm font-semibold", className)}
{...props}
/>
))
ToastTitle.displayName = ToastPrimitives.Title.displayName
const ToastDescription = React.forwardRef<
React.ElementRef<typeof ToastPrimitives.Description>,
React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
>(({ className, ...props }, ref) => (
<ToastPrimitives.Description
ref={ref}
className={cn("text-sm opacity-90", className)}
{...props}
/>
))
ToastDescription.displayName = ToastPrimitives.Description.displayName
type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>
type ToastActionElement = React.ReactElement<typeof ToastAction>
export {
type ToastProps,
type ToastActionElement,
ToastProvider,
ToastViewport,
Toast,
ToastTitle,
ToastDescription,
ToastClose,
ToastAction,
}

View File

@ -0,0 +1,33 @@
import { useToast } from "@/hooks/use-toast"
import {
Toast,
ToastClose,
ToastDescription,
ToastProvider,
ToastTitle,
ToastViewport,
} from "@/components/ui/toast"
export function Toaster() {
const { toasts } = useToast()
return (
<ToastProvider>
{toasts.map(function ({ id, title, description, action, ...props }) {
return (
<Toast key={id} {...props}>
<div className="grid gap-1">
{title && <ToastTitle>{title}</ToastTitle>}
{description && (
<ToastDescription>{description}</ToastDescription>
)}
</div>
{action}
<ToastClose />
</Toast>
)
})}
<ToastViewport />
</ToastProvider>
)
}

View File

@ -0,0 +1,59 @@
import * as React from "react"
import * as ToggleGroupPrimitive from "@radix-ui/react-toggle-group"
import { type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"
import { toggleVariants } from "@/components/ui/toggle"
const ToggleGroupContext = React.createContext<
VariantProps<typeof toggleVariants>
>({
size: "default",
variant: "default",
})
const ToggleGroup = React.forwardRef<
React.ElementRef<typeof ToggleGroupPrimitive.Root>,
React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Root> &
VariantProps<typeof toggleVariants>
>(({ className, variant, size, children, ...props }, ref) => (
<ToggleGroupPrimitive.Root
ref={ref}
className={cn("flex items-center justify-center gap-1", className)}
{...props}
>
<ToggleGroupContext.Provider value={{ variant, size }}>
{children}
</ToggleGroupContext.Provider>
</ToggleGroupPrimitive.Root>
))
ToggleGroup.displayName = ToggleGroupPrimitive.Root.displayName
const ToggleGroupItem = React.forwardRef<
React.ElementRef<typeof ToggleGroupPrimitive.Item>,
React.ComponentPropsWithoutRef<typeof ToggleGroupPrimitive.Item> &
VariantProps<typeof toggleVariants>
>(({ className, children, variant, size, ...props }, ref) => {
const context = React.useContext(ToggleGroupContext)
return (
<ToggleGroupPrimitive.Item
ref={ref}
className={cn(
toggleVariants({
variant: context.variant || variant,
size: context.size || size,
}),
className
)}
{...props}
>
{children}
</ToggleGroupPrimitive.Item>
)
})
ToggleGroupItem.displayName = ToggleGroupPrimitive.Item.displayName
export { ToggleGroup, ToggleGroupItem }

View File

@ -0,0 +1,47 @@
import * as React from "react"
import * as TogglePrimitive from "@radix-ui/react-toggle"
import { cva, type VariantProps } from "class-variance-authority"
import { cn } from "@/lib/utils"
const toggleVariants = cva(
"inline-flex items-center justify-center rounded-md text-sm font-medium ring-offset-background transition-colors hover:bg-muted hover:text-muted-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground",
{
variants: {
variant: {
default: "bg-transparent",
outline:
"border border-input bg-transparent hover:bg-accent hover:text-accent-foreground",
ghost:
"bg-transparent dark:hover:bg-white/10 dark:data-[state=on]:bg-white/20 dark:text-white light:hover:bg-black/10 light:data-[state=on]:bg-black/20 light:text-black",
},
size: {
default: "h-10 px-3",
sm: "h-9 px-2.5",
lg: "h-11 px-5",
icon: "h-10 w-10 p-0",
},
},
defaultVariants: {
variant: "default",
size: "default",
},
}
)
const Toggle = React.forwardRef<
React.ElementRef<typeof TogglePrimitive.Root>,
React.ComponentPropsWithoutRef<typeof TogglePrimitive.Root> &
VariantProps<typeof toggleVariants>
>(({ className, variant, size, ...props }, ref) => (
<TogglePrimitive.Root
ref={ref}
className={cn(toggleVariants({ variant, size, className }))}
{...props}
/>
))
Toggle.displayName = TogglePrimitive.Root.displayName
export { Toggle, toggleVariants }

View File

@ -0,0 +1,28 @@
import * as React from "react"
import * as TooltipPrimitive from "@radix-ui/react-tooltip"
import { cn } from "@/lib/utils"
const TooltipProvider = TooltipPrimitive.Provider
const Tooltip = TooltipPrimitive.Root
const TooltipTrigger = TooltipPrimitive.Trigger
const TooltipContent = React.forwardRef<
React.ElementRef<typeof TooltipPrimitive.Content>,
React.ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>
>(({ className, sideOffset = 4, ...props }, ref) => (
<TooltipPrimitive.Content
ref={ref}
sideOffset={sideOffset}
className={cn(
"z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2",
className
)}
{...props}
/>
))
TooltipContent.displayName = TooltipPrimitive.Content.displayName
export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

View File

@ -0,0 +1,3 @@
import { useToast, toast } from "../../hooks/use-toast";
export { useToast, toast };

View File

@ -0,0 +1,19 @@
import * as React from "react"
const MOBILE_BREAKPOINT = 768
export function useIsMobile() {
const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)
React.useEffect(() => {
const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
const onChange = () => {
setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
}
mql.addEventListener("change", onChange)
setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
return () => mql.removeEventListener("change", onChange)
}, [])
return !!isMobile
}

View File

@ -0,0 +1,193 @@
import * as React from "react"
import type {
ToastActionElement,
ToastProps,
} from "@/components/ui/toast"
const TOAST_LIMIT = 10
const TOAST_REMOVE_DELAY = 2000
type ToasterToast = ToastProps & {
id: string
title?: React.ReactNode
description?: React.ReactNode
action?: ToastActionElement
}
const actionTypes = {
ADD_TOAST: "ADD_TOAST",
UPDATE_TOAST: "UPDATE_TOAST",
DISMISS_TOAST: "DISMISS_TOAST",
REMOVE_TOAST: "REMOVE_TOAST",
} as const
let count = 0
function genId() {
count = (count + 1) % Number.MAX_SAFE_INTEGER
return count.toString()
}
type ActionType = typeof actionTypes
type Action =
| {
type: ActionType["ADD_TOAST"]
toast: ToasterToast
}
| {
type: ActionType["UPDATE_TOAST"]
toast: Partial<ToasterToast>
}
| {
type: ActionType["DISMISS_TOAST"]
toastId?: ToasterToast["id"]
}
| {
type: ActionType["REMOVE_TOAST"]
toastId?: ToasterToast["id"]
}
interface State {
toasts: ToasterToast[]
}
const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
const addToRemoveQueue = (toastId: string) => {
if (toastTimeouts.has(toastId)) {
return
}
const timeout = setTimeout(() => {
toastTimeouts.delete(toastId)
dispatch({
type: "REMOVE_TOAST",
toastId: toastId,
})
}, TOAST_REMOVE_DELAY)
toastTimeouts.set(toastId, timeout)
}
export const reducer = (state: State, action: Action): State => {
switch (action.type) {
case "ADD_TOAST":
return {
...state,
toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
}
case "UPDATE_TOAST":
return {
...state,
toasts: state.toasts.map((t) =>
t.id === action.toast.id ? { ...t, ...action.toast } : t
),
}
case "DISMISS_TOAST": {
const { toastId } = action
// ! Side effects ! - This could be extracted into a dismissToast() action,
// but I'll keep it here for simplicity
if (toastId) {
addToRemoveQueue(toastId)
} else {
state.toasts.forEach((toast) => {
addToRemoveQueue(toast.id)
})
}
return {
...state,
toasts: state.toasts.map((t) =>
t.id === toastId || toastId === undefined
? {
...t,
open: false,
}
: t
),
}
}
case "REMOVE_TOAST":
if (action.toastId === undefined) {
return {
...state,
toasts: [],
}
}
return {
...state,
toasts: state.toasts.filter((t) => t.id !== action.toastId),
}
}
}
const listeners: Array<(state: State) => void> = []
let memoryState: State = { toasts: [] }
function dispatch(action: Action) {
memoryState = reducer(memoryState, action)
listeners.forEach((listener) => {
listener(memoryState)
})
}
type Toast = Omit<ToasterToast, "id">
function toast({ ...props }: Toast) {
const id = genId()
const update = (props: ToasterToast) =>
dispatch({
type: "UPDATE_TOAST",
toast: { ...props, id },
})
const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
const newProps = { ...props }
dispatch({
type: "ADD_TOAST",
toast: {
...newProps,
id,
open: true,
onOpenChange: (open: boolean) => {
if (!open) dismiss()
},
},
})
return {
id: id,
dismiss,
update,
}
}
function useToast() {
const [state, setState] = React.useState<State>(memoryState)
React.useEffect(() => {
listeners.push(setState)
return () => {
const index = listeners.indexOf(setState)
if (index > -1) {
listeners.splice(index, 1)
}
}
}, [state])
return {
...state,
toast,
dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
}
}
export { useToast, toast }

View File

@ -75,11 +75,11 @@ export async function getConfig(): Promise<void> {
* Step 3: Load prompts store after config is received
*/
export async function loadStore(
callbacks: Pick<InitCallbacks, 'setPrompts'>,
callbacks: Pick<InitCallbacks, 'setPrompts' | 'setApiKey'>,
setPromptHistory?: (history: string[]) => void,
setFileHistory?: (fileHistory: string[]) => void
): Promise<PromptTemplate[]> {
const { setPrompts } = callbacks;
const { setPrompts, setApiKey } = callbacks;
log.debug('🔄 Loading prompts from store...');
@ -126,8 +126,14 @@ export async function loadStore(
files: data.fileHistory.map((f: string) => f.split(/[/\\]/).pop())
});
setFileHistory(data.fileHistory);
}
log.info(`✅ Loaded ${data.prompts.length} prompts, ${data.history?.length || 0} history entries, ${data.fileHistory?.length || 0} file history entries from store`);
}
// Load API key if available
if (data.apiKey && typeof data.apiKey === 'string') {
setApiKey(data.apiKey);
}
log.info(`✅ Loaded ${data.prompts.length} prompts, ${data.history?.length || 0} history entries, ${data.fileHistory?.length || 0} file history entries, ${data.apiKey ? 'API key' : 'no API key'} from store`);
return data.prompts;
} else {
@ -313,7 +319,8 @@ export async function completeInitialization(
export async function saveToStore(updates: {
prompts?: PromptTemplate[],
history?: string[],
fileHistory?: string[]
fileHistory?: string[],
apiKey?: string
}): Promise<void> {
const { isTauri: isTauriEnv } = await tauriApi.ensureTauriApi();
@ -329,7 +336,7 @@ export async function saveToStore(updates: {
const BaseDir = tauriApi.fs.BaseDirectory;
// Load existing data first to merge
let existingData = { prompts: [], history: [], fileHistory: [] };
let existingData = { prompts: [], history: [], fileHistory: [], apiKey: '' };
try {
let existingContent: string;
if (BaseDir && BaseDir.AppData !== undefined) {
@ -340,7 +347,14 @@ export async function saveToStore(updates: {
existingContent = await tauriApi.fs.readTextFile(storePath);
}
if (existingContent) {
existingData = JSON.parse(existingContent);
const parsed = JSON.parse(existingContent);
// Ensure all fields exist with defaults
existingData = {
prompts: parsed.prompts || [],
history: parsed.history || [],
fileHistory: parsed.fileHistory || [],
apiKey: parsed.apiKey || ''
};
}
} catch (loadError) {
log.debug('No existing store to merge with');
@ -350,7 +364,8 @@ export async function saveToStore(updates: {
const mergedData = {
prompts: updates.prompts !== undefined ? updates.prompts : existingData.prompts || [],
history: updates.history !== undefined ? updates.history : existingData.history || [],
fileHistory: updates.fileHistory !== undefined ? updates.fileHistory : existingData.fileHistory || []
fileHistory: updates.fileHistory !== undefined ? updates.fileHistory : existingData.fileHistory || [],
apiKey: updates.apiKey !== undefined ? updates.apiKey : existingData.apiKey || ''
};
const dataToSave = JSON.stringify(mergedData, null, 2);
@ -358,7 +373,18 @@ export async function saveToStore(updates: {
promptCount: mergedData.prompts.length,
historyCount: mergedData.history.length,
fileHistoryCount: mergedData.fileHistory.length,
dataLength: dataToSave.length
hasApiKey: !!mergedData.apiKey,
apiKeyLength: mergedData.apiKey?.length || 0,
dataLength: dataToSave.length,
updates: Object.keys(updates)
});
console.log('🔍 Store merge debug:', {
existingApiKey: !!existingData.apiKey,
newApiKey: !!updates.apiKey,
finalApiKey: !!mergedData.apiKey,
existingPrompts: existingData.prompts.length,
finalPrompts: mergedData.prompts.length
});
// Write using the same approach as loading

View File

@ -2,7 +2,7 @@ import {
TauriCommand,
TauriEvent
} from '../constants';
import { PromptTemplate } from '../types';
// import { BaseDirectory } from '@tauri-apps/plugin-fs'
// Dynamically import Tauri APIs
let invoke: any;
@ -21,14 +21,16 @@ let fetch: any;
let appConfigDir: any;
let appDataDir: any;
let join: any;
let isTauri = false;
let apiInitialized = false;
let platform: any;
const isBrowser = typeof window !== 'undefined';
const apiInitializationPromise = (async () => {
if (!isBrowser) {
console.log('Not in browser environment');
platform = 'browser';
return;
}
@ -45,7 +47,8 @@ const apiInitializationPromise = (async () => {
dialogApi,
fsApi,
httpApi,
pathApi
pathApi,
osApi
] = await Promise.all([
import('@tauri-apps/api/window'),
import('@tauri-apps/api/webview'),
@ -54,7 +57,8 @@ const apiInitializationPromise = (async () => {
import('@tauri-apps/plugin-dialog'),
import('@tauri-apps/plugin-fs'),
import('@tauri-apps/plugin-http'),
import('@tauri-apps/api/path')
import('@tauri-apps/api/path'),
import('@tauri-apps/plugin-os')
]);
// Test if we can actually use the APIs (this will throw if not in Tauri)
@ -64,8 +68,9 @@ const apiInitializationPromise = (async () => {
console.log('🔍 pathApi keys:', Object.keys(pathApi));
console.log('🔍 pathApi.BaseDirectory:', pathApi.BaseDirectory);
console.log('🔍 fsApi keys:', Object.keys(fsApi));
console.log('🔍 fsApi.BaseDirectory:', fsApi.BaseDirectory);
console.log('🔍 fsApi.BaseDirectory:', fsApi.BaseDirectory);
//* The value is set at compile time. Possible values are `'linux'`, `'macos'`, `'ios'`, `'freebsd'`, `'dragonfly'`, `'netbsd'`, `'openbsd'`, `'solaris'`, `'android'`, `'windows'`
console.log('🔍 osApi.platform:', osApi.platform());
// Assign all APIs
getCurrentWindow = windowApi.getCurrentWindow;
getCurrentWebview = webviewApi.getCurrentWebview;
@ -83,7 +88,7 @@ const apiInitializationPromise = (async () => {
appConfigDir = pathApi.appConfigDir;
appDataDir = pathApi.appDataDir;
join = pathApi.join;
platform = osApi.platform;
isTauri = true;
apiInitialized = true;
console.log('✅ All Tauri APIs loaded successfully');

View File

@ -0,0 +1,6 @@
import { clsx, type ClassValue } from "clsx"
import { twMerge } from "tailwind-merge"
export function cn(...inputs: ClassValue[]) {
return twMerge(clsx(inputs))
}

View File

@ -15,10 +15,13 @@
"jsx": "react-jsx",
/* Linting */
"strict": true,
"strict": false,
"noUnusedLocals": false,
"noUnusedParameters": false,
"noFallthroughCasesInSwitch": true
"noFallthroughCasesInSwitch": true,
"paths": {
"@/*": ["./src/*"]
}
},
"include": ["src"],
"references": [{ "path": "./tsconfig.node.json" }]

View File

@ -2,7 +2,7 @@ import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import tailwindcss from '@tailwindcss/vite'
const host = process.env.TAURI_DEV_HOST;
const host = process.env.TAURI_DEV_HOST || "0.0.0.0";
// https://vite.dev/config/
export default defineConfig(async () => ({

Binary file not shown.

Before

Width:  |  Height:  |  Size: 121 KiB