miga 0.1.3

Bedrock Addon Utility Package Manager
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

use crate::registry::manifest::{LockFile, ProjectManifest};
use crate::utils::fs;
use anyhow::{Context, Result};
use serde_json::{json, Map, Value};

/// Regenerates `tsconfig.json` with path mappings derived from the current project manifest
/// and lock file, covering both npm external types and miga registry modules.
///
/// For registry modules, the version from `ProjectManifest.modules` is used to
/// select the correct versioned directory under `.miga_modules/<name>/v<version>/`.
pub fn update(project: &ProjectManifest, lock: &LockFile) -> Result<()> {
    let tsconfig_path = "tsconfig.json";

    let mut tsconfig: Value = if fs::exists(tsconfig_path) {
        let content = fs::read_to_string(tsconfig_path)?;
        serde_json::from_str(&content).context("Failed to parse tsconfig.json")?
    } else {
        json!({
            "compilerOptions": {
                "target": "ES2020",
                "module": "ES2020",
                "moduleResolution": "node",
                "strict": true,
                "noEmit": true,
                "baseUrl": "."
            },
            "include": ["behavior/scripts/**/*.ts"],
            "exclude": [".miga_modules", "dist", "build"]
        })
    };

    if let Some(opts) = tsconfig
        .get_mut("compilerOptions")
        .and_then(|v| v.as_object_mut())
    {
        let mut paths = Map::new();

        for name in project.externals.keys() {
            paths.insert(
                name.clone(),
                json!([format!("./.miga_modules/{}/index.d.ts", name)]),
            );
        }

        for (name, versions) in &lock.modules {
            // Prefer the version pinned in the manifest; fall back to the
            // first available version in the lock file.
            let version = project
                .modules
                .get(name)
                .or_else(|| versions.keys().next())
                .cloned()
                .unwrap_or_default();

            if let Some(locked) = versions.get(&version) {
                paths.insert(
                    name.clone(),
                    json!([format!(
                        "./.miga_modules/{}/v{}/{}",
                        name, version, locked.entry
                    )]),
                );
                paths.insert(
                    format!("{}/*", name),
                    json!([format!("./.miga_modules/{}/v{}/*", name, version)]),
                );
            }
        }

        opts.insert("paths".to_string(), Value::Object(paths));
    }

    fs::write_force(tsconfig_path, &serde_json::to_string_pretty(&tsconfig)?)?;
    Ok(())
}