@akiojin/gwt 6.30.3 → 9.0.1

package/vendor/ratatui-core/src/text.rs

@@ -0,0 +1,64 @@
+//! Primitives for styled text.
+//!
+//! A terminal UI is at its root a lot of strings. In order to make it accessible and stylish, those
+//! strings may be associated to a set of styles. `ratatui` has three ways to represent them:
+//! - A single line string where all graphemes have the same style is represented by a [`Span`].
+//! - A single line string where each grapheme may have its own style is represented by [`Line`].
+//! - A multiple line string where each grapheme may have its own style is represented by a
+//!   [`Text`].
+//!
+//! These types form a hierarchy: [`Line`] is a collection of [`Span`] and each line of [`Text`] is
+//! a [`Line`].
+//!
+//! Keep it mind that a lot of widgets will use those types to advertise what kind of string is
+//! supported for their properties. Moreover, `ratatui` provides convenient `From` implementations
+//! so that you can start by using simple `String` or `&str` and then promote them to the previous
+//! primitives when you need additional styling capabilities.
+//!
+//! For example, for the `Block` widget, all the following calls are valid to set its `title`
+//! property (which is a [`Line`] under the hood):
+//!
+//! ```rust,ignore
+//! use ratatui_core::{
+//!     style::{Color, Style},
+//!     text::{Line, Span},
+//!     widgets::Block,
+//! };
+//!
+//! // A simple string with no styling.
+//! // Converted to Line(vec![
+//! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
+//! // ])
+//! let block = Block::new().title("My title");
+//!
+//! // A simple string with a unique style.
+//! // Converted to Line(vec![
+//! //   Span { content: Cow::Borrowed("My title"), style: Style { fg: Some(Color::Yellow), .. }
+//! // ])
+//! let block = Block::new().title(Span::styled("My title", Style::default().fg(Color::Yellow)));
+//!
+//! // A string with multiple styles.
+//! // Converted to Line(vec![
+//! //   Span { content: Cow::Borrowed("My"), style: Style { fg: Some(Color::Yellow), .. } },
+//! //   Span { content: Cow::Borrowed(" title"), .. }
+//! // ])
+//! let block = Block::new().title(vec![
+//!     Span::styled("My", Style::default().fg(Color::Yellow)),
+//!     Span::raw(" title"),
+//! ]);
+//! ```
+
+mod grapheme;
+pub use grapheme::StyledGrapheme;
+
+mod line;
+pub use line::{Line, ToLine};
+
+mod masked;
+pub use masked::Masked;
+
+mod span;
+pub use span::{Span, ToSpan};
+
+mod text;
+pub use text::{Text, ToText};

package/vendor/ratatui-core/src/widgets/stateful_widget.rs

