@valni/cli-darwin-x64 0.1.2 → 0.1.3

package/runtime/node_modules/@mariozechner/clipboard/src/clipboard_rs/common.rs

@@ -1,307 +0,0 @@
-#[cfg(feature = "image")]
-use image::imageops::FilterType;
-#[cfg(feature = "image")]
-use image::{ColorType, DynamicImage, GenericImageView, ImageFormat, RgbaImage};
-use std::error::Error;
-use std::io::Cursor;
-pub type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync + 'static>>;
-
-pub trait ContentData {
-  fn get_format(&self) -> ContentFormat;
-
-  fn as_bytes(&self) -> &[u8];
-
-  fn as_str(&self) -> Result<&str>;
-}
-
-pub trait ClipboardHandler {
-  fn on_clipboard_change(&mut self);
-}
-
-pub enum ClipboardContent {
-  Text(String),
-  Rtf(String),
-  Html(String),
-  #[cfg(feature = "image")]
-  Image(RustImageData),
-  Files(Vec<String>),
-  Other(String, Vec<u8>),
-}
-
-impl ContentData for ClipboardContent {
-  fn get_format(&self) -> ContentFormat {
-    match self {
-      ClipboardContent::Text(_) => ContentFormat::Text,
-      ClipboardContent::Rtf(_) => ContentFormat::Rtf,
-      ClipboardContent::Html(_) => ContentFormat::Html,
-      #[cfg(feature = "image")]
-      ClipboardContent::Image(_) => ContentFormat::Image,
-      ClipboardContent::Files(_) => ContentFormat::Files,
-      ClipboardContent::Other(format, _) => ContentFormat::Other(format.clone()),
-    }
-  }
-
-  fn as_bytes(&self) -> &[u8] {
-    match self {
-      ClipboardContent::Text(data) => data.as_bytes(),
-      ClipboardContent::Rtf(data) => data.as_bytes(),
-      ClipboardContent::Html(data) => data.as_bytes(),
-      // dynamic image is not supported to as bytes
-      #[cfg(feature = "image")]
-      ClipboardContent::Image(_) => &[],
-      ClipboardContent::Files(data) => {
-        // use first file path as data
-        if let Some(path) = data.first() {
-          path.as_bytes()
-        } else {
-          &[]
-        }
-      }
-      ClipboardContent::Other(_, data) => data.as_slice(),
-    }
-  }
-
-  fn as_str(&self) -> Result<&str> {
-    match self {
-      ClipboardContent::Text(data) => Ok(data),
-      ClipboardContent::Rtf(data) => Ok(data),
-      ClipboardContent::Html(data) => Ok(data),
-      #[cfg(feature = "image")]
-      ClipboardContent::Image(_) => Err("can't convert image to string".into()),
-      ClipboardContent::Files(data) => {
-        // use first file path as data
-        if let Some(path) = data.first() {
-          Ok(path)
-        } else {
-          Err("content is empty".into())
-        }
-      }
-      ClipboardContent::Other(_, data) => std::str::from_utf8(data).map_err(|e| e.into()),
-    }
-  }
-}
-
-#[derive(Clone)]
-pub enum ContentFormat {
-  Text,
-  Rtf,
-  Html,
-  #[cfg(feature = "image")]
-  Image,
-  Files,
-  Other(String),
-}
-
-#[cfg(feature = "image")]
-pub struct RustImageData {
-  width: u32,
-  height: u32,
-  data: Option<DynamicImage>,
-}
-
-/// 此处的 `RustImageBuffer` 已经是带有图片格式的字节流，例如 png,jpeg;
-#[cfg(feature = "image")]
-pub struct RustImageBuffer(Vec<u8>);
-
-#[cfg(feature = "image")]
-pub trait RustImage: Sized {
-  /// create an empty image
-  fn empty() -> Self;
-
-  fn is_empty(&self) -> bool;
-
-  /// Read image from file path
-  fn from_path(path: &str) -> Result<Self>;
-
-  /// Create a new image from a byte slice
-  fn from_bytes(bytes: &[u8]) -> Result<Self>;
-
-  fn from_dynamic_image(image: DynamicImage) -> Self;
-
-  /// width and height
-  fn get_size(&self) -> (u32, u32);
-
-  /// Scale this image down to fit within a specific size.
-  /// Returns a new image. The image's aspect ratio is preserved.
-  /// The image is scaled to the maximum possible size that fits
-  /// within the bounds specified by `nwidth` and `nheight`.
-  ///
-  /// This method uses a fast integer algorithm where each source
-  /// pixel contributes to exactly one target pixel.
-  /// May give aliasing artifacts if new size is close to old size.
-  fn thumbnail(&self, width: u32, height: u32) -> Result<Self>;
-
-  /// en: Adjust the size of the image without retaining the aspect ratio
-  /// zh: 调整图片大小，不保留长宽比
-  fn resize(&self, width: u32, height: u32, filter: FilterType) -> Result<Self>;
-
-  fn encode_image(
-    &self,
-    target_color_type: ColorType,
-    format: ImageFormat,
-  ) -> Result<RustImageBuffer>;
-
-  fn to_jpeg(&self) -> Result<RustImageBuffer>;
-
-  /// en: Convert to png format, the returned image is a new image, and the data itself will not be modified
-  /// zh: 转为 png 格式,返回的为新的图片，本身数据不会修改
-  fn to_png(&self) -> Result<RustImageBuffer>;
-
-  #[cfg(target_os = "windows")]
-  fn to_bitmap(&self) -> Result<RustImageBuffer>;
-
-  fn save_to_path(&self, path: &str) -> Result<()>;
-
-  fn get_dynamic_image(&self) -> Result<DynamicImage>;
-
-  fn to_rgba8(&self) -> Result<RgbaImage>;
-}
-
-#[cfg(feature = "image")]
-impl RustImage for RustImageData {
-  fn empty() -> Self {
-    RustImageData {
-      width: 0,
-      height: 0,
-      data: None,
-    }
-  }
-
-  fn is_empty(&self) -> bool {
-    self.data.is_none()
-  }
-
-  fn from_path(path: &str) -> Result<Self> {
-    let image = image::open(path)?;
-    let (width, height) = image.dimensions();
-    Ok(RustImageData {
-      width,
-      height,
-      data: Some(image),
-    })
-  }
-
-  fn from_bytes(bytes: &[u8]) -> Result<Self> {
-    let image = image::load_from_memory(bytes)?;
-    let (width, height) = image.dimensions();
-    Ok(RustImageData {
-      width,
-      height,
-      data: Some(image),
-    })
-  }
-
-  fn from_dynamic_image(image: DynamicImage) -> Self {
-    let (width, height) = image.dimensions();
-    RustImageData {
-      width,
-      height,
-      data: Some(image),
-    }
-  }
-
-  fn get_size(&self) -> (u32, u32) {
-    (self.width, self.height)
-  }
-
-  fn thumbnail(&self, width: u32, height: u32) -> Result<Self> {
-    match &self.data {
-      Some(image) => {
-        let resized = image.thumbnail(width, height);
-        Ok(RustImageData {
-          width: resized.width(),
-          height: resized.height(),
-          data: Some(resized),
-        })
-      }
-      None => Err("image is empty".into()),
-    }
-  }
-
-  fn resize(&self, width: u32, height: u32, filter: FilterType) -> Result<Self> {
-    match &self.data {
-      Some(image) => {
-        let resized = image.resize_exact(width, height, filter);
-        Ok(RustImageData {
-          width: resized.width(),
-          height: resized.height(),
-          data: Some(resized),
-        })
-      }
-      None => Err("image is empty".into()),
-    }
-  }
-
-  fn save_to_path(&self, path: &str) -> Result<()> {
-    match &self.data {
-      Some(image) => {
-        image.save(path)?;
-        Ok(())
-      }
-      None => Err("image is empty".into()),
-    }
-  }
-
-  fn get_dynamic_image(&self) -> Result<DynamicImage> {
-    match &self.data {
-      Some(image) => Ok(image.clone()),
-      None => Err("image is empty".into()),
-    }
-  }
-
-  fn to_rgba8(&self) -> Result<RgbaImage> {
-    match &self.data {
-      Some(image) => Ok(image.to_rgba8()),
-      None => Err("image is empty".into()),
-    }
-  }
-
-  // 私有辅助函数，处理图像格式转换和编码
-  fn encode_image(
-    &self,
-    target_color_type: ColorType,
-    format: ImageFormat,
-  ) -> Result<RustImageBuffer> {
-    let image = self.data.as_ref().ok_or("image is empty")?;
-
-    let mut bytes = Vec::new();
-    match (image.color(), target_color_type) {
-      (ColorType::Rgba8, ColorType::Rgb8) => image
-        .to_rgb8()
-        .write_to(&mut Cursor::new(&mut bytes), format)?,
-      (_, ColorType::Rgba8) => image
-        .to_rgba8()
-        .write_to(&mut Cursor::new(&mut bytes), format)?,
-      _ => image.write_to(&mut Cursor::new(&mut bytes), format)?,
-    };
-    Ok(RustImageBuffer(bytes))
-  }
-
-  fn to_jpeg(&self) -> Result<RustImageBuffer> {
-    // JPEG 需要 RGB 格式（不支持 alpha 通道）
-    self.encode_image(ColorType::Rgb8, ImageFormat::Jpeg)
-  }
-
-  fn to_png(&self) -> Result<RustImageBuffer> {
-    // PNG 使用 RGBA 格式以支持透明度
-    self.encode_image(ColorType::Rgba8, ImageFormat::Png)
-  }
-
-  #[cfg(target_os = "windows")]
-  fn to_bitmap(&self) -> Result<RustImageBuffer> {
-    // BMP 使用 RGBA 格式
-    self.encode_image(ColorType::Rgba8, ImageFormat::Bmp)
-  }
-}
-
-#[cfg(feature = "image")]
-impl RustImageBuffer {
-  pub fn get_bytes(&self) -> &[u8] {
-    &self.0
-  }
-
-  pub fn save_to_path(&self, path: &str) -> Result<()> {
-    std::fs::write(path, &self.0)?;
-    Ok(())
-  }
-}

