@intelligentgraphics/ig.gfx.packager 3.0.20 → 3.0.21

package/lib/lib.mjs

@@ -1,7 +1,8 @@
 import * as path from 'path';
+import * as fs$1 from 'fs/promises';
+import * as terser from 'terser';
 import * as fs from 'fs';
 import { createWriteStream, createReadStream } from 'fs';
-import * as terser from 'terser';
 import resolve from 'resolve';
 import 'write-pkg';
 import glob from 'glob';
@@ -9,8 +10,9 @@ import 'write-json-file';
 import axios from 'axios';
 import ts from 'typescript';
 import typedoc from 'typedoc';
+import EventEmitter from 'events';
+import { SourceMapGenerator, SourceMapConsumer } from 'source-map-js';
 import Ajv from 'ajv';
-import * as fs$1 from 'fs/promises';
 import { pipeline } from 'stream/promises';
 import { exec } from 'child_process';
 import { promisify } from 'util';
@@ -263,10 +265,10 @@ const readStringFromFileOrUndefined = (filePath)=>{
     }
 };
 
-const logPackageMessage = (name, step, index, total)=>{
+const logPackageMessage = (name, step, index, total, maxNameLength = 15)=>{
     const numLength = total === undefined ? undefined : total.toString().length;
     const indexString = total === undefined || total < 2 ? "" : `${index.toString().padStart(numLength, "0")}/${total} `;
-    const identifierString = `${indexString}${name.padEnd(15)}`;
+    const identifierString = `${indexString}${name.padEnd(maxNameLength)}`;
     console.log(`${identifierString} >> ${step}`);
 };
 
@@ -377,7 +379,186 @@ const tryReadTsConfig = (location)=>{
     });
     return config;
 };