@@ -0,0 +1,193 @@
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+
+/// A `StatefulWidget` is a widget that can take advantage of some local state to remember things
+/// between two draw calls.
+///
+/// For a comprehensive guide to widgets, including trait explanations, implementation patterns,
+/// and available widgets, see the [`widgets`] module documentation.
+///
+/// [`widgets`]: ../../ratatui/widgets/index.html
+///
+/// Most widgets can be drawn directly based on the input parameters. However, some features may
+/// require some kind of associated state to be implemented.
+///
+/// For example, the `List` widget can highlight the item currently selected. This can be translated
+/// in an offset, which is the number of elements to skip in order to have the selected item within
+/// the viewport currently allocated to this widget. The widget can therefore only provide the
+/// following behavior: whenever the selected item is out of the viewport scroll to a predefined
+/// position (making the selected item the last viewable item or the one in the middle for example).
+/// Nonetheless, if the widget has access to the last computed offset then it can implement a
+/// natural scrolling experience where the last offset is reused until the selected item is out of
+/// the viewport.
+///
+/// ## Examples
+///
+/// ```rust,ignore
+/// use std::io;
+///
+/// use ratatui::{
+///     backend::TestBackend,
+///     widgets::{List, ListItem, ListState, StatefulWidget, Widget},
+///     Terminal,
+/// };
+///
+/// // Let's say we have some events to display.
+/// struct Events {
+///     // `items` is the state managed by your application.
+///     items: Vec<String>,
+///     // `state` is the state that can be modified by the UI. It stores the index of the selected
+///     // item as well as the offset computed during the previous draw call (used to implement
+///     // natural scrolling).
+///     state: ListState,
+/// }
+///
+/// impl Events {
+///     fn new(items: Vec<String>) -> Events {
+///         Events {
+///             items,
+///             state: ListState::default(),
+///         }
+///     }
+///
+///     pub fn set_items(&mut self, items: Vec<String>) {
+///         self.items = items;
+///         // We reset the state as the associated items have changed. This effectively reset
+///         // the selection as well as the stored offset.
+///         self.state = ListState::default();
+///     }
+///
+///     // Select the next item. This will not be reflected until the widget is drawn in the
+///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
+///     pub fn next(&mut self) {
+///         let i = match self.state.selected() {
+///             Some(i) => {
+///                 if i >= self.items.len() - 1 {
+///                     0
+///                 } else {
+///                     i + 1
+///                 }
+///             }
+///             None => 0,
+///         };
+///         self.state.select(Some(i));
+///     }
+///
+///     // Select the previous item. This will not be reflected until the widget is drawn in the
+///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
+///     pub fn previous(&mut self) {
+///         let i = match self.state.selected() {
+///             Some(i) => {
+///                 if i == 0 {
+///                     self.items.len() - 1
+///                 } else {
+///                     i - 1
+///                 }
+///             }
+///             None => 0,
+///         };
+///         self.state.select(Some(i));
+///     }
+///
+///     // Unselect the currently selected item if any. The implementation of `ListState` makes
+///     // sure that the stored offset is also reset.
+///     pub fn unselect(&mut self) {
+///         self.state.select(None);
+///     }
+/// }
+///
+/// # let backend = TestBackend::new(5, 5);
+/// # let mut terminal = Terminal::new(backend).unwrap();
+///
+/// let mut events = Events::new(vec![String::from("Item 1"), String::from("Item 2")]);
+///
+/// loop {
+///     terminal.draw(|f| {
+///         // The items managed by the application are transformed to something
+///         // that is understood by ratatui.
+///         let items: Vec<ListItem> = events
+///             .items
+///             .iter()
+///             .map(|i| ListItem::new(i.as_str()))
+///             .collect();
+///         // The `List` widget is then built with those items.
+///         let list = List::new(items);
+///         // Finally the widget is rendered using the associated state. `events.state` is
+///         // effectively the only thing that we will "remember" from this draw call.
+///         f.render_stateful_widget(list, f.size(), &mut events.state);
+///     });
+///
+///     // In response to some input events or an external http request or whatever:
+///     events.next();
+/// }
+/// ```
+pub trait StatefulWidget {
+    /// State associated with the stateful widget.
+    ///
+    /// If you don't need this then you probably want to implement [`Widget`] instead.
+    ///
+    /// [`Widget`]: super::Widget
+    type State: ?Sized;
+    /// Draws the current state of the widget in the given buffer. That is the only method required
+    /// to implement a custom stateful widget.
+    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
+}
+
+#[cfg(test)]
+mod tests {
+    use alloc::format;
+    use alloc::string::{String, ToString};
+
+    use rstest::{fixture, rstest};
+
+    use super::*;
+    use crate::buffer::Buffer;
+    use crate::layout::Rect;
+    use crate::text::Line;
+    use crate::widgets::Widget;
+
+    #[fixture]
+    fn buf() -> Buffer {
+        Buffer::empty(Rect::new(0, 0, 20, 1))
+    }
+
+    #[fixture]
+    fn state() -> String {
+        "world".to_string()
+    }
+
+    struct PersonalGreeting;
+
+    impl StatefulWidget for PersonalGreeting {
+        type State = String;
+        fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+            Line::from(format!("Hello {state}")).render(area, buf);
+        }
+    }
+
+    #[rstest]
+    fn render(mut buf: Buffer, mut state: String) {
+        let widget = PersonalGreeting;
+        widget.render(buf.area, &mut buf, &mut state);
+        assert_eq!(buf, Buffer::with_lines(["Hello world         "]));
+    }
+
+    struct Bytes;
+
+    /// A widget with an unsized state type.
+    impl StatefulWidget for Bytes {
+        type State = [u8];
+        fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+            let slice = core::str::from_utf8(state).unwrap();
+            Line::from(format!("Bytes: {slice}")).render(area, buf);
+        }
+    }
+
+    #[rstest]
+    fn render_unsized_state_type(mut buf: Buffer) {
+        let widget = Bytes;
+        let state = b"hello";
+        widget.render(buf.area, &mut buf, &mut state.clone());
+        assert_eq!(buf, Buffer::with_lines(["Bytes: hello        "]));
+    }
+}

