oveo 0.4.0

Javascript optimizer
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
129
130
131
132
133
134
135
136
137
138
139

use std::path::PathBuf;

use oxc_allocator::Allocator;
use oxc_codegen::{Codegen, CodegenOptions};
use oxc_parser::Parser;
use oxc_semantic::SemanticBuilder;
use oxc_span::SourceType;

use crate::{externs::ExternMap, property_names::LocalPropertyMap};
pub use globals::GlobalCategory;
pub use property_names::PropertyMap;

pub mod annotation;
pub(crate) mod chunk;
pub(crate) mod context;
pub mod externs;
pub(crate) mod globals;
pub(crate) mod module;
pub(crate) mod property_names;
pub(crate) mod statements;

#[derive(Default, Debug)]
pub struct OptimizerOptions {
    pub hoist: bool,
    pub dedupe: bool,
    pub globals: GlobalsOptions,
    pub rename_properties: bool,
    pub url: Option<String>,
}

#[derive(Default, Debug)]
pub struct GlobalsOptions {
    pub include: GlobalCategory,
    pub hoist: bool,
    pub singletons: bool,
}

pub struct OptimizerOutput {
    pub code: String,
    pub map: String,
}

#[derive(Debug, thiserror::Error)]
pub enum OptimizerError {
    #[error("Invalid module type: {0}")]
    ModuleType(String),
    #[error("Unable to parse javascript file: {0}")]
    SyntaxError(String),
    #[error("Unable to parse javascript file: {0}")]
    SemanticError(String),
    #[error("Unable to optimize javascript file: {0}")]
    OptimizerError(String),
    #[error("Unable to parse property map: {0}")]
    PropertyMapParseError(String),
}

pub fn optimize_module(
    source_text: &str,
    module_type: &str,
    options: &OptimizerOptions,
    externs: &ExternMap,
) -> Result<OptimizerOutput, OptimizerError> {
    let allocator = Allocator::default();
    let source_type = match module_type {
        "js" => SourceType::mjs(),
        "jsx" => SourceType::jsx(),
        "ts" => SourceType::ts(),
        "tsx" => SourceType::tsx(),
        _ => return Err(OptimizerError::ModuleType(module_type.to_string())),
    };
    let ret = Parser::new(&allocator, source_text, source_type).parse();
    if let Some(err) = ret.errors.first() {
        return Err(OptimizerError::SyntaxError(err.to_string()));
    }

    let mut program = ret.program;

    let ret = SemanticBuilder::new().with_excess_capacity(0.1).build(&program);
    if let Some(err) = ret.errors.first() {
        return Err(OptimizerError::SemanticError(err.to_string()));
    }

    let scoping = ret.semantic.into_scoping();
    module::optimize_module(&mut program, options, externs, &allocator, scoping);

    let result = Codegen::new()
        .with_options(CodegenOptions {
            source_map_path: Some(PathBuf::new()),
            ..Default::default()
        })
        .build(&program);

    Ok(OptimizerOutput {
        code: result.code,
        map: result.map.map_or_else(String::default, |v| v.to_json_string()),
    })
}

pub fn optimize_chunk(
    source_text: &str,
    options: &OptimizerOptions,
    property_map: &PropertyMap,
) -> Result<OptimizerOutput, OptimizerError> {
    let allocator = Allocator::default();
    let source_type = SourceType::mjs();
    let ret = Parser::new(&allocator, source_text, source_type).parse();
    if let Some(err) = ret.errors.first() {
        return Err(OptimizerError::SyntaxError(err.to_string()));
    }

    let mut program = ret.program;

    let ret = SemanticBuilder::new().with_excess_capacity(0.1).build(&program);
    if let Some(err) = ret.errors.first() {
        return Err(OptimizerError::SemanticError(err.to_string()));
    }

    let scoping = ret.semantic.into_scoping();

    chunk::optimize_chunk(
        &mut program,
        options,
        LocalPropertyMap::new(property_map),
        &allocator,
        scoping,
    );

    let result = Codegen::new()
        .with_options(CodegenOptions {
            source_map_path: Some(PathBuf::new()),
            ..Default::default()
        })
        .build(&program);

    Ok(OptimizerOutput {
        code: result.code,
        map: result.map.map_or_else(String::default, |v| v.to_json_string()),
    })
}