package/runtime/node_modules/@mariozechner/clipboard/src/clipboard_rs/mod.rs

@@ -1,93 +0,0 @@
-pub mod common;
-mod platform;
-#[cfg(feature = "image")]
-pub use common::RustImageData;
-pub use common::{ClipboardContent, ClipboardHandler, ContentFormat, Result};
-#[cfg(feature = "image")]
-pub use image::imageops::FilterType;
-#[cfg(target_os = "linux")]
-pub use platform::ClipboardContextX11Options;
-pub use platform::{ClipboardContext, ClipboardWatcherContext, WatcherShutdown};
-
-pub trait Clipboard: Send {
-  /// zh: 获得剪切板当前内容的所有格式
-  /// en: Get all formats of the current content in the clipboard
-  fn available_formats(&self) -> Result<Vec<String>>;
-
-  fn has(&self, format: ContentFormat) -> bool;
-
-  /// zh: 清空剪切板
-  /// en: clear clipboard
-  fn clear(&self) -> Result<()>;
-
-  /// zh: 获得指定格式的数据，以字节数组形式返回
-  /// en: Get the data in the specified format in the clipboard as a byte array
-  fn get_buffer(&self, format: &str) -> Result<Vec<u8>>;
-
-  /// zh: 仅获得无格式纯文本，以字符串形式返回
-  /// en: Get plain text content in the clipboard as string
-  fn get_text(&self) -> Result<String>;
-
-  /// zh: 获得剪贴板中的富文本内容，以字符串形式返回
-  /// en: Get the rich text content in the clipboard as string
-  fn get_rich_text(&self) -> Result<String>;
-
-  /// zh: 获得剪贴板中的html内容，以字符串形式返回
-  /// en: Get the html format content in the clipboard as string
-  fn get_html(&self) -> Result<String>;
-
-  #[cfg(feature = "image")]
-  fn get_image(&self) -> Result<RustImageData>;
-
-  fn get_files(&self) -> Result<Vec<String>>;
-
-  fn get(&self, formats: &[ContentFormat]) -> Result<Vec<ClipboardContent>>;
-
-  fn set_buffer(&self, format: &str, buffer: Vec<u8>) -> Result<()>;
-
-  fn set_text(&self, text: String) -> Result<()>;
-
-  fn set_rich_text(&self, text: String) -> Result<()>;
-
-  fn set_html(&self, html: String) -> Result<()>;
-
-  #[cfg(feature = "image")]
-  fn set_image(&self, image: RustImageData) -> Result<()>;
-
-  fn set_files(&self, files: Vec<String>) -> Result<()>;
-
-  /// set image will clear clipboard
-  fn set(&self, contents: Vec<ClipboardContent>) -> Result<()>;
-}
-
-pub trait ClipboardWatcher<T: ClipboardHandler>: Send {
-  /// zh: 添加一个剪切板变化处理器，可以添加多个处理器，处理器需要实现 [`ClipboardHandler`] 这个trait
-  /// en: Add a clipboard change handler, you can add multiple handlers, the handler needs to implement the trait [`ClipboardHandler`]
-  fn add_handler(&mut self, handler: T) -> &mut Self;
-
-  /// zh: 开始监视剪切板变化，这是一个阻塞方法，直到监视结束，或者调用了stop方法，所以建议在单独的线程中调用
-  /// en: Start monitoring clipboard changes, this is a blocking method, until the monitoring ends, or the stop method is called, so it is recommended to call it in a separate thread
-  fn start_watch(&mut self);
-
-  /// zh: 获得停止监视的通道，可以通过这个通道停止监视
-  /// en: Get the channel to stop monitoring, you can stop monitoring through this channel
-  fn get_shutdown_channel(&self) -> WatcherShutdown;
-}
-
-#[cfg(not(all(
-  unix,
-  not(any(
-    target_os = "macos",
-    target_os = "ios",
-    target_os = "android",
-    target_os = "emscripten"
-  ))
-)))]
-impl WatcherShutdown {
-  /// zh: 停止监视
-  ///
-  /// en: stop watching
-  pub fn stop(self) {
-    drop(self);
-  }
-}

