ng-packagr/src/lib/ng-package/entry-point/write-bundles.transform.js

Compile and package Angular libraries in Angular Package Format (APF)

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.writeBundlesTransform = void 0;
const node_path_1 = require("node:path");
const ora_1 = __importDefault(require("ora"));
const file_watcher_1 = require("../../file-system/file-watcher");
const rolldown_1 = require("../../flatten/rolldown");
const transform_1 = require("../../graph/transform");
const cache_1 = require("../../utils/cache");
const fs_1 = require("../../utils/fs");
const path_1 = require("../../utils/path");
const nodes_1 = require("../nodes");
const writeBundlesTransform = (options) => (0, transform_1.transformFromPromise)(async (graph) => {
    const entryPoint = (0, nodes_1.findEntryPointInProgress)(graph);
    const { destinationFiles, entryPoint: ngEntryPoint, tsConfig } = entryPoint.data;
    const cache = entryPoint.cache;
    const { fesm2022Dir, esm2022, declarations, declarationsDir } = destinationFiles;
    const spinner = (0, ora_1.default)({
        hideCursor: false,
        discardStdin: false,
    });
    const cacheKey = await (0, cache_1.generateKey)(ngEntryPoint.moduleId, declarationsDir, fesm2022Dir, tsConfig.options.compilationMode, (tsConfig.options.declarationMap ?? false).toString());
    const hash = await (0, cache_1.generateKey)([...cache.outputCache.values()].map(({ version }) => version).join(':'));
    const cacheDirectory = options.cacheEnabled && options.cacheDirectory;
    if (cacheDirectory) {
        const cacheResult = await (0, cache_1.readCacheEntry)(options.cacheDirectory, cacheKey);
        if (cacheResult?.hash === hash) {
            const filesToCopy = [
                ...cacheResult.fesm2022.map(file => ({
                    ...file,
                    filePath: (0, node_path_1.join)(fesm2022Dir, file.fileName),
                })),
                ...cacheResult.types.map(file => ({
                    ...file,
                    filePath: (0, node_path_1.join)(declarationsDir, file.fileName),
                })),
            ];
            try {
                const writeFilePromises = [];
                for (const file of filesToCopy) {
                    if (options.watch && (await (0, fs_1.exists)(file.filePath))) {
                        continue;
                    }
                    if (writeFilePromises.length === 0) {
                        spinner.start('Writing FESM and DTS bundles');
                        await Promise.all([(0, fs_1.mkdir)(fesm2022Dir, { recursive: true }), (0, fs_1.mkdir)(declarationsDir, { recursive: true })]);
                    }
                    writeFilePromises.push((0, fs_1.writeFile)(file.filePath, file.type === 'asset' ? file.source : file.code));
                }
                if (writeFilePromises.length) {
                    await Promise.all(writeFilePromises);
                    spinner.succeed('Writing FESM and DTS bundles');
                }
            }
            catch (error) {
                spinner.fail('Writing FESM and DTS bundles');
                throw error;
            }
            return;
        }
    }
    async function generateBundles() {
        const [{ files: fesmFiles }, { files: typesFiles }] = await Promise.all([
            (0, rolldown_1.rolldownBundleFile)({
                entry: esm2022,
                entryName: ngEntryPoint.flatModuleFile,
                moduleName: ngEntryPoint.moduleId,
                dir: fesm2022Dir,
                fileCache: cache.outputCache,
                sourcemap: true,
            }),
            (0, rolldown_1.rolldownBundleFile)({
                entry: declarations,
                entryName: ngEntryPoint.flatModuleFile,
                moduleName: ngEntryPoint.moduleId,
                dir: declarationsDir,
                fileCache: cache.outputCache,
                sourcemap: tsConfig.options.declarationMap ?? false,
            }),
        ]);
        const mapFile = (file) => file.type === 'chunk'
            ? {
                type: 'chunk',
                fileName: file.fileName,
                code: file.code,
            }
            : {
                type: 'asset',
                fileName: file.fileName,
                source: file.source,
            };
        return {
            hash,
            types: typesFiles.map(mapFile),
            fesm2022: fesmFiles.map(mapFile),
        };
    }
    let bundlesCache;
    try {
        bundlesCache = await generateBundles();
        spinner.succeed('Generating FESM and DTS bundles');
        // Invalidate dependent entry-points
        const changedDtsFiles = [];
        for (const file of bundlesCache.types) {
            if (file.type !== 'chunk' || !file.fileName.endsWith('.d.ts')) {
                continue;
            }
            const dtsFile = (0, path_1.ensureUnixPath)((0, node_path_1.join)(declarationsDir, file.fileName));
            const cachedSourceFile = cache.sourcesFileCache.get(dtsFile);
            if (cachedSourceFile?.sourceFile?.text !== file.code) {
                changedDtsFiles.push(dtsFile);
            }
        }
        if (changedDtsFiles.length) {
            (0, file_watcher_1.invalidateEntryPointsAndCacheOnFileChange)(graph, changedDtsFiles, cache.sourcesFileCache);
        }
    }
    catch (error) {
        spinner.fail();
        throw error;
    }
    if (cacheDirectory) {
        await (0, cache_1.saveCacheEntry)(cacheDirectory, cacheKey, bundlesCache);
    }
});
exports.writeBundlesTransform = writeBundlesTransform;
//# sourceMappingURL=write-bundles.transform.js.map