amberjs 1.17.0

JavaScript/TypeScript runtime built with Rust and V8
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// Clipboard API implementation
// Provides clipboard read/write capability for AI workloads
// that need to copy/paste content
//
// v0.3.342: Initial implementation of Clipboard API

use anyhow::Result;
use rusty_v8 as v8;

/// Set up Clipboard API in the V8 context
pub fn setup_clipboard_api(
    scope: &mut v8::ContextScope<v8::HandleScope>,
    context: &v8::Local<v8::Context>,
) -> Result<()> {
    let global = context.global(scope);

    // Create navigator property if it doesn't exist
    let navigator_key = v8::String::new(scope, "navigator").unwrap();
    let navigator_val = global.get(scope, navigator_key.into());

    // Create or get navigator object
    let navigator_obj = if let Some(val) = navigator_val {
        if val.is_object() {
            v8::Local::<v8::Object>::try_from(val).unwrap()
        } else {
            let new_navigator: v8::Local<v8::Object> = v8::Object::new(scope);
            global.set(scope, navigator_key.into(), new_navigator.into());
            new_navigator
        }
    } else {
        let new_navigator: v8::Local<v8::Object> = v8::Object::new(scope);
        global.set(scope, navigator_key.into(), new_navigator.into());
        new_navigator
    };

    // Create clipboard object
    let clipboard_obj: v8::Local<v8::Object> = v8::Object::new(scope);

    // Create writeText method template
    let write_text_template = v8::FunctionTemplate::new(scope, write_text_callback);
    let write_text_fn = write_text_template.get_function(scope).unwrap();
    let write_text_key = v8::String::new(scope, "writeText").unwrap();
    clipboard_obj.set(scope, write_text_key.into(), write_text_fn.into());

    // Create readText method template
    let read_text_template = v8::FunctionTemplate::new(scope, read_text_callback);
    let read_text_fn = read_text_template.get_function(scope).unwrap();
    let read_text_key = v8::String::new(scope, "readText").unwrap();
    clipboard_obj.set(scope, read_text_key.into(), read_text_fn.into());

    // Create read method template (modern API)
    let read_template = v8::FunctionTemplate::new(scope, read_callback);
    let read_fn = read_template.get_function(scope).unwrap();
    let read_key = v8::String::new(scope, "read").unwrap();
    clipboard_obj.set(scope, read_key.into(), read_fn.into());

    // Create write method template (modern API)
    let write_template = v8::FunctionTemplate::new(scope, write_callback);
    let write_fn = write_template.get_function(scope).unwrap();
    let write_key = v8::String::new(scope, "write").unwrap();
    clipboard_obj.set(scope, write_key.into(), write_fn.into());

    // Set clipboard object on navigator
    let clipboard_key = v8::String::new(scope, "clipboard").unwrap();
    navigator_obj.set(scope, clipboard_key.into(), clipboard_obj.into());

    Ok(())
}

/// writeText callback - writes text to clipboard
fn write_text_callback(
    scope: &mut v8::PinScope,
    _args: v8::FunctionCallbackArguments,
    mut retval: v8::ReturnValue,
) {
    let resolver = v8::PromiseResolver::new(scope).unwrap();
    let promise = resolver.get_promise(scope);
    retval.set(promise.into());

    let message = v8::String::new(scope, "Clipboard API is not supported yet").unwrap();
    let error = v8::Exception::error(scope, message);
    resolver.reject(scope, error).unwrap();
}

/// readText callback - reads text from clipboard
fn read_text_callback(
    scope: &mut v8::PinScope,
    _args: v8::FunctionCallbackArguments,
    mut retval: v8::ReturnValue,
) {
    let resolver = v8::PromiseResolver::new(scope).unwrap();
    let promise = resolver.get_promise(scope);
    retval.set(promise.into());

    let message = v8::String::new(scope, "Clipboard API is not supported yet").unwrap();
    let error = v8::Exception::error(scope, message);
    resolver.reject(scope, error).unwrap();
}

/// read callback - modern read API (returns ClipboardItem array)
fn read_callback(
    scope: &mut v8::PinScope,
    _args: v8::FunctionCallbackArguments,
    mut retval: v8::ReturnValue,
) {
    let resolver = v8::PromiseResolver::new(scope).unwrap();
    let promise = resolver.get_promise(scope);
    retval.set(promise.into());

    let message = v8::String::new(scope, "Clipboard API is not supported yet").unwrap();
    let error = v8::Exception::error(scope, message);
    resolver.reject(scope, error).unwrap();
}

/// write callback - modern write API (takes ClipboardItem array)
fn write_callback(
    scope: &mut v8::PinScope,
    _args: v8::FunctionCallbackArguments,
    mut retval: v8::ReturnValue,
) {
    let resolver = v8::PromiseResolver::new(scope).unwrap();
    let promise = resolver.get_promise(scope);
    retval.set(promise.into());

    let message = v8::String::new(scope, "Clipboard API is not supported yet").unwrap();
    let error = v8::Exception::error(scope, message);
    resolver.reject(scope, error).unwrap();
}