@perspective-dev/viewer 4.0.0

package/src/rust/exprtk/tokenize/comment.rs

@@ -0,0 +1,21 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use nom::IResult;
+use nom::bytes::complete::{is_not, tag};
+use nom::combinator::recognize;
+use nom::multi::many0;
+use nom::sequence::preceded;
+
+pub fn parse_comment(input: &str) -> IResult<&'_ str, &'_ str> {
+    recognize(preceded(tag("//"), many0(is_not("\r\n"))))(input)
+}

package/src/rust/exprtk/tokenize/number.rs

@@ -0,0 +1,44 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use nom::IResult;
+use nom::branch::alt;
+use nom::character::complete::{char, one_of};
+use nom::combinator::{opt, recognize};
+use nom::multi::{many0, many1};
+use nom::sequence::{preceded, terminated, tuple};
+
+fn decimal(input: &str) -> IResult<&str, &str> {
+    recognize(many1(terminated(one_of("0123456789"), many0(char('_')))))(input)
+}
+
+pub fn parse_number_literal(input: &str) -> IResult<&str, &str> {
+    alt((
+        // Case one: .42
+        recognize(tuple((
+            char('.'),
+            decimal,
+            opt(tuple((one_of("eE"), opt(one_of("+-")), decimal))),
+        ))),
+        // Case two: 42e42 and 42.42e42
+        recognize(tuple((
+            decimal,
+            opt(preceded(char('.'), decimal)),
+            one_of("eE"),
+            opt(one_of("+-")),
+            decimal,
+        ))),
+        // Case three: 42. and 42.42
+        recognize(tuple((decimal, char('.'), opt(decimal)))),
+        decimal,
+    ))(input)
+}

package/src/rust/exprtk/tokenize/string.rs

@@ -0,0 +1,98 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use nom::IResult;
+use nom::branch::alt;
+use nom::bytes::complete::{is_not, take_while_m_n};
+use nom::character::complete::{char, multispace1};
+use nom::combinator::{map, map_opt, map_res, value, verify};
+use nom::multi::fold_many0;
+use nom::sequence::{delimited, preceded};
+
+fn parse_unicode(input: &str) -> IResult<&str, char> {
+    let parse_hex = take_while_m_n(1, 6, |c: char| c.is_ascii_hexdigit());
+    let parse_delimited_hex = preceded(char('u'), delimited(char('{'), parse_hex, char('}')));
+    let parse_u32 = map_res(parse_delimited_hex, move |hex| u32::from_str_radix(hex, 16));
+    map_opt(parse_u32, std::char::from_u32)(input)
+}
+
+fn parse_escaped_char(input: &str) -> IResult<&str, char> {
+    preceded(
+        char('\\'),
+        alt((
+            parse_unicode,
+            value('\n', char('n')),
+            value('\r', char('r')),
+            value('\t', char('t')),
+            value('\u{08}', char('b')),
+            value('\u{0C}', char('f')),
+            value('\\', char('\\')),
+            value('/', char('/')),
+            value('"', char('"')),
+            value('\'', char('\'')),
+        )),
+    )(input)
+}
+
+fn parse_literal(sep: char, input: &str) -> IResult<&str, &str> {
+    let not_quote_slash = if sep == '\'' {
+        is_not("\'\\")
+    } else {
+        is_not("\"\\")
+    };
+
+    verify(not_quote_slash, |s: &str| !s.is_empty())(input)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum StringFragment {
+    Literal(usize),
+    EscapedChar,
+    EscapedWS,
+}
+
+impl StringFragment {
+    const fn len(&self) -> usize {
+        match self {
+            Self::Literal(s) => *s,
+            Self::EscapedChar => 2,
+            Self::EscapedWS => 0,
+        }
+    }
+}
+
+fn parse_fragment(sep: char, input: &str) -> IResult<&str, StringFragment> {
+    alt((
+        map(
+            |x| parse_literal(sep, x),
+            |x| StringFragment::Literal(x.len()),
+        ),
+        map(parse_escaped_char, |_| StringFragment::EscapedChar),
+        value(StringFragment::EscapedWS, preceded(char('\\'), multispace1)),
+    ))(input)
+}
+
+pub fn parse_string_literal(
+    sep: char,
+) -> impl for<'a> Fn(&'a str) -> IResult<&'a str, Vec<&'a str>> {
+    move |input| {
+        let build_string = fold_many0(
+            |x| parse_fragment(sep, x),
+            || 2,
+            |len, frag| frag.len() + len,
+        );
+
+        let offset = delimited(char(sep), build_string, char(sep));
+        let (input, lit) = map(offset, |x| &input[..x])(input)?;
+        Ok((input, lit.split('\n').collect()))
+    }
+}

