petcarescript/tools/build.js

PetCareScript - A modern, expressive programming language designed for humans with async, HTTP, database, and testing support

/**
 * PetCareScript Build Script
 */

const fs = require('fs');
const path = require('path');

class Builder {
    constructor() {
        this.version = require('../package.json').version;
        this.distDir = './dist';
    }

    build() {
        console.log('🔨 Building PetCareScript...');

        this.createDistDirectory();
        this.copySourceFiles();
        this.createMinifiedVersion();
        this.createBrowserVersion();
        this.generateMetadata();

        console.log('✅ Build completed!');
    }

    createDistDirectory() {
        if (!fs.existsSync(this.distDir)) {
            fs.mkdirSync(this.distDir, { recursive: true });
        }
    }

    copySourceFiles() {
        // Copy main files to dist
        const filesToCopy = [
            'index.js',
            'package.json',
            'README.md'
        ];

        filesToCopy.forEach(file => {
            fs.copyFileSync(file, path.join(this.distDir, file));
        });

        // Copy src directory
        this.copyDirectory('./src', path.join(this.distDir, 'src'));
    }

    copyDirectory(src, dest) {
        if (!fs.existsSync(dest)) {
            fs.mkdirSync(dest, { recursive: true });
        }

        const entries = fs.readdirSync(src, { withFileTypes: true });

        for (const entry of entries) {
            const srcPath = path.join(src, entry.name);
            const destPath = path.join(dest, entry.name);

            if (entry.isDirectory()) {
                this.copyDirectory(srcPath, destPath);
            } else {
                fs.copyFileSync(srcPath, destPath);
            }
        }
    }

    createMinifiedVersion() {
        // Minified version (placeholder - would need a real minifier)
        const mainFile = fs.readFileSync('./index.js', 'utf8');
        const minified = mainFile.replace(/\s+/g, ' ').trim();
        fs.writeFileSync(path.join(this.distDir, 'index.min.js'), minified);
    }

    createBrowserVersion() {
        // Browser version
        const browserCode = `/**
 * PetCareScript Browser Version
 */
(function(global) {
    // Browser-compatible version would need modification
    // This is a placeholder for the browser build
    
    console.warn('PetCareScript browser version is not yet implemented');
    
    global.PetCareScript = {
        version: '${this.version}',
        available: false
    };
    
    // AMD support
    if (typeof define === 'function' && define.amd) {
        define('petcarescript', [], function() {
            return global.PetCareScript;
        });
    }
    
    // CommonJS support
    if (typeof module === 'object' && module.exports) {
        module.exports = global.PetCareScript;
    }
    
})(typeof window !== 'undefined' ? window : this);`;

        fs.writeFileSync(path.join(this.distDir, 'petcarescript.browser.js'), browserCode);
    }

    generateMetadata() {
        const metadata = {
            name: 'PetCareScript',
            version: this.version,
            buildDate: new Date().toISOString(),
            files: this.getFileList(this.distDir),
            size: this.calculateTotalSize(this.distDir)
        };

        fs.writeFileSync(
            path.join(this.distDir, 'build-info.json'),
            JSON.stringify(metadata, null, 2)
        );
    }

    getFileList(dir) {
        const files = [];
        const entries = fs.readdirSync(dir, { withFileTypes: true });

        for (const entry of entries) {
            const fullPath = path.join(dir, entry.name);
            if (entry.isDirectory()) {
                files.push(...this.getFileList(fullPath));
            } else {
                files.push(path.relative(this.distDir, fullPath));
            }
        }

        return files;
    }

    calculateTotalSize(dir) {
        let totalSize = 0;
        const entries = fs.readdirSync(dir, { withFileTypes: true });

        for (const entry of entries) {
            const fullPath = path.join(dir, entry.name);
            if (entry.isDirectory()) {
                totalSize += this.calculateTotalSize(fullPath);
            } else {
                totalSize += fs.statSync(fullPath).size;
            }
        }

        return totalSize;
    }
}

// Execute build
const builder = new Builder();
builder.build();