@intelligentgraphics/ig.gfx.packager 3.0.20 → 3.0.22

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';
@@ -71,7 +73,7 @@ const readPackageCreatorManifest = (location)=>{
 };
 const writePackageCreatorManifest = (location, creatorPackage)=>{
     const packageJsonPath = path.join(location.manifestDir, PACKAGE_FILE);
-    fs.writeFileSync(packageJsonPath, JSON.stringify(creatorPackage, null, "\t") + "\n");
+    fs.writeFileSync(packageJsonPath, JSON.stringify(creatorPackage, null, "	") + "\n");
 };
 const getPackageCreatorIndexPath = (location)=>path.join(location.manifestDir, INDEX_FILE);
 const readPackageCreatorIndex = (location)=>{
@@ -90,7 +92,7 @@ const readPackageCreatorIndex = (location)=>{
 };
 const writePackageCreatorIndex = (location, index)=>{
     const indexPath = getPackageCreatorIndexPath(location);
-    fs.writeFileSync(indexPath, JSON.stringify(index, null, "\t") + "\n");
+    fs.writeFileSync(indexPath, JSON.stringify(index, null, "	") + "\n");
 };
 const readPackageNpmManifest = (location)=>{
     try {
@@ -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}`);
 };
 
@@ -282,7 +284,7 @@ const PLUGIN_ID = "0feba3a0-b6d1-11e6-9598-0800200c9a66";
  *
  * @param {SessionStartParams} params
  * @returns
- */ const startSession = async ({ url , authentication , ...params })=>{
+ */ const startSession = async ({ url, authentication, ...params })=>{
     const payload = {
         ...params,
         user: undefined,
@@ -296,7 +298,7 @@ const PLUGIN_ID = "0feba3a0-b6d1-11e6-9598-0800200c9a66";
     } else if (authentication.type === "license") {
         payload.license = authentication.license;
     }
-    const { data: { session: sessionId , state , response  }  } = await axios.post(`Session/Start2`, JSON.stringify(payload), {
+    const { data: { session: sessionId, state, response } } = await axios.post(`Session/Start2`, JSON.stringify(payload), {
         baseURL: url
     });
     if (state !== "SUCCESS") {
@@ -319,11 +321,11 @@ const closeSession = async (session)=>{
         baseURL: session.url
     });
 };
-const uploadPackageFromStream = async (session, { name , version  }, stream)=>{
+const uploadPackageFromStream = async (session, { name, version }, stream)=>{
     await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}/`, stream);
 };
 const uploadPackageToUrl = async (url, path, stream)=>{
-    const { data , status  } = await axios.post(path, stream, {
+    const { data, status } = await axios.post(path, stream, {
         baseURL: url
     });
     let objectBody;
@@ -358,7 +360,7 @@ const uploadPackageToUrl = async (url, path, stream)=>{
     return data;
 };
 const getExistingPackages = async (session)=>{
-    const { data  } = await axios.get(`Script/GetInformation/${session.sessionId}`, {
+    const { data } = await axios.get(`Script/GetInformation/${session.sessionId}`, {
         baseURL: session.url,
         validateStatus: (status)=>status === 404 || status === 200
     }).catch((err)=>{
@@ -368,7 +370,7 @@ const getExistingPackages = async (session)=>{
 };
 
 const tryReadTsConfig = (location)=>{
-    const { config  } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
+    const { config } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
         try {
             return fs.readFileSync(path, "utf8");
         } catch  {
@@ -377,7 +379,187 @@ 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();
+            env.log("Compiling typescript files");
+            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 +570,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 +635,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 +1075,115 @@ 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)=>(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 +1197,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 +1208,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
+            manager.addListener("error", (error)=>{
+                reject(new Error(error));
             });
-            const minifiedPath = path.join(outputDirectory, `${data.Package}.min.js`);
-            fs.writeFileSync(minifiedPath, minifyResult.code, {
-                encoding: "utf8"
-            });
-        }
-        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 +1247,128 @@ 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) {
+        logStep("Minifying the output");
+        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, "	"), "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, "	"), "utf8");
     }
 };
 const applyTsConfigOption = (data)=>{
@@ -1095,13 +1507,9 @@ const getWorkspaceBannerText = (manifest)=>{
 
 // Stolen from ig.tools.core
 class PackageVersion {
-    static #_ = (()=>{
-        // https://regex101.com/r/90PEY9/1
-        this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
-    })();
-    static #_1 = (()=>{
-        this.lineMatcher = /^(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?$/;
-    })();
+    static #_ = // https://regex101.com/r/90PEY9/1
+    this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
+    static #_2 = this.lineMatcher = /^(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?$/;
     static extractFromText(input, description) {
         if (input === undefined) {
             throw new Error(`Can not parse version from undefined`);
@@ -1221,7 +1629,7 @@ class PackageVersion {
         this.preRelease = undefined;
         this.buildNumber = 100;
     }
-    toVersionString({ buildNumber  } = {}) {
+    toVersionString({ buildNumber } = {}) {
         let version = [
             this.major,
             this.minor,
@@ -1414,7 +1822,7 @@ const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage)=>{
         if (fs.existsSync(source)) {
             const images = fs.readdirSync(source);
             for (const file of images){
-                const { ext  } = path.parse(file);
+                const { ext } = path.parse(file);
                 switch(ext){
                     case ".png":
                     case ".jpeg":
@@ -1438,10 +1846,9 @@ const notRuntimeScripts = [
     "Context",
     "Evaluator"
 ];
-const buildArchiveFromPackage = async (packageLocation, data, binDir)=>{
-    const { domain  } = parseCreatorPackageName(data);
+const buildArchiveFromPackage = async (packageLocation, data, binDir, minified = true)=>{
+    const { domain } = parseCreatorPackageName(data);
     const logStep = (step)=>logPackageMessage(data.Package, step);
-    const libFilePath = path.join(binDir, `${data.Package}.min.js`);
     const scriptDirectories = [
         packageLocation.path,
         packageLocation.scriptsDir
@@ -1468,6 +1875,7 @@ const buildArchiveFromPackage = async (packageLocation, data, binDir)=>{
     }
     let libFile;
     try {
+        const libFilePath = minified ? path.join(binDir, `${data.Package}.min.js`) : path.join(binDir, `${data.Package}.js`);
         libFile = fs.readFileSync(libFilePath, {
             encoding: "utf8"
         });
@@ -1486,10 +1894,7 @@ const buildArchiveFromPackage = async (packageLocation, data, binDir)=>{
         library = `/* This file is part of the ${domain} Data Packages.
 		* Copyright (C) ${date.getFullYear()} intelligentgraphics. All Rights Reserved. */`;
     }
-    const minifyResult = await terser.minify(library, {
-        ecma: 5
-    });
-    archive.file(`${data.Package}.js`, minifyResult.code);
+    archive.file(`${data.Package}.js`, library);
     archive.file(PACKAGE_FILE, JSON.stringify(data, null, 2));
     const creatorIndex = readPackageCreatorIndex(packageLocation);
     if (creatorIndex !== undefined) {
@@ -1498,7 +1903,7 @@ const buildArchiveFromPackage = async (packageLocation, data, binDir)=>{
     for (const directory of scriptDirectories){
         try {
             for (const file of fs.readdirSync(directory)){
-                const { ext  } = path.parse(file);
+                const { ext } = path.parse(file);
                 switch(ext){
                     case ".png":
                     case ".jpeg":
@@ -1520,10 +1925,10 @@ const execAsync = promisify(exec);
 const releaseFolder = async (options)=>{
     const workspace = options.workspace;
     const location = options.directory;
-    const { write: writeVersionFile , reset: resetVersionFile  } = getVersionFileHandler(location);
+    const { write: writeVersionFile, reset: resetVersionFile } = getVersionFileHandler(location);
     const packageDescription = readPackageCreatorManifest(location);
     const fullPackageName = packageDescription.Package;
-    const { domain , subdomain  } = parseCreatorPackageName(packageDescription);
+    const { domain, subdomain } = parseCreatorPackageName(packageDescription);
     const publishDomain = options.domain ?? domain;
     const publishSubdomain = options.subdomain ?? subdomain;
     const sharedPackageJson = readWorkspaceNpmManifest(workspace);
@@ -1631,7 +2036,8 @@ const releaseFolder = async (options)=>{
                     }
                 }
             }
-            const archive = await buildArchiveFromPackage(location, packageDescription, binDir);
+            logPackageMessage(packageDescription.Package, `Creating zip file`);
+            const archive = await buildArchiveFromPackage(location, packageDescription, binDir, options.minimize);
             try {
                 const zipOutputStream = createWriteStream(zipFilePath);
                 await pipeline(archive.generateNodeStream(), zipOutputStream);
@@ -1837,7 +2243,7 @@ const createSessionManager = async (params)=>{
  * Extracts and returns script array for _Index.json from a src folder
  *
  * @param folderPath path to a src folder
- */ function generateIndex({ location , ignore =[] , strictOptional =false  }) {
+ */ function generateIndex({ location, ignore = [], strictOptional = false }) {
     const files = getPackageTypescriptFiles(location);
     const filtered = files.filter((path)=>{
         return !ignore.some((suffix)=>path.endsWith(suffix));
@@ -2107,5 +2513,5 @@ const detectScriptingClass = (node)=>{
     }
 };
 
-export { buildFolders, generateIndex, releaseFolder };
+export { buildFolders, buildFoldersWatch, generateIndex, releaseFolder };
 //# sourceMappingURL=lib.mjs.map