llrt_core 0.8.1-beta

LLRT Core for rquickjs
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

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0
use rquickjs::{
    module::{Declarations, Exports, ModuleDef},
    prelude::Func,
    Ctx, Result, Value,
};

use crate::libs::{
    encoding::{bytes_from_hex, bytes_to_hex_string},
    utils::{
        bytes::{bytes_to_typed_array, ObjectBytes},
        module::{export_default, ModuleInfo},
        result::ResultExt,
    },
};

pub struct LlrtHexModule;

impl LlrtHexModule {
    pub fn encode<'js>(ctx: Ctx<'js>, bytes: ObjectBytes<'js>) -> Result<String> {
        Ok(bytes_to_hex_string(bytes.as_bytes(&ctx)?))
    }

    pub fn decode(ctx: Ctx, encoded: String) -> Result<Value> {
        let bytes = bytes_from_hex(encoded.as_bytes())
            .or_throw_msg(&ctx, "Cannot decode unrecognized sequence")?;

        bytes_to_typed_array(ctx, &bytes)
    }
}

impl ModuleDef for LlrtHexModule {
    fn declare(declare: &Declarations) -> Result<()> {
        declare.declare(stringify!(encode))?;
        declare.declare(stringify!(decode))?;
        declare.declare("default")?;
        Ok(())
    }

    fn evaluate<'js>(ctx: &Ctx<'js>, exports: &Exports<'js>) -> Result<()> {
        export_default(ctx, exports, |default| {
            default.set(stringify!(encode), Func::from(Self::encode))?;
            default.set(stringify!(decode), Func::from(Self::decode))?;
            Ok(())
        })?;

        Ok(())
    }
}

impl From<LlrtHexModule> for ModuleInfo<LlrtHexModule> {
    fn from(val: LlrtHexModule) -> Self {
        ModuleInfo {
            name: "llrt:hex",
            module: val,
        }
    }
}