Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

6.8 KB
Raw Blame
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
import path from 'path';
import { mkdir, cp, readFile, writeFile, readdir, rm } from 'fs/promises';
import { existsSync } from 'fs';
import config from '../build.config.js';
import * as logger from '../utils/logger.js';
import { runCommand } from '../utils/emscripten.js';
import { hashDirectory, hashFiles, HashCache } from '../utils/hash.js';

export async function buildSdk(options = {}) {
    const { manifest = null, noCache = false } = options;

    if (manifest) {
        manifest.startTarget('sdk');
    }

    try {
        logger.step('Building SDK...');

        const sdkDir = config.paths.sdk;
        const outputDir = path.join(config.paths.output, 'sdk');

        const sdkOutputs = [
            'esm/esengine.js',
            'esm/esengine.bundled.js',
            'esm/esengine.d.ts',
            'esm/wasm.js',
            'esm/wasm.d.ts',
            'esm/spine/index.js',
            'esm/spine/index.d.ts',
            'esm/physics/index.js',
            'esm/physics/index.d.ts',
            'esm/physics3d/index.js',
            'esm/physics3d/index.d.ts',
            'cjs/esengine.wechat.js',
            'cjs/index.wechat.js',
        ];

        let cache = null;
        let currentHash = null;

        if (!noCache) {
            cache = new HashCache(config.paths.cache);
            await cache.load();

            const sdkSrcDir = path.join(sdkDir, 'src');
            // The bundle is a function of the sources AND the build configuration,
            // so bundler/tsconfig/package edits must bust the cache too.
            const configFiles = ['rolldown.config.js', 'rollup.config.js', 'tsconfig.json', 'package.json']
                .map((f) => path.join(sdkDir, f));
            currentHash = `${await hashDirectory(sdkSrcDir, /\.ts$/)}:${await hashFiles(configFiles)}`;

            // Skip only when the source is unchanged AND the artifacts are actually
            // present. Hashing the source alone wrongly reported "cached" after the
            // dist/outputDir had been deleted or left incomplete, so a stale or
            // missing build was never regenerated (this masked a newly-generated
            // component.generated.ts from reaching consumers).
            const distFresh = existsSync(path.join(sdkDir, 'dist', 'index.js'));
            const outputsFresh = sdkOutputs.every((rel) => existsSync(path.join(outputDir, rel)));
            if (!await cache.isChanged('sdk', currentHash) && distFresh && outputsFresh) {
                logger.success('SDK: No changes detected (cached)');
                const result = { outputDir, outputs: sdkOutputs, skipped: true };
                if (manifest) {
                    await manifest.endTarget('sdk', result);
                }
                return result;
            }
        }

        await mkdir(outputDir, { recursive: true });
        await runCommand('npm', ['run', 'build'], { cwd: sdkDir });
        await copyDistOutputs(sdkDir, outputDir);

        if (cache) {
            cache.set('sdk', currentHash);
            await cache.save();
        }

        logger.success('SDK: Build complete');

        const result = { outputDir, outputs: sdkOutputs };

        if (manifest) {
            await manifest.endTarget('sdk', result);
        }

        return result;
    } catch (error) {
        if (manifest) {
            manifest.markTargetFailed('sdk', error);
        }
        throw error;
    }
}

async function copyDistOutputs(sdkDir, outputDir) {
    const distDir = path.join(sdkDir, 'dist');

    if (!existsSync(distDir)) {
        logger.warn('SDK dist directory not found');
        return;
    }

    const esmDir = path.join(outputDir, 'esm');
    const cjsDir = path.join(outputDir, 'cjs');

    await rm(esmDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
    await mkdir(esmDir, { recursive: true });
    await mkdir(cjsDir, { recursive: true });

    const spineDir = path.join(esmDir, 'spine');
    const dragonBonesDir = path.join(esmDir, 'dragonbones');
    const physicsDir = path.join(esmDir, 'physics');
    const physics3dDir = path.join(esmDir, 'physics3d');
    const sharedDir = path.join(esmDir, 'shared');
    await mkdir(spineDir, { recursive: true });
    await mkdir(dragonBonesDir, { recursive: true });
    await mkdir(physicsDir, { recursive: true });
    await mkdir(physics3dDir, { recursive: true });
    await mkdir(sharedDir, { recursive: true });

    const files = [
        { src: 'index.js', dest: path.join(esmDir, 'esengine.js') },
        { src: 'index.bundled.js', dest: path.join(esmDir, 'esengine.bundled.js') },
        { src: 'index.bundled.js.map', dest: path.join(esmDir, 'esengine.bundled.js.map') },
        { src: 'index.d.ts', dest: path.join(esmDir, 'esengine.d.ts') },
        { src: 'wasm.js', dest: path.join(esmDir, 'wasm.js') },
        { src: 'wasm.d.ts', dest: path.join(esmDir, 'wasm.d.ts') },
        { src: 'spine/index.js', dest: path.join(spineDir, 'index.js') },
        { src: 'spine/index.d.ts', dest: path.join(spineDir, 'index.d.ts') },
        { src: 'dragonbones/index.js', dest: path.join(dragonBonesDir, 'index.js') },
        { src: 'dragonbones/index.d.ts', dest: path.join(dragonBonesDir, 'index.d.ts') },
        { src: 'physics/index.js', dest: path.join(physicsDir, 'index.js') },
        { src: 'physics/index.d.ts', dest: path.join(physicsDir, 'index.d.ts') },
        { src: 'physics3d/index.js', dest: path.join(physics3dDir, 'index.js') },
        { src: 'physics3d/index.d.ts', dest: path.join(physics3dDir, 'index.d.ts') },
        { src: 'index.wechat.js', dest: path.join(cjsDir, 'index.wechat.js') },
        { src: 'index.wechat.cjs.js', dest: path.join(cjsDir, 'esengine.wechat.js') },
    ];

    for (const { src, dest } of files) {
        const srcPath = path.join(distDir, src);
        if (existsSync(srcPath)) {
            await cp(srcPath, dest);
            logger.debug(`Copied ${src}`);
        }
    }

    const srcSharedDir = path.join(distDir, 'shared');
    if (existsSync(srcSharedDir)) {
        const sharedFiles = await readdir(srcSharedDir);
        for (const file of sharedFiles) {
            await cp(path.join(srcSharedDir, file), path.join(sharedDir, file));
        }
        logger.debug(`Copied ${sharedFiles.length} shared chunks`);
    }
}

export async function cleanSdk() {
    const sdkDistDir = path.join(config.paths.sdk, 'dist');
    const outputSdkDir = path.join(config.paths.output, 'sdk');

    if (existsSync(sdkDistDir)) {
        await rm(sdkDistDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
        logger.debug('Removed sdk/dist');
    }

    if (existsSync(outputSdkDir)) {
        await rm(outputSdkDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
        logger.debug('Removed build/sdk');
    }
}