[all] Move common types for input event and terminal output from term…

…inal_async into core

core/Cargo.toml

@@ -85,6 +85,10 @@ bincode = { version = "1.3.3" }
 # on top of `sled` which currently does not support access across multiple processes.
 kv = { version = "0.24.0", features = ["json-value", "bincode-value"] }
 
+# Async stream for DI and testing.
+futures-core = "0.3.30"
+async-stream = "0.3.5"
+
 [dev-dependencies]
 # for assert_eq! macro
 pretty_assertions = "1.4.0"

core/src/common/mod.rs

@@ -19,10 +19,12 @@
 pub mod common_enums;
 pub mod common_math;
 pub mod common_result_and_error;
+pub mod type_aliases;
 pub mod miette_setup_global_report_handler;
 
 // Re-export.
 pub use common_enums::*;
 pub use common_math::*;
 pub use common_result_and_error::*;
+pub use type_aliases::*;
 pub use miette_setup_global_report_handler::*;

core/src/common/type_aliases.rs

@@ -0,0 +1,35 @@
+/*
+ *   Copyright (c) 2024 R3BL LLC
+ *   All rights reserved.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+use std::{io::Error, pin::Pin, sync::Arc};
+
+use crossterm::event::Event;
+use futures_core::Stream;
+
+/// Disambiguate the type of `StdMutex` from stdlib and tokio to avoid conflicts.
+pub type StdMutex<T> = std::sync::Mutex<T>;
+
+/// Type alias for a `Send`-able output device (raw terminal, SharedWriter, etc).
+pub type SendRawTerminal = dyn std::io::Write + Send;
+/// Type alias for a `Send`-able raw terminal wrapped in an `Arc<StdMutex>`.
+pub type SafeRawTerminal = Arc<StdMutex<SendRawTerminal>>;
+
+/// Type alias for crossterm streaming (input) event result.
+pub type CrosstermEventResult = Result<Event, Error>;
+/// Type alias for a pinned stream that is async safe. `T` is usually
+/// [CrosstermEventResult].
+pub type PinnedInputStream<T> = Pin<Box<dyn Stream<Item = T>>>;

terminal_async/examples/spinner.rs

@@ -19,11 +19,11 @@ use std::{io::{stderr, Write},
           sync::Arc,
           time::Duration};
 
+use r3bl_core::StdMutex;
 use r3bl_terminal_async::{Spinner,
                           SpinnerColor,
                           SpinnerStyle,
                           SpinnerTemplate,
-                          StdMutex,
                           TerminalAsync,
                           ARTIFICIAL_UI_DELAY,
                           DELAY_MS,

terminal_async/examples/terminal_async.rs

@@ -15,21 +15,25 @@
  *   limitations under the License.
  */
 
-use std::{io::{stderr, Write},
+use std::{fs,
+          io::{stderr, Write},
           ops::ControlFlow,
+          path::{self, PathBuf},
+          str::FromStr as _,
           sync::Arc,
           time::Duration};
 
 use crossterm::style::Stylize as _;
-use miette::IntoDiagnostic as _;
+use miette::{miette, IntoDiagnostic as _};
 use r3bl_core::{tracing_logging::tracing_config::TracingConfig,
                 DisplayPreference,
-                SharedWriter};
+                SendRawTerminal,
+                SharedWriter,
+                StdMutex};
 use r3bl_terminal_async::{Readline,
                           ReadlineEvent,
                           Spinner,
                           SpinnerStyle,
-                          StdMutex,
                           TerminalAsync};
 use strum::IntoEnumIterator;
 use strum_macros::{Display, EnumIter, EnumString};
@@ -252,8 +256,6 @@ mod task_2 {
 }
 
 mod process_input_event {
-    use std::str::FromStr;
-
     use super::*;
 
     pub fn process(
@@ -426,12 +428,6 @@ mod long_running_task {
 }
 
 pub mod file_walker {
-    use std::{fs,
-              path::{self, PathBuf}};
-
-    use miette::miette;
-    use r3bl_terminal_async::SendRawTerminal;
-
     use super::*;
 
     pub const FOLDER_DELIM: &str = std::path::MAIN_SEPARATOR_STR;

terminal_async/src/lib.rs

@@ -465,17 +465,12 @@ pub use readline_impl::*;
 pub use spinner_impl::*;
 
 // External crates.
-use std::{collections::VecDeque, io::Error, pin::Pin, sync::Arc};
-use crossterm::event::Event;
-use futures_core::Stream;
+use std::{collections::VecDeque, sync::Arc};
 
-// Type aliases.
-
-pub type StdMutex<T> = std::sync::Mutex<T>;
-
-pub type SendRawTerminal = dyn std::io::Write + Send;
-pub type SafeRawTerminal = Arc<StdMutex<SendRawTerminal>>;
+// r3bl-open-core crates.
+use r3bl_core::{StdMutex, SendRawTerminal, SafeRawTerminal};
 
+// Type aliases.
 pub type SafeLineState = Arc<StdMutex<LineState>>;
 pub type SafeHistory = Arc<StdMutex<History>>;
 
@@ -484,9 +479,6 @@ pub type SafeBool = Arc<StdMutex<bool>>;
 pub type PauseBuffer = VecDeque<r3bl_core::Text>;
 pub type SafePauseBuffer = Arc<StdMutex<PauseBuffer>>;
 
-pub type CrosstermEventResult = Result<Event, Error>;
-pub type PinnedInputStream<T> = Pin<Box<dyn Stream<Item = T>>>;
-
 // Constants.
 pub const CHANNEL_CAPACITY: usize = 1_000;
 pub const HISTORY_SIZE_MAX: usize = 1_000;

terminal_async/src/public_api/terminal_async.rs

@@ -24,15 +24,18 @@ use crossterm::{cursor::MoveToColumn,
                 terminal::{Clear, ClearType}};
 use futures_util::FutureExt as _;
 use miette::IntoDiagnostic as _;
-use r3bl_core::{LineStateControlSignal, SharedWriter};
+use r3bl_core::{CrosstermEventResult,
+                LineStateControlSignal,
+                PinnedInputStream,
+                SharedWriter};
 use r3bl_tuify::{is_fully_uninteractive_terminal,
                  is_stdin_piped,
                  is_stdout_piped,
                  StdinIsPipedResult,
                  StdoutIsPipedResult,
                  TTYResult};
 
-use crate::{CrosstermEventResult, PinnedInputStream, Readline, ReadlineEvent, StdMutex};
+use crate::{Readline, ReadlineEvent, StdMutex};
 
 pub struct TerminalAsync {
     pub readline: Readline,

terminal_async/src/readline_impl/readline.rs

@@ -21,16 +21,17 @@ use std::{io::{self, Write},
 use crossterm::{terminal::{self, disable_raw_mode, Clear},
                 QueueableCommand};
 use futures_util::StreamExt;
-use r3bl_core::{LineStateControlSignal, SharedWriter};
+use r3bl_core::{CrosstermEventResult,
+                LineStateControlSignal,
+                PinnedInputStream,
+                SharedWriter};
 use thiserror::Error;
 use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};
 
-use crate::{CrosstermEventResult,
-            History,
+use crate::{History,
             LineState,
             LineStateLiveness,
             PauseBuffer,
-            PinnedInputStream,
             SafeHistory,
             SafeLineState,
             SafePauseBuffer,