otter-pm 0.1.1

NPM-compatible package manager for Otter
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
140
141
142
143
144
145
146
147
148

//! Bundled TypeScript type definitions management
//!
//! This module handles copying Otter's bundled type definitions to node_modules/@types
//! so that editors can provide IntelliSense and go-to-definition support.

use std::fs;
use std::path::Path;

/// Otter global API types (console, timers, fetch, etc.)
const OTTER_TYPES: &str = include_str!("types/otter.d.ts");

/// Node.js Buffer types
const NODE_BUFFER_TYPES: &str = include_str!("types/node/buffer.d.ts");

/// Node.js fs types
const NODE_FS_TYPES: &str = include_str!("types/node/fs.d.ts");

/// Node.js path types
const NODE_PATH_TYPES: &str = include_str!("types/node/path.d.ts");

/// Node.js test types
const NODE_TEST_TYPES: &str = include_str!("types/node/test.d.ts");

/// Install bundled type definitions to node_modules
pub fn install_bundled_types(node_modules: &Path) -> Result<(), TypesError> {
    // Install @types/otter for global APIs
    install_otter_types(node_modules)?;

    // Install @types/node for Node.js compatibility APIs
    install_node_types(node_modules)?;

    Ok(())
}

/// Install @types/otter (global Otter APIs)
fn install_otter_types(node_modules: &Path) -> Result<(), TypesError> {
    let types_dir = node_modules.join("@types").join("otter");
    fs::create_dir_all(&types_dir).map_err(|e| TypesError::Io(e.to_string()))?;

    // Write index.d.ts
    fs::write(types_dir.join("index.d.ts"), OTTER_TYPES)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    // Write package.json
    let package_json = r#"{
  "name": "@types/otter",
  "version": "0.1.0",
  "description": "TypeScript definitions for Otter runtime",
  "types": "index.d.ts",
  "license": "MIT"
}"#;
    fs::write(types_dir.join("package.json"), package_json)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    Ok(())
}

/// Install @types/node (Node.js compatibility APIs)
fn install_node_types(node_modules: &Path) -> Result<(), TypesError> {
    let types_dir = node_modules.join("@types").join("node");
    fs::create_dir_all(&types_dir).map_err(|e| TypesError::Io(e.to_string()))?;

    // Write individual module types
    fs::write(types_dir.join("buffer.d.ts"), NODE_BUFFER_TYPES)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    fs::write(types_dir.join("fs.d.ts"), NODE_FS_TYPES)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    fs::write(types_dir.join("path.d.ts"), NODE_PATH_TYPES)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    fs::write(types_dir.join("test.d.ts"), NODE_TEST_TYPES)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    // Write index.d.ts that re-exports all modules
    let index_dts = r#"/// <reference path="buffer.d.ts" />
/// <reference path="fs.d.ts" />
/// <reference path="path.d.ts" />
/// <reference path="test.d.ts" />

// Re-export modules for direct imports
export * from "node:buffer";
export * from "node:fs";
export * from "node:path";
export * from "node:test";
"#;
    fs::write(types_dir.join("index.d.ts"), index_dts)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    // Write package.json
    let package_json = r#"{
  "name": "@types/node",
  "version": "0.1.0",
  "description": "TypeScript definitions for Otter's Node.js compatibility layer",
  "types": "index.d.ts",
  "license": "MIT"
}"#;
    fs::write(types_dir.join("package.json"), package_json)
        .map_err(|e| TypesError::Io(e.to_string()))?;

    Ok(())
}

#[derive(Debug, thiserror::Error)]
pub enum TypesError {
    #[error("IO error: {0}")]
    Io(String),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_bundled_types_not_empty() {
        assert!(!OTTER_TYPES.is_empty());
        assert!(!NODE_BUFFER_TYPES.is_empty());
        assert!(!NODE_FS_TYPES.is_empty());
        assert!(!NODE_PATH_TYPES.is_empty());
    }

    #[test]
    fn test_install_bundled_types() {
        let temp_dir = std::env::temp_dir().join("otter-types-test");
        let node_modules = temp_dir.join("node_modules");

        // Clean up first
        let _ = fs::remove_dir_all(&temp_dir);
        fs::create_dir_all(&node_modules).unwrap();

        // Install types
        install_bundled_types(&node_modules).unwrap();

        // Verify @types/otter
        assert!(node_modules.join("@types/otter/index.d.ts").exists());
        assert!(node_modules.join("@types/otter/package.json").exists());

        // Verify @types/node
        assert!(node_modules.join("@types/node/index.d.ts").exists());
        assert!(node_modules.join("@types/node/fs.d.ts").exists());
        assert!(node_modules.join("@types/node/buffer.d.ts").exists());
        assert!(node_modules.join("@types/node/path.d.ts").exists());

        // Clean up
        let _ = fs::remove_dir_all(&temp_dir);
    }
}