devalang 0.2.0

Write music with code. Devalang is a domain-specific language (DSL) for sound designers and music hackers. Compose, automate, and control sound — in plain text.
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

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.bumpVersion = bumpVersion;
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const child_process_1 = require("child_process");
/**
 * Bumps the version across all project files
 */
async function bumpVersion(type, preTag = 'beta') {
    const rootPath = path.resolve(__dirname, '../../../..');
    // Read current versions
    const packageJsonPath = path.join(rootPath, 'package.json');
    const cargoTomlPath = path.join(rootPath, 'Cargo.toml');
    const projectVersionPath = path.join(rootPath, 'project-version.json');
    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
    const currentVersion = packageJson.version;
    // Parse version
    const versionMatch = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)(?:-(.+))?$/);
    if (!versionMatch) {
        throw new Error(`Invalid version format: ${currentVersion}`);
    }
    let [, major, minor, patch, pre] = versionMatch;
    let majorNum = parseInt(major);
    let minorNum = parseInt(minor);
    let patchNum = parseInt(patch);
    // Calculate new version
    let newVersion;
    let channel = 'stable';
    switch (type) {
        case 'major':
            majorNum++;
            minorNum = 0;
            patchNum = 0;
            newVersion = `${majorNum}.${minorNum}.${patchNum}`;
            break;
        case 'minor':
            minorNum++;
            patchNum = 0;
            newVersion = `${majorNum}.${minorNum}.${patchNum}`;
            break;
        case 'patch':
            patchNum++;
            newVersion = `${majorNum}.${minorNum}.${patchNum}`;
            break;
        case 'pre':
            const preVersion = pre ? parseInt(pre.split('.')[1] || '0') + 1 : 0;
            newVersion = `${majorNum}.${minorNum}.${patchNum}-${preTag}.${preVersion}`;
            channel = preTag;
            break;
    }
    // Get git commit hash
    let commit;
    try {
        commit = (0, child_process_1.execSync)('git rev-parse --short HEAD', { encoding: 'utf-8' }).trim();
    }
    catch (error) {
        console.warn('⚠️  Could not get git commit hash');
    }
    // Update package.json
    packageJson.version = newVersion;
    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
    console.log(`✅ Updated package.json to ${newVersion}`);
    // Update Cargo.toml
    let cargoToml = fs.readFileSync(cargoTomlPath, 'utf-8');
    cargoToml = cargoToml.replace(/version = "[\d\.]+-?[a-z\.]*\d*"/, `version = "${newVersion}"`);
    fs.writeFileSync(cargoTomlPath, cargoToml);
    console.log(`✅ Updated Cargo.toml to ${newVersion}`);
    // Update project-version.json
    const projectVersion = {
        version: newVersion,
        channel,
        build: 1, // Reset build number on version bump
        commit
    };
    fs.writeFileSync(projectVersionPath, JSON.stringify(projectVersion, null, 2) + '\n');
    console.log(`✅ Updated project-version.json to ${newVersion}`);
    // Update installer/windows/devalang.wxs (WiX installer)
    const wixFilePath = path.join(rootPath, 'installer', 'windows', 'devalang.wxs');
    if (fs.existsSync(wixFilePath)) {
        try {
            let wixContent = fs.readFileSync(wixFilePath, 'utf-8');
            // Update ProductVersion in the <?define ?> section
            wixContent = wixContent.replace(/<\?define ProductVersion="[\d\.]+\-?[a-z\.]*\d*" \?>/, `<` + `?define ProductVersion="${newVersion}" ?` + `>`);
            fs.writeFileSync(wixFilePath, wixContent);
            console.log(`✅ Updated installer/windows/devalang.wxs to ${newVersion}`);
        }
        catch (error) {
            console.warn('⚠️  Could not update installer/windows/devalang.wxs:', error);
        }
    }
    else {
        console.warn('⚠️  installer/windows/devalang.wxs not found, skipping');
    }
    return newVersion;
}
//# sourceMappingURL=bump.js.map