package/runtime/node_modules/@mariozechner/clipboard/src/clipboard_rs/platform/ios.rs

@@ -1,313 +0,0 @@
-use crate::clipboard_rs::{
-  common::Result, Clipboard, ClipboardContent, ClipboardHandler, ClipboardWatcher, ContentFormat,
-};
-#[cfg(feature = "image")]
-use crate::clipboard_rs::{common::RustImage, RustImageData};
-use objc2::{rc::Retained, runtime::ProtocolObject};
-use objc2_foundation::{ns_string, NSArray, NSData, NSDictionary, NSString};
-use objc2_ui_kit::UIPasteboard;
-#[cfg(feature = "image")]
-use objc2_ui_kit::{UIImage, UIImagePNGRepresentation};
-use std::{
-  sync::mpsc::{self, Receiver, Sender},
-  time::Duration,
-};
-
-pub struct ClipboardContext {
-  clipboard: Retained<UIPasteboard>,
-}
-pub struct ClipboardWatcherContext<T: ClipboardHandler> {
-  clipboard: Retained<UIPasteboard>,
-  handlers: Vec<T>,
-  running: bool,
-  stop_signal: Sender<()>,
-  stop_receiver: Receiver<()>,
-}
-
-impl<T: ClipboardHandler> ClipboardWatcherContext<T> {
-  pub fn new() -> Result<Self> {
-    let clipboard = unsafe { UIPasteboard::generalPasteboard() };
-    let (tx, rx) = mpsc::channel();
-    Ok(Self {
-      clipboard,
-      handlers: Vec::new(),
-      running: false,
-      stop_signal: tx,
-      stop_receiver: rx,
-    })
-  }
-}
-
-unsafe impl<T: ClipboardHandler> Send for ClipboardWatcherContext<T> {}
-
-impl<T: ClipboardHandler> ClipboardWatcher<T> for ClipboardWatcherContext<T> {
-  fn add_handler(&mut self, handler: T) -> &mut Self {
-    self.handlers.push(handler);
-    self
-  }
-
-  fn start_watch(&mut self) {
-    if self.running {
-      println!("already start watch!");
-      return;
-    }
-    if self.handlers.is_empty() {
-      println!("no handler, no need to start watch!");
-      return;
-    }
-    self.running = true;
-    let mut last_change_count = unsafe { self.clipboard.changeCount() };
-    loop {
-      // if receive stop signal, break loop
-      if self
-        .stop_receiver
-        .recv_timeout(Duration::from_millis(500))
-        .is_ok()
-      {
-        break;
-      }
-      let change_count = unsafe { self.clipboard.changeCount() };
-      if last_change_count == 0 {
-        last_change_count = change_count;
-      } else if change_count != last_change_count {
-        self
-          .handlers
-          .iter_mut()
-          .for_each(|handler| handler.on_clipboard_change());
-        last_change_count = change_count;
-      }
-    }
-    self.running = false;
-  }
-
-  fn get_shutdown_channel(&self) -> WatcherShutdown {
-    WatcherShutdown {
-      stop_signal: self.stop_signal.clone(),
-    }
-  }
-}
-
-pub struct WatcherShutdown {
-  stop_signal: Sender<()>,
-}
-
-impl Drop for WatcherShutdown {
-  fn drop(&mut self) {
-    let _ = self.stop_signal.send(());
-  }
-}
-
-impl ClipboardContext {
-  pub fn new() -> Result<Self> {
-    let clipboard = unsafe { UIPasteboard::generalPasteboard() };
-    Ok(Self { clipboard })
-  }
-
-  fn write_to_clipboard(&self, data: &[ClipboardContent]) -> Result<()> {
-    let items = data
-      .iter()
-      .map(|content| match content {
-        ClipboardContent::Text(text) => {
-          let ns_text = NSString::from_str(text);
-          let pair = unsafe {
-            NSDictionary::dictionaryWithObject_forKey(
-              ns_text.as_ref(),
-              ProtocolObject::from_ref(ns_string!("public.utf8-plain-text")),
-            )
-          };
-          Some(pair)
-        }
-        ClipboardContent::Rtf(rtf) => {
-          let ns_rtf = NSString::from_str(rtf);
-          let pair = unsafe {
-            NSDictionary::dictionaryWithObject_forKey(
-              ns_rtf.as_ref(),
-              ProtocolObject::from_ref(ns_string!("public.rtf")),
-            )
-          };
-          Some(pair)
-        }
-        ClipboardContent::Html(html) => {
-          let ns_html = NSString::from_str(html);
-          let pair = unsafe {
-            NSDictionary::dictionaryWithObject_forKey(
-              ns_html.as_ref(),
-              ProtocolObject::from_ref(ns_string!("public.html")),
-            )
-          };
-          Some(pair)
-        }
-        #[cfg(feature = "image")]
-        ClipboardContent::Image(image) => {
-          let png = image.to_png().unwrap();
-          let ns_data = NSData::with_bytes(png.get_bytes());
-          let image = unsafe { UIImage::imageWithData(&ns_data) };
-          if let Some(image) = image {
-            let pair = unsafe {
-              NSDictionary::dictionaryWithObject_forKey(
-                image.as_ref(),
-                ProtocolObject::from_ref(ns_string!("public.png")),
-              )
-            };
-            Some(pair)
-          } else {
-            None
-          }
-        }
-        _ => None,
-      })
-      .filter_map(|item| item)
-      .collect::<Vec<_>>();
-    unsafe {
-      self
-        .clipboard
-        .setItems(&NSArray::from_retained_slice(&items))
-    };
-    Ok(())
-  }
-}
-
-impl Clipboard for ClipboardContext {
-  fn available_formats(&self) -> Result<Vec<String>> {
-    let formats = unsafe { self.clipboard.pasteboardTypes() };
-    Ok(formats.iter().map(|f| f.to_string()).collect())
-  }
-
-  fn has(&self, format: ContentFormat) -> bool {
-    match format {
-      ContentFormat::Text => unsafe { self.clipboard.hasStrings() },
-      #[cfg(feature = "image")]
-      ContentFormat::Image => unsafe { self.clipboard.hasImages() },
-      ContentFormat::Rtf => unsafe {
-        self
-          .clipboard
-          .containsPasteboardTypes(&NSArray::from_slice(&[ns_string!("public.rtf")]))
-      },
-      ContentFormat::Html => unsafe {
-        self
-          .clipboard
-          .containsPasteboardTypes(&NSArray::from_slice(&[ns_string!("public.html")]))
-      },
-      ContentFormat::Files => false,
-      ContentFormat::Other(format) => unsafe {
-        self
-          .clipboard
-          .containsPasteboardTypes(&NSArray::from_retained_slice(&[NSString::from_str(
-            &format,
-          )]))
-      },
-    }
-  }
-
-  fn clear(&self) -> Result<()> {
-    unsafe { self.clipboard.setItems(&NSArray::from_slice(&[])) };
-    Ok(())
-  }
-
-  fn get_buffer(&self, format: &str) -> Result<Vec<u8>> {
-    let ns_format = NSString::from_str(format);
-    let data = unsafe { self.clipboard.dataForPasteboardType(&ns_format) };
-    if let Some(data) = data {
-      Ok(data.to_vec())
-    } else {
-      Err("No data found".into())
-    }
-  }
-
-  fn get_text(&self) -> Result<String> {
-    let text = unsafe { self.clipboard.string() };
-    if let Some(text) = text {
-      Ok(text.to_string())
-    } else {
-      Err("No text found".into())
-    }
-  }
-
-  fn get_rich_text(&self) -> Result<String> {
-    let buffer = self.get_buffer("public.rtf")?;
-    Ok(String::from_utf8_lossy(&buffer).to_string())
-  }
-
-  fn get_html(&self) -> Result<String> {
-    let buffer = self.get_buffer("public.html")?;
-    Ok(String::from_utf8_lossy(&buffer).to_string())
-  }
-
-  #[cfg(feature = "image")]
-  fn get_image(&self) -> Result<RustImageData> {
-    let image = unsafe { self.clipboard.image() };
-    if let Some(image) = image {
-      let data = unsafe { UIImagePNGRepresentation(&image) };
-      if let Some(data) = data {
-        let bytes = unsafe { data.as_bytes_unchecked() };
-        Ok(RustImageData::from_bytes(bytes)?)
-      } else {
-        Err("No image data found".into())
-      }
-    } else {
-      Err("No image found".into())
-    }
-  }
-
-  fn get_files(&self) -> Result<Vec<String>> {
-    Err("Not supported".into())
-  }
-
-  fn get(&self, _formats: &[ContentFormat]) -> Result<Vec<ClipboardContent>> {
-    Err("Not supported".into())
-  }
-
-  fn set_buffer(&self, format: &str, buffer: Vec<u8>) -> Result<()> {
-    let ns_format = NSString::from_str(format);
-    let ns_data = NSData::with_bytes(&buffer);
-    unsafe {
-      self
-        .clipboard
-        .setData_forPasteboardType(&ns_data, &ns_format)
-    }
-    Ok(())
-  }
-
-  fn set_text(&self, text: String) -> Result<()> {
-    unsafe {
-      self
-        .clipboard
-        .setString(Some(&NSString::from_str(text.as_str())))
-    };
-    Ok(())
-  }
-
-  fn set_rich_text(&self, _text: String) -> Result<()> {
-    Err("Not supported".into())
-  }
-
-  fn set_html(&self, _html: String) -> Result<()> {
-    Err("Not supported".into())
-  }
-
-  #[cfg(feature = "image")]
-  fn set_image(&self, image: RustImageData) -> Result<()> {
-    if image.is_empty() {
-      Err("Image is empty".into())
-    } else {
-      let png = image.to_png()?;
-      let ns_data = NSData::with_bytes(png.get_bytes());
-      let image = unsafe { UIImage::imageWithData(&ns_data) };
-      if let Some(image) = image {
-        unsafe { self.clipboard.setImage(Some(&image)) };
-        Ok(())
-      } else {
-        Err("Failed to create image".into())
-      }
-    }
-  }
-
-  fn set_files(&self, _files: Vec<String>) -> Result<()> {
-    Err("Not supported".into())
-  }
-
-  fn set(&self, contents: Vec<ClipboardContent>) -> Result<()> {
-    self.write_to_clipboard(&contents)?;
-    Ok(())
-  }
-}