package/src/rust/exprtk/tokenize/symbol.rs

@@ -0,0 +1,26 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use nom::IResult;
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::character::complete::{alpha1, alphanumeric1};
+use nom::combinator::recognize;
+use nom::multi::many0_count;
+use nom::sequence::pair;
+
+pub fn parse_symbol_literal(input: &str) -> IResult<&'_ str, &'_ str> {
+    recognize(pair(
+        alt((alpha1, tag("_"))),
+        many0_count(alt((alphanumeric1, tag("_")))),
+    ))(input)
+}

package/src/rust/exprtk/tokenize.rs

@@ -0,0 +1,190 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+mod comment;
+mod number;
+mod string;
+mod symbol;
+
+use nom::IResult;
+use nom::branch::alt;
+use nom::bytes::complete::{is_a, is_not};
+use nom::character::complete::{line_ending, space1};
+use nom::combinator::map;
+use nom::multi::many0;
+use yew::prelude::*;
+
+use self::comment::*;
+use self::number::*;
+use self::string::*;
+use self::symbol::*;
+
+/// Syntax-highlightable ExprTK tokens.
+///
+///  We had the option of implemnting this alternatively as `pub struct
+/// Token(TokenType, &'a str);`, but I felt this was less ergonomic for the
+/// frequent pattern matching necessary when handling enum tokens.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Token<'a> {
+    Comment(&'a str),
+    Whitespace(&'a str),
+    Break(&'a str),
+    Symbol(&'a str),
+    Literal(&'a str),
+    Operator(&'a str),
+    Unknown(&'a str),
+    Column(&'a str),
+}
+
+use Token::*;
+
+impl ToHtml for Token<'_> {
+    fn to_html(&self) -> Html {
+        html! {
+            if matches!(self, Break(_)) { <br /> } else {
+                <span class={self.class_name()}>{ self.content() }</span>
+            }
+        }
+    }
+}
+
+impl<'a> Token<'a> {
+    const fn class_name(&self) -> &'static str {
+        match self {
+            Comment(_) => "comment",
+            Whitespace(_) => "whitespace",
+            Symbol(_) => "symbol",
+            Operator(_) => "operator",
+            Unknown(_) => "unknown",
+            Break(_) => "break",
+            Literal(_) => "literal",
+            Column(_) => "column",
+        }
+    }
+
+    /// Note the use of the lifetime `'a` - this function does not work
+    /// correctly when it's signature is specified `-> &'_ str` instead, as
+    /// `self` and the `str` may have different lifetimes.
+    pub const fn content(&self) -> &'a str {
+        match self {
+            Comment(x) => x,
+            Whitespace(x) => x,
+            Symbol(x) => x,
+            Operator(x) => x,
+            Unknown(x) => x,
+            Break(x) => x,
+            Literal(x) => x,
+            Column(x) => x,
+        }
+    }
+}
+
+#[allow(clippy::redundant_closure)]
+fn parse_multiline_string<'a>(
+    sep: char,
+    lit: impl Fn(&'a str) -> Token<'a>,
+) -> impl FnMut(&'a str) -> IResult<&'a str, Vec<Token<'a>>> {
+    map(parse_string_literal(sep), move |x| {
+        x.into_iter()
+            .map(|x| lit(x))
+            .intersperse(Token::Break("\n"))
+            .collect()
+    })
+}
+
+/// Parse a string representing an ExprTK Expression Column into `Token`s. A
+/// token list is sufficient for syntax-highlighting purposes, faster than a
+/// full parser and much easier to write a renderer for.
+pub fn tokenize(input: &str) -> Vec<Token<'_>> {
+    let comment = map(parse_comment, |x| vec![Token::Comment(x)]);
+    let string = parse_multiline_string('\'', Token::Literal);
+    let column = parse_multiline_string('"', Token::Column);
+    let symbol = map(parse_symbol_literal, |x| vec![Token::Symbol(x)]);
+    let number = map(parse_number_literal, |x| vec![Token::Literal(x)]);
+    let whitespace = map(space1, |x| vec![Token::Whitespace(x)]);
+    let linebreak = map(line_ending, |x| vec![Token::Break(x)]);
+    let ops = map(is_a("+-/*^%&|=:;,.(){}[]<>\\"), |x| {
+        vec![Token::Operator(x)]
+    });
+    let unknown = map(is_not(" \t\n\r"), |x| vec![Token::Unknown(x)]);
+    let token = alt((
+        comment, string, column, symbol, number, whitespace, linebreak, ops, unknown,
+    ));
+
+    let mut expr = map(many0(token), |x| x.into_iter().flatten().collect());
+    let (rest, mut tokens) = expr(input).unwrap_or_else(|_| (input, vec![]));
+    if !rest.is_empty() {
+        tracing::warn!(
+            "Parser terminated at position {}: {}",
+            input.len() - rest.len(),
+            input
+        );
+
+        tokens.push(Token::Unknown(rest))
+    }
+
+    tokens
+}
+
+#[cfg(test)]
+mod tests {
+    use wasm_bindgen_test::*;
+
+    use super::*;
+
+    #[wasm_bindgen_test]
+    fn test_simple() {
+        let s = "123 abc 'hello' \"Sales\"";
+        assert_eq!(tokenize(s), vec![
+            Literal("123"),
+            Whitespace(" "),
+            Symbol("abc"),
+            Whitespace(" "),
+            Column("'hello'"),
+            Whitespace(" "),
+            Literal("\"Sales\"")
+        ]);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_complex_string() {
+        let s = "'this is 'a \"test of\" strings";
+        assert_eq!(tokenize(s), vec![
+            Column("'this is '"),
+            Symbol("a"),
+            Whitespace(" "),
+            Literal("\"test of\""),
+            Whitespace(" "),
+            Symbol("strings"),
+        ]);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_comment_newline() {
+        let s = "// Title\n1 + 2";
+        assert_eq!(tokenize(s), vec![
+            Comment("// Title"),
+            Break("\n"),
+            Literal("1"),
+            Whitespace(" "),
+            Operator("+"),
+            Whitespace(" "),
+            Literal("2"),
+        ]);
+    }
+
+    #[wasm_bindgen_test]
+    fn test_escape_strings() {
+        let s = "'test\\/'";
+        assert_eq!(tokenize(s), vec![Literal("'test\\/'"),]);
+    }
+}

package/src/rust/js/clipboard.rs

@@ -0,0 +1,77 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::cell::RefCell;
+use std::future::Future;
+use std::rc::Rc;
+
+use perspective_client::clone;
+use perspective_js::utils::global;
+use wasm_bindgen::JsCast;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::JsFuture;
+
+use super::mimetype::*;
+use crate::js::clipboard_item::*;
+use crate::*;
+
+pub async fn paste_from_clipboard() -> Option<String> {
+    JsFuture::from(global::clipboard().read_text())
+        .await
+        .ok()
+        .and_then(|x| x.as_string())
+}
+
+/// Copy a `JsPerspectiveView` to the clipboard as a CSV.
+pub fn copy_to_clipboard(
+    view: impl Future<Output = Result<web_sys::Blob, ApiError>>,
+    mimetype: MimeType,
+) -> impl Future<Output = ApiResult<()>> {
+    let js_ref: Rc<RefCell<Option<web_sys::Blob>>> = Rc::new(RefCell::new(None));
+    poll(0, mimetype, js_ref.clone()).unwrap();
+    async move {
+        let js_val = view.await?;
+        *js_ref.borrow_mut() = Some(js_val);
+        Ok(())
+    }
+}
+
+/// This method must be called from an event handler, subject to the browser's
+/// restrictions on clipboard access.  See
+/// [ws](https://www.w3.org/TR/clipboard-apis/#allow-read-clipboard).
+fn poll(
+    count: u32,
+    mimetype: MimeType,
+    js_ref: Rc<RefCell<Option<web_sys::Blob>>>,
+) -> ApiResult<()> {
+    if let Some(js_val) = js_ref.borrow().as_ref() {
+        let options = js_sys::Object::new();
+        js_sys::Reflect::set(&options, &mimetype.into(), js_val)?;
+        let item = ClipboardItem::new(&options);
+        let items = std::iter::once(item).collect::<js_sys::Array>();
+        let _promise = global::clipboard().write(&items.into());
+    } else {
+        clone!(js_ref);
+        if count == 200 {
+            tracing::warn!("Clipboard handler surpassed 10s");
+        }
+
+        let f: js_sys::Function =
+            Closure::once(Box::new(move || poll(count + 1, mimetype, js_ref)))
+                .into_js_value()
+                .unchecked_into();
+
+        global::window().set_timeout_with_callback_and_timeout_and_arguments_0(&f, 50)?;
+    }
+
+    Ok(())
+}

package/src/rust/js/clipboard_item.rs

@@ -0,0 +1,21 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(inline_js = "export const ClipboardItem = window.ClipboardItem")]
+extern "C" {
+    pub type ClipboardItem;
+
+    #[wasm_bindgen(constructor, js_class = "ClipboardItem")]
+    pub fn new(files: &js_sys::Object) -> ClipboardItem;
+}

package/src/rust/js/intersection_observer.rs

@@ -0,0 +1,32 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(inline_js = "export const IntersectionObserver = window.IntersectionObserver")]
+extern "C" {
+    pub type IntersectionObserver;
+
+    #[wasm_bindgen(constructor, js_class = "IntersectionObserver")]
+    pub fn new(callback: &js_sys::Function) -> IntersectionObserver;
+
+    #[wasm_bindgen(method)]
+    pub fn observe(this: &IntersectionObserver, elem: &web_sys::HtmlElement);
+
+    #[wasm_bindgen(method)]
+    pub fn unobserve(this: &IntersectionObserver, elem: &web_sys::HtmlElement);
+
+    pub type IntersectionObserverEntry;
+
+    #[wasm_bindgen(method, getter, js_name = "isIntersecting")]
+    pub fn is_intersecting(this: &IntersectionObserverEntry) -> bool;
+}

package/src/rust/js/mimetype.rs

@@ -0,0 +1,42 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+use std::fmt::Display;
+
+use wasm_bindgen::prelude::*;
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub enum MimeType {
+    TextPlain,
+    ImagePng,
+}
+
+impl Default for MimeType {
+    fn default() -> Self {
+        Self::TextPlain
+    }
+}
+
+impl From<MimeType> for JsValue {
+    fn from(x: MimeType) -> Self {
+        Self::from(format!("{x}"))
+    }
+}
+
+impl Display for MimeType {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
+        fmt.write_str(match self {
+            Self::TextPlain => "text/plain",
+            Self::ImagePng => "image/png",
+        })
+    }
+}

package/src/rust/js/mod.rs

@@ -0,0 +1,29 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! - State objects
+//! - Use refs
+//! - Relative imports should not fork
+
+mod clipboard;
+pub mod clipboard_item;
+mod intersection_observer;
+mod mimetype;
+pub mod plugin;
+pub mod resize_observer;
+mod testing;
+
+pub use self::clipboard::*;
+pub use self::intersection_observer::*;
+pub use self::mimetype::*;
+pub use self::plugin::*;
+pub use self::resize_observer::*;