-const build = async (location, outputDir)=>{
+const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
+        const files = getPackageTypescriptFiles(location);
+        if (files.length === 0) {
+            env.onBuildStart();
+            env.onBuildEnd({
+                type: "success",
+                artefacts: {
+                    js: "",
+                    definitions: ""
+                }
+            });
+            return {
+                destroy: ()=>{}
+            };
+        }
+        try {
+            env.onBuildStart();
+            const compilerOptions = getCompilerOptions(location, outputDir);
+            const host = ts.createCompilerHost(compilerOptions);
+            host.getCurrentDirectory = ()=>location.scriptsDir;
+            let js;
+            let definitions;
+            let sourceMap;
+            host.writeFile = (fileName, data, writeByteOrderMark)=>{
+                if (fileName.endsWith(".js")) {
+                    js = data;
+                } else if (fileName.endsWith(".d.ts")) {
+                    definitions = data;
+                } else if (fileName.endsWith(".js.map")) {
+                    sourceMap = data;
+                }
+            };
+            const programOptions = {
+                rootNames: files,
+                options: compilerOptions,
+                host
+            };
+            const program = ts.createProgram(programOptions);
+            const emitResult = program.emit();
+            const allDiagnostics = ts.getPreEmitDiagnostics(program);
+            if (!emitResult.emitSkipped) {
+                if (allDiagnostics.length > 0) {
+                    console.log(allDiagnostics.map(createErrorMessage).join("\n"));
+                }
+                if (js === undefined || definitions === undefined) {
+                    throw new Error(`Unexpected: no js or definitions were created`);
+                }
+                env.onBuildEnd({
+                    type: "success",
+                    artefacts: {
+                        js: js.replace(`//# sourceMappingURL=out.js.map`, ""),
+                        definitions,
+                        sourceMap
+                    }
+                });
+            } else {
+                const error = allDiagnostics.map(createErrorMessage).join("\n");
+                throw new Error(error);
+            }
+        } catch (err) {
+            env.onBuildEnd({
+                type: "error",
+                error: err.message
+            });
+        }
+        return {
+            destroy: ()=>{}
+        };
+    };
+const createTSCWatchBuildParticipant = (location, outputDir)=>{
+    return ({ onBuildStart , onBuildEnd  })=>{
+        let state = {
+            diagnostics: [],
+            js: undefined,
+            definitions: undefined,
+            sourceMap: undefined
+        };
+        const customSys = {
+            ...ts.sys,
+            writeFile: (fileName, data, writeByteOrderMark)=>{
+                if (fileName.endsWith(".js")) {
+                    state.js = data;
+                } else if (fileName.endsWith(".d.ts")) {
+                    state.definitions = data;
+                } else if (fileName.endsWith(".js.map")) {
+                    state.sourceMap = data;
+                }
+            }
+        };
+        const reportDiagnostic = (diagnostic)=>{
+            switch(diagnostic.code){
+                // file not found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4640
+                // probably deleted -> ignore
+                case 6053:
+                    return;
+                // no inputs were found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L6838
+                // we don't care about this error. a user might have temporarily deleted the last ts file and will readd one later.
+                case 18003:
+                    return;
+            }
+            state.diagnostics.push(diagnostic);
+        };
+        const reportWatchStatusChanged = (diagnostic)=>{
+            switch(diagnostic.code){
+                // regular watch mode - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4567
+                case 6031:
+                // incremental watch mode - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4571
+                case 6032:
+                    // build start
+                    onBuildStart();
+                    break;
+                // found one error - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L5119
+                case 6193:
+                // found n or 0 errors - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L5123
+                case 6194:
+                    // build end
+                    const emitState = state;
+                    state = {
+                        diagnostics: [],
+                        js: undefined,
+                        definitions: undefined,
+                        sourceMap: undefined
+                    };
+                    if (emitState.diagnostics.length > 0) {
+                        const message = emitState.diagnostics.map(createErrorMessage).join("\n");
+                        onBuildEnd({
+                            type: "error",
+                            error: message
+                        });
+                        return;
+                    }
+                    if (emitState.js === undefined || emitState.definitions === undefined) {
+                        onBuildEnd({
+                            type: "success",
+                            artefacts: {
+                                js: ""
+                            }
+                        });
+                        return;
+                    }
+                    onBuildEnd({
+                        type: "success",
+                        artefacts: {
+                            js: emitState.js.replace(`//# sourceMappingURL=out.js.map`, ""),
+                            definitions: emitState.definitions,
+                            sourceMap: emitState.sourceMap
+                        }
+                    });
+                    break;
+            }
+        };
+        const host = ts.createWatchCompilerHost(path.join(location.scriptsDir, "tsconfig.json"), getCompilerOptions(location, outputDir), customSys, ts.createSemanticDiagnosticsBuilderProgram, reportDiagnostic, reportWatchStatusChanged);
+        const watchProgram = ts.createWatchProgram(host);
+        const files = getPackageTypescriptFiles(location);
+        if (files.length === 0) {
+            onBuildStart();
+            onBuildEnd({
+                type: "success",
+                artefacts: {
+                    js: "",
+                    definitions: ""
+                }
+            });
+        }
+        return {
+            destroy: ()=>{
+                watchProgram.close();
+            }
+        };
+    };
+};
+const createErrorMessage = (diagnostic)=>{
+    if (!diagnostic.file) {
+        return `${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
+    }
+    const { line , character  } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+    return `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`;
+};
+const getCompilerOptions = (location, outputDir)=>{
     const config = tryReadTsConfig(location);
     config.compilerOptions.lib = [
         "es5",
@@ -388,58 +569,15 @@ const build = async (location, outputDir)=>{
         ...result.options,
         removeComments: false,
         declaration: true,
-        sourceMap: false,
+        sourceMap: true,
+        inlineSources: false,
         // We don't use tsc to actually emit the files, but we still need to set the correct
         // output directory so the compiler can rewrite the `reference path` directives.
         outFile: path.join(outputDir, "out.js"),
         target: ts.ScriptTarget.ES5,
         noEmitOnError: true
     };
-    const host = ts.createCompilerHost(compilerOptions);
-    host.getCurrentDirectory = ()=>location.scriptsDir;
-    let js;
-    let definitions;
-    host.writeFile = (fileName, data, writeByteOrderMark)=>{
-        if (fileName.endsWith(".js")) {
-            js = data;
-        } else if (fileName.endsWith(".d.ts")) {
-            definitions = data;
-        }
-    };
-    const files = getPackageTypescriptFiles(location);
-    if (files.length === 0) {
-        throw new Error(`Expected typescript files to exist when building a package. Packages only consisting of animation jsons do not need to be built.`);
-    }
-    const programOptions = {
-        rootNames: files,
-        options: compilerOptions,
-        host
-    };
-    const program = ts.createProgram(programOptions);
-    const emitResult = program.emit();
-    const allDiagnostics = ts.getPreEmitDiagnostics(program);
-    if (!emitResult.emitSkipped) {
-        if (allDiagnostics.length > 0) {
-            console.log(allDiagnostics.map(createErrorMessage).join("\n"));
-        }
-        if (js === undefined || definitions === undefined) {
-            throw new Error(`Unexpected: no js or definitions were created`);
-        }
-        return {
-            js,
-            definitions
-        };
-    }
-    const error = allDiagnostics.map(createErrorMessage).join("\n");
-    throw new Error(error);
-};
-const createErrorMessage = (diagnostic)=>{
-    if (!diagnostic.file) {
-        return `${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
-    }
-    const { line , character  } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-    return `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`;
+    return compilerOptions;
 };
 
 const generateDocs = async (location, declarationFile, outFolder, name)=>{
@@ -496,6 +634,120 @@ const toposort = (packages)=>{
     return result;
 };
 
+class BuildManager extends EventEmitter {
+    constructor(manifest, writer, logStep){
+        super();
+        this.manifest = manifest;
+        this.writer = writer;
+        this.logStep = logStep;
+        this.participants = new Map();
+        this.states = new Map();
+    }
+    addParticipant(name, participant) {
+        this.participants.set(name, participant);
+    }
+    run() {
+        for (const [name] of this.participants){
+            this.states.set(name, {
+                type: "busy"
+            });
+        }
+        this.emit("start");
+        for (const [name, participant] of this.participants){
+            participant({
+                onBuildStart: ()=>{
+                    let alreadyBusy = false;
+                    for (const [name, state] of this.states){
+                        if (state.type === "busy") {
+                            alreadyBusy = true;
+                            continue;
+                        }
+                    }
+                    this.states.set(name, {
+                        type: "busy"
+                    });
+                    if (!alreadyBusy) {
+                        this.emit("start");
+                    }
+                },
+                onBuildEnd: (result)=>{
+                    this.states.set(name, result);
+                    this.maybeEmit();
+                },
+                log: this.logStep
+            });
+        }
+    }
+    maybeEmit() {
+        const errors = [];
+        const results = [];
+        for (const [_, state] of this.states){
+            if (state.type === "busy") {
+                return;
+            }
+            if (state.type === "success") {
+                results.push(state);
+            } else if (state.type === "error") {
+                errors.push(state.error);
+            }
+        }
+        if (errors.length > 0) {
+            this.emit("error", errors.join("\n"));
+            return;
+        }
+        const completeResult = {
+            js: ""
+        };
+        const sourceMapGenerator = new SourceMapGenerator();
+        for (const result of results){
+            if (result.artefacts.js) {
+                if (completeResult.js) {
+                    completeResult.js += "\n";
+                }
+                if (result.artefacts.sourceMap) {
+                    const lines = completeResult.js.split("\n").length - 1;
+                    const sourceMap = new SourceMapConsumer(JSON.parse(result.artefacts.sourceMap));
+                    const sources = new Set();
+                    sourceMap.eachMapping((mapping)=>{
+                        sourceMapGenerator.addMapping({
+                            generated: {
+                                line: lines + mapping.generatedLine,
+                                column: mapping.generatedColumn
+                            },
+                            original: {
+                                line: mapping.originalLine,
+                                column: mapping.originalColumn
+                            },
+                            source: mapping.source,
+                            name: mapping.name
+                        });
+                        sources.add(mapping.source);
+                    });
+                    for (const source of sources){
+                        const content = sourceMap.sourceContentFor(source);
+                        if (content !== null) {
+                            sourceMapGenerator.setSourceContent(source, content);
+                        }
+                    }
+                }
+                completeResult.js += result.artefacts.js;
+            }
+            if (result.artefacts.definitions) {
+                if (completeResult.definitions) {
+                    completeResult.definitions += "\n";
+                } else {
+                    completeResult.definitions = "";
+                }
+                completeResult.definitions += result.artefacts.definitions;
+            }
+        }
+        completeResult.sourceMap = sourceMapGenerator.toString();
+        this.writer(completeResult).then(()=>{
+            this.emit("build");
+        });
+    }
+}
+
 var animationSchema = {
     $schema: "http://json-schema.org/draft-07/schema",
     $id: "https://archive.intelligentgraphics.biz/schemas/gfx/animation.json",
@@ -822,6 +1074,117 @@ var animationSchema = {
     }
 };
 
+const createAnimationBuildParticipant = (location, manifest)=>{
+    return (env)=>{
+        env.onBuildStart();
+        bundleAnimations(location, manifest, env.log).then((result)=>{
+            env.onBuildEnd({
+                type: "success",
+                artefacts: {
+                    js: (result == null ? void 0 : result.js) ?? ""
+                }
+            });
+        }).catch((err)=>{
+            env.onBuildEnd({
+                type: "error",
+                error: err.message
+            });
+        });
+        return {
+            destroy: ()=>{}
+        };
+    };
+};
+const createAnimationWatchBuildParticipant = (location, manifest)=>{
+    return (env)=>{
+        env.onBuildStart();
+        bundleAnimations(location, manifest, env.log).then((result)=>{
+            env.onBuildEnd({
+                type: "success",
+                artefacts: {
+                    js: (result == null ? void 0 : result.js) ?? ""
+                }
+            });
+        }).catch((err)=>{
+            env.onBuildEnd({
+                type: "error",
+                error: err.message
+            });
+        });
+        (async ()=>{
+            for await (const event of fs$1.watch(location.scriptsDir)){
+                if (event.filename.endsWith(".animation.json")) {
+                    env.onBuildStart();
+                    try {
+                        const result = await bundleAnimations(location, manifest, env.log);
+                        env.onBuildEnd({
+                            type: "success",
+                            artefacts: {
+                                js: (result == null ? void 0 : result.js) ?? ""
+                            }
+                        });
+                    } catch (err) {
+                        env.onBuildEnd({
+                            type: "error",
+                            error: err.message
+                        });
+                    }
+                }
+            }
+        })();
+        return {
+            destroy: ()=>{}
+        };
+    };
+};
+const bundleAnimations = async (location, manifest, logStep)=>{
+    const animations = new Map();
+    for (const scriptFilePath of readPackageAnimationList(location)){
+        const content = await fs$1.readFile(scriptFilePath, {
+            encoding: "utf8"
+        });
+        let data;
+        try {
+            data = JSON.parse(content);
+        } catch (err) {
+            const relativePath = path.relative(location.path, scriptFilePath);
+            if (err instanceof SyntaxError) {
+                throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
+            }
+            throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
+                cause: err
+            });
+        }
+        if (!data.Id) {
+            const fileName = path.basename(scriptFilePath, ".animation.json");
+            data.Id = fileName;
+        }
+        (await getAnimationJsonValidation())(data);
+        delete data.$schema;
+        animations.set(data.Id, JSON.stringify(data));
+    }
+    if (animations.size > 0) {
+        const scope = manifest.Scope ?? manifest.Package;
+        const scopeParts = scope.split(".");
+        let js = createNamespace(scopeParts);
+        for (const [name, content] of animations){
+            js += `${scope}["${name}"] = ` + content + ";";
+            logStep(`Adding animation ${scope}.${name}`);
+        }
+        return {
+            js
+        };
+    }
+    return undefined;
+};
+const createNamespace = (parts)=>{
+    let code = `var ${parts[0]};`;
+    for(let index = 0; index < parts.length; index++){
+        const path = parts.slice(0, index + 1).join(".");
+        code += `\n(${path} = ${path} || {});`;
+    }
+    return code;
+};
 let validateAnimationJson;
 const getAnimationJsonValidation = async ()=>{
     if (validateAnimationJson === undefined) {
@@ -835,9 +1198,10 @@ const getAnimationJsonValidation = async ()=>{
     }
     return validateAnimationJson;
 };
+
 const buildFolders = async (options)=>{
     if (options.outDir !== undefined && options.clean) {
-        fs.rmSync(options.outDir, {
+        await fs$1.rm(options.outDir, {
             recursive: true
         });
     }
@@ -845,93 +1209,38 @@ const buildFolders = async (options)=>{
     const folders = options.packages;
     let sortedPackages = sortPackagesByBuildOrder(folders);
     let index = 1;
+    const manifests = new Map(sortedPackages.map((location)=>[
+            location,
+            readPackageCreatorManifest(location)
+        ]));
+    const maxNameLength = Array.from(manifests.values(), (manifest)=>manifest.Package.length).reduce((acc, length)=>Math.max(acc, length), 0);
     for (const location of sortedPackages){
-        const hasTypescript = getPackageTypescriptFiles(location).length > 0;
-        ensureTsConfig(location);
-        const data = readPackageCreatorManifest(location);
-        const logStep = (step)=>logPackageMessage(data.Package, step, index, folders.length);
+        await ensureTsConfig(location);
+        const data = manifests.get(location);
+        const logStep = (step)=>logPackageMessage(data.Package, step, index, folders.length, maxNameLength);
         const outputDirectory = options.outDir || location.scriptsDir;
-        fs.mkdirSync(outputDirectory, {
+        await fs$1.mkdir(outputDirectory, {
             recursive: true
         });
-        let buildResult;
-        if (hasTypescript) {
-            logStep("Compiling typescript to javascript");
-            buildResult = await build(location, outputDirectory);
-        } else {
-            buildResult = {
-                js: ""
-            };
-        }
-        const banner = options.banner ? createBannerComment(options.banner) : undefined;
-        if (banner) {
-            buildResult.js = banner + "\n" + buildResult.js;
-            if (buildResult.definitions !== undefined) {
-                buildResult.definitions = banner + "\n" + buildResult.definitions;
-            }
-        }
-        const animations = new Map();
-        for (const scriptFilePath of readPackageAnimationList(location)){
-            const content = fs.readFileSync(scriptFilePath, {
-                encoding: "utf8"
-            });
-            let data;
-            try {
-                data = JSON.parse(content);
-            } catch (err) {
-                const relativePath = path.relative(options.workspace.path, scriptFilePath);
-                if (err instanceof SyntaxError) {
-                    throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
-                }
-                throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
-                    cause: err
-                });
-            }
-            if (!data.Id) {
-                const fileName = path.basename(scriptFilePath, ".animation.json");
-                data.Id = fileName;
-            }
-            (await getAnimationJsonValidation())(data);
-            delete data.$schema;
-            animations.set(data.Id, JSON.stringify(data));
-        }
-        if (animations.size > 0) {
-            const scope = data.Scope ?? data.Package;
-            const scopeParts = scope.split(".");
-            buildResult.js += createNamespace(scopeParts);
-            for (const [name, content] of animations){
-                buildResult.js += `${scope}["${name}"] = ` + content + ";";
-                logPackageMessage(data.Package, `Adding animation ${scope}.${name}`);
-            }
-        } else if (!hasTypescript) {
-            throw new Error(`Expected package to have a least one ts file or one animation.json file`);
-        }
-        fs.writeFileSync(path.join(outputDirectory, `${data.Package}.js`), buildResult.js, {
-            encoding: "utf8"
-        });
-        if (buildResult.definitions !== undefined) {
-            fs.writeFileSync(path.join(outputDirectory, `${data.Package}.d.ts`), buildResult.definitions, {
-                encoding: "utf8"
+        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, logStep), logStep);
+        if (options.banner) {
+            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
+        }
+        manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory));
+        manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
+        await new Promise((resolve, reject)=>{
+            manager.addListener("start", ()=>{
+                logStep(`Build started`);
             });
-        }
-        if (options.minimize) {
-            const minifyResult = await terser.minify(buildResult.js, {
-                ecma: 5
-            });
-            const minifiedPath = path.join(outputDirectory, `${data.Package}.min.js`);
-            fs.writeFileSync(minifiedPath, minifyResult.code, {
-                encoding: "utf8"
+            manager.addListener("error", (error)=>{
+                reject(new Error(error));
             });
-        }
-        if (location.path.includes("Basics") && buildResult.definitions !== undefined) {
-            fs.mkdirSync(path.join(workspace.path, "lib"), {
-                recursive: true
+            manager.addListener("build", ()=>{
+                logStep(`Build complete`);
+                resolve();
             });
-            logStep("Copying basics definition file to the lib folder");
-            fs.writeFileSync(path.join(workspace.path, "lib", `${data.Package}.d.ts`), buildResult.definitions, {
-                encoding: "utf8"
-            });
-        }
+            manager.run();
+        });
         if (options.docs) {
             logStep("Generating typedoc documentation");
             await generateDocs(location, path.join(outputDirectory, `${data.Package}.d.ts`), path.join(workspace.path, "docs", data.Package), data.Package);
@@ -939,24 +1248,127 @@ const buildFolders = async (options)=>{
         index++;
     }
 };
-const createNamespace = (parts)=>{
-    let code = `var ${parts[0]};`;
-    for(let index = 0; index < parts.length; index++){
-        const path = parts.slice(0, index + 1).join(".");
-        code += `\n(${path} = ${path} || {});`;
+const buildFoldersWatch = async (options)=>{
+    if (options.outDir !== undefined && options.clean) {
+        await fs$1.rm(options.outDir, {
+            recursive: true
+        });
+    }
+    const workspace = options.workspace;
+    const folders = options.packages;
+    let sortedPackages = sortPackagesByBuildOrder(folders);
+    let index = 1;
+    const manifests = new Map(sortedPackages.map((location)=>[
+            location,
+            readPackageCreatorManifest(location)
+        ]));
+    const maxNameLength = Array.from(manifests.values(), (manifest)=>manifest.Package.length).reduce((acc, length)=>Math.max(acc, length), 0);
+    for (const location of sortedPackages){
+        await ensureTsConfig(location);
+        const data = manifests.get(location);
+        const currentIndex = index;
+        const logStep = (step)=>logPackageMessage(data.Package, step, currentIndex, folders.length, maxNameLength);
+        const outputDirectory = options.outDir || location.scriptsDir;
+        await fs$1.mkdir(outputDirectory, {
+            recursive: true
+        });
+        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, logStep), logStep);
+        if (options.banner) {
+            manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
+        }
+        manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory));
+        manager.addParticipant("animation", createAnimationWatchBuildParticipant(location, data));
+        await new Promise((resolve, reject)=>{
+            manager.addListener("start", ()=>{
+                logStep(`Build started`);
+            });
+            manager.addListener("error", (error)=>{
+                logStep(`Build failed: ${error}`);
+                resolve();
+            });
+            manager.addListener("build", ()=>{
+                logStep(`Build complete`);
+                resolve();
+            });
+            manager.run();
+        });
+        index++;
+    }
+    await new Promise(()=>{});
+};
+const writeBuildResult = async (buildResult, manifest, location, workspace, outputDirectory, minimize, logStep)=>{
+    let js = buildResult.js;
+    if (buildResult.sourceMap) {
+        js += `\n//# sourceMappingURL=${manifest.Package}.js.map`;
+    }
+    await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js`), js, {
+        encoding: "utf8"
+    });
+    if (buildResult.definitions !== undefined) {
+        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.d.ts`), buildResult.definitions, {
+            encoding: "utf8"
+        });
+    }
+    if (buildResult.sourceMap !== undefined) {
+        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.js.map`), buildResult.sourceMap, {
+            encoding: "utf8"
+        });
+    }
+    if (minimize) {
+        const minifyResult = await terser.minify(js, {
+            ecma: 5,
+            sourceMap: {
+                content: buildResult.sourceMap,
+                includeSources: false
+            }
+        });
+        const minifiedPath = path.join(outputDirectory, `${manifest.Package}.min.js`);
+        await fs$1.writeFile(minifiedPath, minifyResult.code, {
+            encoding: "utf8"
+        });
+        if (minifyResult.map !== undefined) {
+            await fs$1.writeFile(minifiedPath + ".map", typeof minifyResult.map === "string" ? minifyResult.map : JSON.stringify(minifyResult.map), {
+                encoding: "utf8"
+            });
+        }
+    }
+    if (location.path.includes("Basics") && buildResult.definitions !== undefined) {
+        await fs$1.mkdir(path.join(workspace.path, "lib"), {
+            recursive: true
+        });
+        logStep("Copying basics definition file to the lib folder");
+        await fs$1.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.definitions, {
+            encoding: "utf8"
+        });
     }
-    return code;
 };
-const ensureTsConfig = (location)=>{
+const createBannerCommentBuildParticipant = (options)=>(env)=>{
+        env.onBuildStart();
+        const banner = createBannerComment(options);
+        env.onBuildEnd({
+            type: "success",
+            artefacts: {
+                js: banner ?? "",
+                definitions: banner ?? ""
+            }
+        });
+        return {
+            destroy: ()=>{}
+        };
+    };
+const ensureTsConfig = async (location)=>{
     const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
-    if (!fs.existsSync(tsconfigPath)) {
-        const content = {};
+    try {
+        const content = JSON.parse(await fs$1.readFile(tsconfigPath, "utf8"));
         applyTsConfigOption(content);
-        fs.writeFileSync(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
-    } else {
-        const content = JSON.parse(fs.readFileSync(tsconfigPath, "utf8"));
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+        const content = {};
         applyTsConfigOption(content);
-        fs.writeFileSync(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
     }
 };
 const applyTsConfigOption = (data)=>{
@@ -2107,5 +2519,5 @@ const detectScriptingClass = (node)=>{
     }
 };
 
-export { buildFolders, generateIndex, releaseFolder };
+export { buildFolders, buildFoldersWatch, generateIndex, releaseFolder };
 //# sourceMappingURL=lib.mjs.map