@intelligentgraphics/ig.gfx.packager 3.0.19 → 3.0.21

package/build/index-e6ead55c.mjs

@@ -0,0 +1,1120 @@
+import * as path from 'path';
+import * as fs$1 from 'fs/promises';
+import * as terser from 'terser';
+import * as fs from 'fs';
+import 'resolve';
+import 'write-pkg';
+import { c as readPackageAnimationList, r as readPackageCreatorManifest, i as isErrorENOENT, q as readPackageNpmManifest } from './cli-91fabb36.mjs';
+import glob from 'glob';
+import 'node:path';
+import 'node:fs';
+import 'axios';
+import ts from 'typescript';
+import { g as getPackageTypescriptFiles } from './scripts-7ed8dff6.mjs';
+import typedoc from 'typedoc';
+import require$$2 from 'events';
+import { SourceMapGenerator, SourceMapConsumer } from 'source-map-js';
+import Ajv from 'ajv';
+
+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(maxNameLength)}`;
+    console.log(`${identifierString} >> ${step}`);
+};
+
+const tryReadTsConfig = (location)=>{
+    const { config  } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
+        try {
+            return fs.readFileSync(path, "utf8");
+        } catch  {
+            return undefined;
+        }
+    });
+    return config;
+};
+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",
+        "dom"
+    ];
+    const result = ts.convertCompilerOptionsFromJson(config.compilerOptions, location.scriptsDir);
+    const compilerOptions = {
+        ...result.options,
+        removeComments: false,
+        declaration: true,
+        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
+    };
+    return compilerOptions;
+};
+
+const generateDocs = async (location, declarationFile, outFolder, name)=>{
+    const app = new typedoc.Application();
+    const mediaDir = path.join(location.manifestDir, "Media");
+    app.bootstrap({
+        entryPoints: [
+            declarationFile
+        ],
+        media: mediaDir,
+        out: outFolder,
+        tsconfig: path.join(location.scriptsDir, "tsconfig.json"),
+        skipErrorChecking: true
+    });
+    app.options.setCompilerOptions([
+        declarationFile
+    ], {
+        target: ts.ScriptTarget.ES5
+    }, undefined);
+    app.options.setValue("name", name);
+    const [readmePath] = glob.sync("**/readme.md", {
+        absolute: true,
+        cwd: location.manifestDir
+    });
+    if (readmePath) {
+        app.options.setValue("readme", readmePath);
+    }
+    const project = app.convert();
+    if (project) {
+        await app.generateDocs(project, outFolder);
+    }
+};
+
+// Stolen from ig.tools.core
+const toposort = (packages)=>{
+    const queue = Object.getOwnPropertyNames(packages);
+    const result = [];
+    let index = 0;
+    while(queue.length > 0){
+        if (index >= queue.length) {
+            throw new Error("Packages can not have cyclic dependencies");
+        }
+        const queueEntry = queue[index];
+        const dependencies = packages[queueEntry];
+        const dependencyQueued = dependencies.some((dependency)=>queue.includes(dependency));
+        if (dependencyQueued) {
+            index++;
+            continue;
+        }
+        queue.splice(index, 1);
+        index = 0;
+        result.push(queueEntry);
+    }
+    return result;
+};
+
+class BuildManager extends require$$2 {
+    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",
+    $comment: "Version 2023-02-17, Source: ig.data.gfx/Specs/animation.json",
+    title: "Animation description format",
+    additionalProperties: false,
+    type: "object",
+    properties: {
+        $schema: {
+            type: "string"
+        },
+        Id: {
+            type: "string",
+            description: "Animation id, to be unique in the project scope. Needs to be a valid JavaScript identifier."
+        },
+        Animations: {
+            type: "array",
+            description: "Declaration of animation states for gfx objects",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    _: {
+                        type: "string",
+                        description: "Comment"
+                    },
+                    Path: {
+                        $ref: "#/definitions/igxcPath"
+                    },
+                    States: {
+                        type: "object",
+                        additionalProperties: {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                Position: {
+                                    $ref: "#/definitions/vec3"
+                                },
+                                Rotation: {
+                                    $ref: "#/definitions/rotation"
+                                },
+                                Scaling: {
+                                    $ref: "#/definitions/vec3"
+                                },
+                                Visibility: {
+                                    type: "boolean"
+                                },
+                                Deformation: {
+                                    anyOf: [
+                                        {
+                                            type: "number"
+                                        },
+                                        {
+                                            type: "string"
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        Kinematics: {
+            oneOf: [
+                {
+                    $ref: "#/definitions/kinematicChain"
+                },
+                {
+                    type: "array",
+                    items: {
+                        $ref: "#/definitions/kinematicChain"
+                    }
+                }
+            ]
+        },
+        LinkedPoints: {
+            type: "object",
+            additionalProperties: {
+                type: "array",
+                items: {
+                    type: "string"
+                }
+            }
+        },
+        _: {
+            type: "string",
+            description: "Comment"
+        }
+    },
+    definitions: {
+        vec3: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                X: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Y: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Z: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                }
+            }
+        },
+        rotation: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                Q: {
+                    description: "If true, the rotation is considered to be a Quaternion. Otherwise, it's interpreted as Euler arcs and W will be ignored.",
+                    type: "boolean"
+                },
+                X: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Y: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                Z: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                W: {
+                    anyOf: [
+                        {
+                            type: "number"
+                        },
+                        {
+                            type: "string"
+                        }
+                    ]
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                }
+            }
+        },
+        igxcPath: {
+            type: "string",
+            description: "Relative path of the target object",
+            pattern: "^((o|e)\\d+(\\.(o|e)\\d+)*|\\.)$"
+        },
+        param: {
+            type: "string",
+            pattern: "^Param\\d+$"
+        },
+        kinematicChain: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                GeometryBase: {
+                    type: "string"
+                },
+                Joints: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        properties: {
+                            Name: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        type: "string"
+                                    }
+                                ]
+                            },
+                            HeadX: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            HeadY: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            HeadZ: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            Tail: {
+                                oneOf: [
+                                    {
+                                        $ref: "#/definitions/param"
+                                    },
+                                    {
+                                        $ref: "#/definitions/igxcPath"
+                                    }
+                                ]
+                            },
+                            LimitLeft: {
+                                type: "number"
+                            },
+                            LimitRight: {
+                                type: "number"
+                            },
+                            LimitUp: {
+                                type: "number"
+                            },
+                            LimitDown: {
+                                type: "number"
+                            },
+                            FollowJointNode: {
+                                $ref: "#/definitions/igxcPath"
+                            },
+                            _TargetNodeForFollow: {
+                                type: "string"
+                            }
+                        }
+                    }
+                },
+                Target: {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/igxcPath"
+                        },
+                        {
+                            $ref: "#/definitions/param"
+                        },
+                        {
+                            type: "string",
+                            enum: [
+                                "subbase"
+                            ]
+                        }
+                    ]
+                },
+                Parent: {
+                    oneOf: [
+                        {
+                            $ref: "#/definitions/igxcPath"
+                        },
+                        {
+                            type: "string",
+                            enum: [
+                                "root"
+                            ]
+                        }
+                    ]
+                },
+                Tolerance: {
+                    type: "number"
+                },
+                MaxIterations: {
+                    type: "integer"
+                },
+                _: {
+                    type: "string",
+                    description: "Comment"
+                },
+                __: {
+                    type: "string",
+                    description: "Super Comment"
+                }
+            }
+        }
+    }
+};
+
+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) {
+        validateAnimationJson = new Ajv({
+            coerceTypes: true,
+            allErrors: true,
+            removeAdditional: true,
+            useDefaults: "empty",
+            validateSchema: "log"
+        }).compile(animationSchema);
+    }
+    return validateAnimationJson;
+};
+
+const buildFolders = 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 logStep = (step)=>logPackageMessage(data.Package, step, index, 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", createTSCBuildParticipant(location, outputDirectory));
+        manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
+        await new Promise((resolve, reject)=>{
+            manager.addListener("start", ()=>{
+                logStep(`Build started`);
+            });
+            manager.addListener("error", (error)=>{
+                reject(new Error(error));
+            });
+            manager.addListener("build", ()=>{
+                logStep(`Build complete`);
+                resolve();
+            });
+            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);
+        }
+        index++;
+    }
+};
+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"
+        });
+    }
+};
+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");
+    try {
+        const content = JSON.parse(await fs$1.readFile(tsconfigPath, "utf8"));
+        applyTsConfigOption(content);
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+        const content = {};
+        applyTsConfigOption(content);
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+    }
+};
+const applyTsConfigOption = (data)=>{
+    data.compilerOptions = data.compilerOptions ?? {};
+    data.compilerOptions.target = "es5";
+    data.compilerOptions.lib = [
+        "es5",
+        "dom"
+    ];
+};
+const sortPackagesByBuildOrder = (folders)=>{
+    const packages = Array.from(folders).reduce((acc, location)=>{
+        const data = readPackageNpmManifest(location);
+        if (data !== undefined) {
+            acc[data.name] = {
+                data,
+                location
+            };
+        } else {
+            acc[location.path] = {
+                data: undefined,
+                location
+            };
+        }
+        return acc;
+    }, {});
+    const packageDependencies = Object.getOwnPropertyNames(packages).reduce((acc, packageName)=>{
+        const packageData = packages[packageName];
+        if (packageData.data === undefined) {
+            acc[packageName] = [];
+        } else {
+            acc[packageName] = Object.getOwnPropertyNames({
+                ...packageData.data.devDependencies,
+                ...packageData.data.dependencies,
+                ...packageData.data.peerDependencies
+            }).filter((packageName)=>packages[packageName] !== undefined);
+        }
+        return acc;
+    }, {});
+    const sortedPackages = toposort(packageDependencies);
+    const result = [];
+    for (const packageName of sortedPackages){
+        const location = packages[packageName].location;
+        if (readPackageCreatorManifest(location).Package.endsWith(".Basics")) {
+            result.unshift(location);
+        } else {
+            result.push(location);
+        }
+    }
+    return result;
+};
+const createBannerComment = (banner)=>{
+    const bannerParts = [];
+    if (banner.text) {
+        bannerParts.push(" * " + banner.text);
+    }
+    {
+        const details = [];
+        if (banner.version) {
+            details.push(`Version: ${banner.version}`);
+        }
+        if (banner.commit) {
+            if (banner.commitDirty) {
+                details.push(`Commit: ${banner.commit} (dirty)`);
+            } else {
+                details.push(`Commit: ${banner.commit}`);
+            }
+        }
+        if (banner.date) {
+            details.push(`Date: ${banner.date.toISOString()}`);
+        }
+        const detailsText = details.map((line)=>` * ${line}`).join("\n");
+        if (detailsText) {
+            bannerParts.push(detailsText);
+        }
+    }
+    const bannerText = bannerParts.join("\n\n");
+    if (bannerText) {
+        return `/*
+${bannerText}
+*
+* @preserve			
+*/`;
+    }
+    return undefined;
+};
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    buildFolders: buildFolders,
+    buildFoldersWatch: buildFoldersWatch
+});
+
+export { buildFolders as b, index as i, logPackageMessage as l };
+//# sourceMappingURL=index-e6ead55c.mjs.map