package/vendor/ratatui-core/src/widgets/widget.rs

@@ -0,0 +1,174 @@
+use alloc::string::String;
+
+use crate::buffer::Buffer;
+use crate::layout::Rect;
+use crate::style::Style;
+
+/// A `Widget` is a type that can be drawn on a [`Buffer`] in a given [`Rect`].
+///
+/// For a comprehensive guide to widgets, including trait explanations, implementation patterns,
+/// and available widgets, see the [`widgets`] module documentation.
+///
+/// [`widgets`]: ../../ratatui/widgets/index.html
+///
+/// Prior to Ratatui 0.26.0, widgets generally were created for each frame as they were consumed
+/// during rendering. This meant that they were not meant to be stored but used as *commands* to
+/// draw common figures in the UI.
+///
+/// Starting with Ratatui 0.26.0, all the internal widgets implement Widget for a reference to
+/// themselves. This allows you to store a reference to a widget and render it later. Widget crates
+/// should consider also doing this to allow for more flexibility in how widgets are used.
+///
+/// In Ratatui 0.26.0, we also added an unstable `WidgetRef` trait and implemented this on all the
+/// internal widgets. In addition to the above benefit of rendering references to widgets, this also
+/// allows you to render boxed widgets. This is useful when you want to store a collection of
+/// widgets with different types. You can then iterate over the collection and render each widget.
+/// See <https://github.com/ratatui/ratatui/issues/1287> for more information.
+///
+/// In general where you expect a widget to immutably work on its data, we recommended to implement
+/// `Widget` for a reference to the widget (`impl Widget for &MyWidget`). If you need to store state
+/// between draw calls, implement `StatefulWidget` if you want the Widget to be immutable, or
+/// implement `Widget` for a mutable reference to the widget (`impl Widget for &mut MyWidget`) if
+/// you want the widget to be mutable. The mutable widget pattern is used infrequently in apps, but
+/// can be quite useful.
+///
+/// A blanket implementation of `Widget` for `&W` where `W` implements `WidgetRef` is provided.
+/// Widget is also implemented for `&str` and `String` types.
+///
+/// # Examples
+///
+/// ```rust,ignore
+/// use ratatui::{
+///     backend::TestBackend,
+///     widgets::{Clear, Widget},
+///     Terminal,
+/// };
+/// # let backend = TestBackend::new(5, 5);
+/// # let mut terminal = Terminal::new(backend).unwrap();
+///
+/// terminal.draw(|frame| {
+///     frame.render_widget(Clear, frame.area());
+/// });
+/// ```
+///
+/// It's common to render widgets inside other widgets:
+///
+/// ```rust
+/// use ratatui_core::buffer::Buffer;
+/// use ratatui_core::layout::Rect;
+/// use ratatui_core::text::Line;
+/// use ratatui_core::widgets::Widget;
+///
+/// struct MyWidget;
+///
+/// impl Widget for MyWidget {
+///     fn render(self, area: Rect, buf: &mut Buffer) {
+///         Line::raw("Hello").render(area, buf);
+///     }
+/// }
+/// ```
+pub trait Widget {
+    /// Draws the current state of the widget in the given buffer. That is the only method required
+    /// to implement a custom widget.
+    fn render(self, area: Rect, buf: &mut Buffer)
+    where
+        Self: Sized;
+}
+
+/// Renders a string slice as a widget.
+///
+/// This implementation allows a string slice (`&str`) to act as a widget, meaning it can be drawn
+/// onto a [`Buffer`] in a specified [`Rect`]. The slice represents a static string which can be
+/// rendered by reference, thereby avoiding the need for string cloning or ownership transfer when
+/// drawing the text to the screen.
+impl Widget for &str {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        buf.set_stringn(area.x, area.y, self, area.width as usize, Style::new());
+    }
+}
+
+/// Renders a `String` object as a widget.
+///
+/// This implementation enables an owned `String` to be treated as a widget, which can be rendered
+/// on a [`Buffer`] within the bounds of a given [`Rect`].
+impl Widget for String {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        buf.set_stringn(area.x, area.y, self, area.width as usize, Style::new());
+    }
+}
+
+impl<W: Widget> Widget for Option<W> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if let Some(widget) = self {
+            widget.render(area, buf);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use rstest::{fixture, rstest};
+
+    use super::*;
+    use crate::buffer::Buffer;
+    use crate::layout::Rect;
+    use crate::text::Line;
+
+    #[fixture]
+    fn buf() -> Buffer {
+        Buffer::empty(Rect::new(0, 0, 20, 1))
+    }
+
+    struct Greeting;
+
+    impl Widget for Greeting {
+        fn render(self, area: Rect, buf: &mut Buffer) {
+            Line::from("Hello").render(area, buf);
+        }
+    }
+
+    #[rstest]
+    fn render(mut buf: Buffer) {
+        let widget = Greeting;
+        widget.render(buf.area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["Hello               "]));
+    }
+
+    #[rstest]
+    fn render_str(mut buf: Buffer) {
+        "hello world".render(buf.area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
+    }
+
+    #[rstest]
+    fn render_str_truncate(mut buf: Buffer) {
+        let area = Rect::new(buf.area.x, buf.area.y, 11, buf.area.height);
+        "hello world, just hello".render(area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
+    }
+
+    #[rstest]
+    fn render_option_str(mut buf: Buffer) {
+        Some("hello world").render(buf.area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
+    }
+
+    #[rstest]
+    fn render_string(mut buf: Buffer) {
+        String::from("hello world").render(buf.area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
+    }
+
+    #[rstest]
+    fn render_string_truncate(mut buf: Buffer) {
+        let area = Rect::new(buf.area.x, buf.area.y, 11, buf.area.height);
+        String::from("hello world, just hello").render(area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
+    }
+
+    #[rstest]
+    fn render_option_string(mut buf: Buffer) {
+        Some(String::from("hello world")).render(buf.area, &mut buf);
+        assert_eq!(buf, Buffer::with_lines(["hello world         "]));
+    }
+}

package/vendor/ratatui-core/src/widgets.rs

@@ -0,0 +1,9 @@
+#![warn(missing_docs)]
+//! The `widgets` module contains the `Widget` and `StatefulWidget` traits, which are used to
+//! render UI elements on the screen.
+
+pub use self::stateful_widget::StatefulWidget;
+pub use self::widget::Widget;
+
+mod stateful_widget;
+mod widget;

package/bin/gwt.js

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-/**
- * Wrapper script to execute the gwt Rust binary.
- * This allows npm/bunx distribution of the Rust CLI.
- *
- * If the binary is not found (e.g., bunx skips postinstall),
- * it will be downloaded on-demand from GitHub Releases.
- */
-
-import { spawn } from 'child_process';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { existsSync, createWriteStream, mkdirSync, chmodSync, unlinkSync } from 'fs';
-import { get } from 'https';
-import {
-  REPO,
-  getPlatformArtifact,
-  getSupportedPlatformKeys,
-  getVersionedDownloadUrl,
-} from '../scripts/release-download.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const BIN_NAME = process.platform === 'win32' ? 'gwt.exe' : 'gwt';
-const BIN_PATH = join(__dirname, BIN_NAME);
-
-async function downloadFile(url, dest) {
-  return new Promise((resolve, reject) => {
-    const file = createWriteStream(dest);
-
-    const request = (url) => {
-      get(url, (res) => {
-        if (res.statusCode === 301 || res.statusCode === 302) {
-          request(res.headers.location);
-          return;
-        }
-
-        if (res.statusCode !== 200) {
-          reject(new Error(`Failed to download: HTTP ${res.statusCode}`));
-          return;
-        }
-
-        res.pipe(file);
-        file.on('finish', () => {
-          file.close();
-          resolve();
-        });
-      }).on('error', (err) => {
-        if (existsSync(dest)) unlinkSync(dest);
-        reject(err);
-      });
-    };
-
-    request(url);
-  });
-}
-
-function requirePlatformArtifact() {
-  const artifact = getPlatformArtifact();
-  if (!artifact) {
-    console.error(`Unsupported platform: ${process.platform}-${process.arch}`);
-    console.error(`Supported platforms: ${getSupportedPlatformKeys().join(', ')}`);
-    process.exit(1);
-  }
-  return artifact;
-}
-
-async function downloadBinary(url) {
-  if (!existsSync(__dirname)) {
-    mkdirSync(__dirname, { recursive: true });
-  }
-
-  await downloadFile(url, BIN_PATH);
-
-  if (process.platform !== 'win32') {
-    chmodSync(BIN_PATH, 0o755);
-  }
-
-  console.log('gwt binary installed successfully!');
-  console.log('');
-}
-
-function runBinary() {
-  const child = spawn(BIN_PATH, process.argv.slice(2), {
-    stdio: 'inherit',
-    env: process.env,
-  });
-
-  child.on('error', (err) => {
-    console.error('Failed to start gwt:', err.message);
-    process.exit(1);
-  });
-
-  child.on('exit', (code, signal) => {
-    if (signal) {
-      process.kill(process.pid, signal);
-    } else {
-      process.exit(code ?? 0);
-    }
-  });
-}
-
-async function main() {
-  if (!existsSync(BIN_PATH)) {
-    const artifact = requirePlatformArtifact();
-    let versionedUrl = null;
-    try {
-      const resolved = getVersionedDownloadUrl(artifact);
-      versionedUrl = resolved.url;
-      console.log(`Downloading gwt binary for ${process.platform}-${process.arch}...`);
-      console.log(`Downloading from: ${versionedUrl}`);
-      await downloadBinary(versionedUrl);
-    } catch (error) {
-      console.error('Failed to download gwt binary:', error.message);
-      console.error('');
-      console.error('You can manually download the binary from:');
-      if (versionedUrl) {
-        console.error(versionedUrl);
-      }
-      console.error(`https://github.com/${REPO}/releases`);
-      console.error('');
-      console.error('Or build from source with: cargo build --release');
-      process.exit(1);
-    }
-  }
-
-  runBinary();
-}
-
-main();

package/scripts/postinstall.test.js

@@ -1,71 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-
-import {
-  RETRY_CONFIG,
-  buildReleaseDownloadUrl,
-  formatFailureGuidance,
-  getRetryDelayMs,
-  isRetryableError,
-  isRetryableStatus,
-} from './postinstall.js';
-import {
-  getPackageVersion,
-  getVersionedDownloadUrl,
-} from './release-download.js';
-
-test('buildReleaseDownloadUrl uses version tag', () => {
-  const url = buildReleaseDownloadUrl('6.17.0', 'gwt-linux-x86_64');
-  assert.equal(
-    url,
-    'https://github.com/akiojin/gwt/releases/download/v6.17.0/gwt-linux-x86_64',
-  );
-});
-
-test('getRetryDelayMs applies exponential backoff with cap', () => {
-  assert.equal(getRetryDelayMs(1, RETRY_CONFIG), 500);
-  assert.equal(getRetryDelayMs(2, RETRY_CONFIG), 1000);
-  assert.equal(getRetryDelayMs(3, RETRY_CONFIG), 2000);
-  assert.equal(getRetryDelayMs(5, RETRY_CONFIG), 5000);
-});
-
-test('isRetryableStatus matches 403/404/5xx', () => {
-  assert.equal(isRetryableStatus(403), true);
-  assert.equal(isRetryableStatus(404), true);
-  assert.equal(isRetryableStatus(500), true);
-  assert.equal(isRetryableStatus(429), false);
-  assert.equal(isRetryableStatus(400), false);
-});
-
-test('isRetryableError uses statusCode or treats network errors as retryable', () => {
-  const notFound = new Error('not found');
-  notFound.statusCode = 404;
-  assert.equal(isRetryableError(notFound), true);
-
-  const badRequest = new Error('bad request');
-  badRequest.statusCode = 400;
-  assert.equal(isRetryableError(badRequest), false);
-
-  const networkError = new Error('socket hang up');
-  assert.equal(isRetryableError(networkError), true);
-});
-
-test('formatFailureGuidance includes versioned URL and release page', () => {
-  const guidance = formatFailureGuidance('1.2.3', 'gwt-linux-x86_64');
-  assert.equal(
-    guidance.versionedUrl,
-    'https://github.com/akiojin/gwt/releases/download/v1.2.3/gwt-linux-x86_64',
-  );
-  assert.equal(guidance.releasePageUrl, 'https://github.com/akiojin/gwt/releases');
-  assert.equal(guidance.buildCommand, 'cargo build --release');
-});
-
-test('getVersionedDownloadUrl uses package.json version', () => {
-  const version = getPackageVersion();
-  const result = getVersionedDownloadUrl('gwt-linux-x86_64');
-  assert.equal(result.version, version);
-  assert.equal(
-    result.url,
-    `https://github.com/akiojin/gwt/releases/download/v${version}/gwt-linux-x86_64`,
-  );
-});