@intelligentgraphics/ig.gfx.packager 3.1.0-alpha.1 → 3.1.0-alpha.3

package/build/{index-0caf1a6e.mjs → index-CqUHGUfc.mjs}

@@ -1,26 +1,42 @@
 import * as path from 'path';
 import * as fs$1 from 'fs/promises';
 import * as terser from 'terser';
+import { EOL } from 'os';
+import ts from 'typescript';
 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-fec9c069.mjs';
-import glob from 'glob';
+import { e as readPackageAnimationList, r as readPackageCreatorManifest, q as readPackageNpmManifest, i as isErrorENOENT } from './cli-DANmLXRa.mjs';
+import { g as getPackageTypescriptFiles, i as isScriptPackageModules } from './scripts-DI0Xj5Yb.mjs';
 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 glob from 'glob';
 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 consoleReporter = {
+    log (message) {
+        console.log(message);
+    },
+    error (message, _error) {
+        console.error(message);
+    }
+};
+const createPackageScopedReporter = (reporter, scope, 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 identifierString = `${indexString}${scope.padEnd(maxNameLength)}`;
+    return {
+        log (message) {
+            reporter.log(`${identifierString} >> ${message}`);
+        },
+        error (message, error) {
+            reporter.error(`${identifierString} >> ${message}`, error);
+        }
+    };
 };
 
 const tryReadTsConfig = (location)=>{
@@ -33,25 +49,12 @@ const tryReadTsConfig = (location)=>{
     });
     return config;
 };
-const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
+const createTSCBuildParticipant = (location, outputDir, skipDeclarations)=>(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 compilerOptions = getCompilerOptions(location, outputDir, skipDeclarations);
             const host = ts.createCompilerHost(compilerOptions);
             host.getCurrentDirectory = ()=>location.scriptsDir;
             let js;
@@ -76,7 +79,7 @@ const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
             const allDiagnostics = ts.getPreEmitDiagnostics(program);
             if (!emitResult.emitSkipped) {
                 if (allDiagnostics.length > 0) {
-                    console.log(allDiagnostics.map(createErrorMessage).join("\n"));
+                    console.log(ts.formatDiagnostics(allDiagnostics, host));
                 }
                 if (js === undefined || definitions === undefined) {
                     throw new Error(`Unexpected: no js or definitions were created`);
@@ -85,12 +88,12 @@ const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
                     type: "success",
                     artefacts: {
                         js: js.replace(`//# sourceMappingURL=out.js.map`, ""),
-                        definitions,
+                        declarations: definitions,
                         sourceMap
                     }
                 });
             } else {
-                const error = allDiagnostics.map(createErrorMessage).join("\n");
+                const error = ts.formatDiagnostics(allDiagnostics, host);
                 throw new Error(error);
             }
         } catch (err) {
@@ -103,7 +106,7 @@ const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
             destroy: ()=>{}
         };
     };
-const createTSCWatchBuildParticipant = (location, outputDir)=>{
+const createTSCWatchBuildParticipant = (location, outputDir, skipDeclarations)=>{
     return ({ onBuildStart, onBuildEnd })=>{
         let state = {
             diagnostics: [],
@@ -123,7 +126,7 @@ const createTSCWatchBuildParticipant = (location, outputDir)=>{
                 }
             }
         };
-        const reportDiagnostic = (diagnostic)=>{
+        const registerDiagnostic = (diagnostic)=>{
             switch(diagnostic.code){
                 // file not found - https://github.com/microsoft/TypeScript/blob/93e6b9da0c4cb164ca90a5a1b07415e81e97f2b1/src/compiler/diagnosticMessages.json#L4640
                 // probably deleted -> ignore
@@ -158,10 +161,10 @@ const createTSCWatchBuildParticipant = (location, outputDir)=>{
                         sourceMap: undefined
                     };
                     if (emitState.diagnostics.length > 0) {
-                        const message = emitState.diagnostics.map(createErrorMessage).join("\n");
+                        const message = ts.formatDiagnostics(emitState.diagnostics, formattingHost);
                         onBuildEnd({
                             type: "error",
-                            error: message
+                            error: new Error(message)
                         });
                         return;
                     }
@@ -178,26 +181,20 @@ const createTSCWatchBuildParticipant = (location, outputDir)=>{
                         type: "success",
                         artefacts: {
                             js: emitState.js.replace(`//# sourceMappingURL=out.js.map`, ""),
-                            definitions: emitState.definitions,
+                            declarations: 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 host = ts.createWatchCompilerHost(path.join(location.scriptsDir, "tsconfig.json"), getCompilerOptions(location, outputDir, skipDeclarations), customSys, ts.createSemanticDiagnosticsBuilderProgram, registerDiagnostic, reportWatchStatusChanged);
+        const formattingHost = {
+            getCanonicalFileName: (path)=>path,
+            getCurrentDirectory: host.getCurrentDirectory,
+            getNewLine: ()=>ts.sys.newLine
+        };
         const watchProgram = ts.createWatchProgram(host);
-        const files = getPackageTypescriptFiles(location);
-        if (files.length === 0) {
-            onBuildStart();
-            onBuildEnd({
-                type: "success",
-                artefacts: {
-                    js: "",
-                    definitions: ""
-                }
-            });
-        }
         return {
             destroy: ()=>{
                 watchProgram.close();
@@ -205,15 +202,7 @@ const createTSCWatchBuildParticipant = (location, outputDir)=>{
         };
     };
 };
-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 getCompilerOptions = (location, outputDir, skipDeclarations)=>{
     const config = tryReadTsConfig(location);
     config.compilerOptions.lib = [
         "es5",
@@ -223,7 +212,7 @@ const getCompilerOptions = (location, outputDir)=>{
     const compilerOptions = {
         ...result.options,
         removeComments: false,
-        declaration: true,
+        declaration: !skipDeclarations,
         sourceMap: true,
         inlineSources: false,
         // We don't use tsc to actually emit the files, but we still need to set the correct
@@ -290,13 +279,8 @@ const toposort = (packages)=>{
 };
 
 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();
+    constructor(manifest, writer, reporter){
+        super(), this.manifest = manifest, this.writer = writer, this.reporter = reporter, this.participants = new Map(), this.states = new Map();
     }
     addParticipant(name, participant) {
         this.participants.set(name, participant);
@@ -329,7 +313,7 @@ class BuildManager extends require$$2 {
                     this.states.set(name, result);
                     this.maybeEmit();
                 },
-                log: this.logStep
+                log: (message)=>this.reporter.log(message)
             });
         }
     }
@@ -347,7 +331,7 @@ class BuildManager extends require$$2 {
             }
         }
         if (errors.length > 0) {
-            this.emit("error", errors.join("\n"));
+            this.emit("error", errors.length === 1 ? errors[0] : new AggregateError(errors));
             return;
         }
         const completeResult = {
@@ -369,14 +353,16 @@ class BuildManager extends require$$2 {
                                 line: lines + mapping.generatedLine,
                                 column: mapping.generatedColumn
                             },
-                            original: {
+                            original: mapping.originalLine !== null && mapping.originalColumn !== null ? {
                                 line: mapping.originalLine,
                                 column: mapping.originalColumn
-                            },
+                            } : undefined,
                             source: mapping.source,
                             name: mapping.name
                         });
-                        sources.add(mapping.source);
+                        if (mapping.source !== null) {
+                            sources.add(mapping.source);
+                        }
                     });
                     for (const source of sources){
                         const content = sourceMap.sourceContentFor(source);
@@ -387,13 +373,13 @@ class BuildManager extends require$$2 {
                 }
                 completeResult.js += result.artefacts.js;
             }
-            if (result.artefacts.definitions) {
-                if (completeResult.definitions) {
-                    completeResult.definitions += "\n";
+            if (result.artefacts.declarations) {
+                if (completeResult.declarations) {
+                    completeResult.declarations += "\n";
                 } else {
-                    completeResult.definitions = "";
+                    completeResult.declarations = "";
                 }
-                completeResult.definitions += result.artefacts.definitions;
+                completeResult.declarations += result.artefacts.declarations;
             }
         }
         completeResult.sourceMap = sourceMapGenerator.toString();
@@ -736,7 +722,7 @@ const createAnimationBuildParticipant = (location, manifest)=>{
             env.onBuildEnd({
                 type: "success",
                 artefacts: {
-                    js: (result == null ? void 0 : result.js) ?? ""
+                    js: result?.js ?? ""
                 }
             });
         }).catch((err)=>{
@@ -756,7 +742,7 @@ const createAnimationWatchBuildParticipant = (location, manifest)=>(env)=>{
             env.onBuildEnd({
                 type: "success",
                 artefacts: {
-                    js: (result == null ? void 0 : result.js) ?? ""
+                    js: result?.js ?? ""
                 }
             });
         }).catch((err)=>{
@@ -767,14 +753,14 @@ const createAnimationWatchBuildParticipant = (location, manifest)=>(env)=>{
         });
         (async ()=>{
             for await (const event of fs$1.watch(location.scriptsDir)){
-                if (event.filename.endsWith(".animation.json")) {
+                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) ?? ""
+                                js: result?.js ?? ""
                             }
                         });
                     } catch (err) {
@@ -852,12 +838,193 @@ const getAnimationJsonValidation = async ()=>{
     return validateAnimationJson;
 };
 
-const buildFolders = async (options)=>{
+// Stolen from ig.tools.core
+class PackageVersion {
+    static{
+        // https://regex101.com/r/90PEY9/1
+        this.fullTextMatcher = /(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?/;
+    }
+    static{
+        this.lineMatcher = /^(\d+)(\.(\d+)(\.(\d+)(\.(\d+))?(-([^\.]+)\.(\d+))?)?)?$/;
+    }
+    static extractFromText(input, description) {
+        if (input === undefined) {
+            throw new Error(`Can not parse version from undefined`);
+        }
+        const match = input.match(PackageVersion.fullTextMatcher);
+        if (!match) {
+            throw new Error(`Could not extract a version from input: ${input}`);
+        }
+        return PackageVersion.fromMatch(match, description);
+    }
+    static extractFromLine(input, description) {
+        if (input === undefined) {
+            throw new Error(`Can not parse version from undefined`);
+        }
+        const match = input.match(PackageVersion.lineMatcher);
+        if (!match) {
+            throw new Error(`Could not parse version from input: ${input}`);
+        }
+        return PackageVersion.fromMatch(match, description);
+    }
+    static equals(a, b, checkPrerelease = false) {
+        if (a.major !== b.major || a.minor !== b.minor || a.patch !== b.patch) {
+            return false;
+        }
+        if (checkPrerelease === false) {
+            return true;
+        }
+        if (a.preRelease === b.preRelease) {
+            return true;
+        }
+        if (a.preRelease === undefined || b.preRelease === undefined) {
+            return false;
+        }
+        return a.preRelease.type === b.preRelease.type && a.preRelease.version === b.preRelease.version;
+    }
+    static fromMatch([, major, , minor = "0", , patch = "0", , build, , preReleaseType, preReleaseNumber], description) {
+        let preRelease = undefined;
+        let buildNumber = 100;
+        if (preReleaseType && preReleaseNumber) {
+            preRelease = {
+                type: preReleaseType,
+                version: parseInt(preReleaseNumber)
+            };
+        }
+        if (build) {
+            buildNumber = Number(build);
+        } else if (description) {
+            const descriptionMatch = description.match(/(\d+)\)$/);
+            if (descriptionMatch) {
+                buildNumber = parseInt(descriptionMatch[1]);
+            }
+        }
+        return new PackageVersion(parseInt(major), parseInt(minor), parseInt(patch), preRelease, buildNumber);
+    }
+    static sort(a, b, ascending = true) {
+        const createSortResult = (a, b)=>ascending ? a - b : b - a;
+        if (a.major !== b.major) {
+            return createSortResult(a.major, b.major);
+        }
+        if (a.minor !== b.minor) {
+            return createSortResult(a.minor, b.minor);
+        }
+        if (a.patch !== b.patch) {
+            return createSortResult(a.patch, b.patch);
+        }
+        return createSortResult(a.preRelease ? a.preRelease.version : 0, b.preRelease ? b.preRelease.version : 0);
+    }
+    static toNumber(version) {
+        return ((version.major * 1000 + version.minor) * 1000 + version.patch) * 1000 + version.buildNumber;
+    }
+    constructor(major, minor, patch, preRelease, buildNumber){
+        this.major = major;
+        this.minor = minor;
+        this.patch = patch;
+        this.preRelease = preRelease;
+        this.buildNumber = buildNumber;
+    }
+    isPreRelease() {
+        return this.preRelease !== undefined;
+    }
+    clone() {
+        return new PackageVersion(this.major, this.minor, this.patch, this.preRelease ? {
+            ...this.preRelease
+        } : undefined, this.buildNumber);
+    }
+    incrementMajor() {
+        this.preRelease = undefined;
+        this.patch = 0;
+        this.minor = 0;
+        this.major++;
+    }
+    incrementMinor() {
+        this.preRelease = undefined;
+        this.patch = 0;
+        this.minor++;
+    }
+    incrementPatch() {
+        this.preRelease = undefined;
+        this.patch++;
+    }
+    createPreRelease(type) {
+        if (!this.preRelease) {
+            this.buildNumber = 1;
+        } else {
+            this.buildNumber++;
+        }
+        if (this.preRelease && type === this.preRelease.type) {
+            this.preRelease.version++;
+            return;
+        }
+        this.preRelease = {
+            version: 0,
+            type
+        };
+    }
+    createRelease() {
+        this.preRelease = undefined;
+        this.buildNumber = 100;
+    }
+    toVersionString({ buildNumber } = {}) {
+        let version = [
+            this.major,
+            this.minor,
+            this.patch
+        ].join(".");
+        if (buildNumber) {
+            version += "." + this.buildNumber;
+        }
+        if (this.preRelease) {
+            version += `-${this.preRelease.type}.${this.preRelease.version}`;
+        }
+        return version;
+    }
+    toDescriptionString(packageName) {
+        const base = [
+            this.major,
+            this.minor,
+            this.patch
+        ].join(".");
+        const parts = [
+            packageName,
+            base
+        ];
+        if (this.preRelease) {
+            parts.push(upperCaseFirst(this.preRelease.type));
+            parts.push(this.preRelease.version);
+        }
+        parts.push(`(${base}.${this.buildNumber})`);
+        return parts.join(" ");
+    }
+    /**
+	 * Determines wether the version is lesser than the input version
+	 *
+	 * @param {PackageVersion} version
+	 * @returns
+	 */ isLesserThan(version) {
+        return PackageVersion.toNumber(this) < PackageVersion.toNumber(version);
+    }
+    /**
+	 * Determines wether the version is greater than the input version
+	 *
+	 * @param {PackageVersion} version
+	 * @returns
+	 */ isGreaterThan(version) {
+        return PackageVersion.toNumber(this) > PackageVersion.toNumber(version);
+    }
+}
+const upperCaseFirst = (input)=>{
+    return input.slice(0, 1).toUpperCase() + input.slice(1);
+};
+
+async function buildFolders(options) {
     if (options.outDir !== undefined && options.clean) {
         await fs$1.rm(options.outDir, {
             recursive: true
         });
     }
+    const baseReporter = options.reporter ?? consoleReporter;
     const workspace = options.workspace;
     const folders = options.packages;
     let sortedPackages = sortPackagesByBuildOrder(folders);
@@ -868,45 +1035,51 @@ const buildFolders = async (options)=>{
         ]));
     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 tsConfig = await ensureTsConfig(location);
         const data = manifests.get(location);
-        const logStep = (step)=>logPackageMessage(data.Package, step, index, folders.length, maxNameLength);
+        const reporter = options.preparedReporter ?? createPackageScopedReporter(baseReporter, data.Package, 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);
+        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
         if (options.banner) {
             manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
         }
-        if (options.experimentalSwc) {
-            const { createSWCBuildParticipant } = await import('./swc-9ed0f3ce.mjs');
-            manager.addParticipant("swc", createSWCBuildParticipant(location));
-        } else {
-            manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory));
+        const typescriptFiles = getPackageTypescriptFiles(location);
+        if (!typescriptFiles.some((file)=>path.basename(file).toLowerCase() === "version.ts")) {
+            manager.addParticipant("version", createVersionLogBuildParticipant(data));
+        }
+        if (typescriptFiles.length > 0) {
+            if (isScriptPackageModules(tsConfig.options)) {
+                const { createRollupBuildParticipant } = await import('./rollup-BEli071h.mjs');
+                manager.addParticipant("rollup", createRollupBuildParticipant(location, data, outputDirectory, options.skipDeclarations ?? false));
+            } else {
+                manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory, options.skipDeclarations ?? false));
+            }
         }
         manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
         await new Promise((resolve, reject)=>{
             manager.addListener("start", ()=>{
-                logStep(`Build started`);
+                reporter.log(`Build started`);
             });
             manager.addListener("error", (error)=>{
-                reject(new Error(error));
+                reject(error);
             });
             manager.addListener("build", ()=>{
-                logStep(`Build complete`);
+                reporter.log(`Build complete`);
                 resolve();
             });
             manager.run();
         });
         if (options.docs) {
-            logStep("Generating typedoc documentation");
+            reporter.log("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)=>{
+}
+async function buildFoldersWatch(options) {
     if (options.outDir !== undefined && options.clean) {
         await fs$1.rm(options.outDir, {
             recursive: true
@@ -922,30 +1095,41 @@ const buildFoldersWatch = async (options)=>{
         ]));
     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 tsConfig = await ensureTsConfig(location);
+        const baseReporter = options.reporter ?? consoleReporter;
         const data = manifests.get(location);
-        const currentIndex = index;
-        const logStep = (step)=>logPackageMessage(data.Package, step, currentIndex, folders.length, maxNameLength);
+        const reporter = createPackageScopedReporter(baseReporter, data.Package, 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);
+        const manager = new BuildManager(data, (result)=>writeBuildResult(result, data, location, workspace, outputDirectory, options.minimize, reporter), reporter);
         if (options.banner) {
             manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
         }
-        manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory));
+        const typescriptFiles = getPackageTypescriptFiles(location);
+        if (!typescriptFiles.some((file)=>path.basename(file).toLowerCase() === "version.ts")) {
+            manager.addParticipant("version", createVersionLogBuildParticipant(data));
+        }
+        if (typescriptFiles.length > 0) {
+            if (isScriptPackageModules(tsConfig.options)) {
+                const { createRollupWatchBuildParticipant } = await import('./rollup-BEli071h.mjs');
+                manager.addParticipant("rollup", createRollupWatchBuildParticipant(location, data, outputDirectory, options.skipDeclarations ?? false));
+            } else {
+                manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory, options.skipDeclarations ?? false));
+            }
+        }
         manager.addParticipant("animation", createAnimationWatchBuildParticipant(location, data));
         await new Promise((resolve, reject)=>{
             manager.addListener("start", ()=>{
-                logStep(`Build started`);
+                reporter.log(`Build started`);
             });
             manager.addListener("error", (error)=>{
-                logStep(`Build failed: ${error}`);
+                reporter.log(`Build failed: ${EOL}${error}`);
                 resolve();
             });
             manager.addListener("build", ()=>{
-                logStep(`Build complete`);
+                reporter.log(`Build complete`);
                 resolve();
             });
             manager.run();
@@ -953,8 +1137,8 @@ const buildFoldersWatch = async (options)=>{
         index++;
     }
     await new Promise(()=>{});
-};
-const writeBuildResult = async (buildResult, manifest, location, workspace, outputDirectory, minimize, logStep)=>{
+}
+async function writeBuildResult(buildResult, manifest, location, workspace, outputDirectory, minimize, reporter) {
     let js = buildResult.js;
     if (buildResult.sourceMap) {
         js += `\n//# sourceMappingURL=${manifest.Package}.js.map`;
@@ -962,8 +1146,8 @@ const writeBuildResult = async (buildResult, manifest, location, workspace, outp
     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, {
+    if (buildResult.declarations !== undefined) {
+        await fs$1.writeFile(path.join(outputDirectory, `${manifest.Package}.d.ts`), buildResult.declarations, {
             encoding: "utf8"
         });
     }
@@ -973,7 +1157,7 @@ const writeBuildResult = async (buildResult, manifest, location, workspace, outp
         });
     }
     if (minimize) {
-        logStep("Minifying the output");
+        reporter.log("Minifying the output");
         const minifyResult = await terser.minify(js, {
             ecma: 5,
             sourceMap: {
@@ -991,54 +1175,94 @@ const writeBuildResult = async (buildResult, manifest, location, workspace, outp
             });
         }
     }
-    if (location.path.includes("Basics") && buildResult.definitions !== undefined) {
+    if (location.path.includes("Basics") && buildResult.declarations !== 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, {
+        reporter.log("Copying basics definition file to the lib folder");
+        await fs$1.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.declarations, {
             encoding: "utf8"
         });
     }
-};
-const createBannerCommentBuildParticipant = (options)=>(env)=>{
+}
+function createVersionLogBuildParticipant(manifest) {
+    return (env)=>{
+        env.onBuildStart();
+        const parsedVersion = manifest.Version !== undefined ? PackageVersion.extractFromLine(manifest.Version) : undefined;
+        let logText;
+        if (parsedVersion !== undefined) {
+            logText = parsedVersion.toDescriptionString(manifest.Package);
+        } else {
+            logText = manifest.Package;
+        }
+        logText += ".";
+        if (manifest.Copyright !== undefined) {
+            logText += " " + manifest.Copyright;
+        }
+        env.onBuildEnd({
+            type: "success",
+            artefacts: {
+                js: `console.log(${JSON.stringify(logText)})`
+            }
+        });
+        return {
+            destroy: ()=>{}
+        };
+    };
+}
+function createBannerCommentBuildParticipant(options) {
+    return (env)=>{
         env.onBuildStart();
         const banner = createBannerComment(options);
         env.onBuildEnd({
             type: "success",
             artefacts: {
                 js: banner ?? "",
-                definitions: banner ?? ""
+                declarations: banner ?? ""
             }
         });
         return {
             destroy: ()=>{}
         };
     };
-const ensureTsConfig = async (location)=>{
+}
+async function ensureTsConfig(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, "	"), "utf8");
+        applyTsConfigOptions(content);
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+        return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
     } catch (err) {
         if (!isErrorENOENT(err)) {
             throw err;
         }
         const content = {};
-        applyTsConfigOption(content);
-        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "	"), "utf8");
+        applyTsConfigOptions(content);
+        await fs$1.writeFile(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
+        return ts.parseJsonConfigFileContent(content, ts.sys, location.scriptsDir);
     }
-};
-const applyTsConfigOption = (data)=>{
-    data.compilerOptions = data.compilerOptions ?? {};
-    data.compilerOptions.target = "es5";
-    data.compilerOptions.lib = [
-        "es5",
-        "dom"
-    ];
-};
-const sortPackagesByBuildOrder = (folders)=>{
+}
+function applyTsConfigOptions(data) {
+    if (data.compilerOptions?.module?.toLowerCase().startsWith("es")) {
+        data.compilerOptions = data.compilerOptions ?? {};
+        data.compilerOptions.target = "esnext";
+        data.compilerOptions.lib = [
+            "esnext",
+            "dom"
+        ];
+        data.compilerOptions.module = "es2015";
+        data.compilerOptions.moduleResolution = "node";
+    } else {
+        data.compilerOptions = data.compilerOptions ?? {};
+        data.compilerOptions.target = "es5";
+        data.compilerOptions.lib = [
+            "es5",
+            "dom"
+        ];
+    }
+}
+function sortPackagesByBuildOrder(folders) {
     const packages = Array.from(folders).reduce((acc, location)=>{
         const data = readPackageNpmManifest(location);
         if (data !== undefined) {
@@ -1078,8 +1302,8 @@ const sortPackagesByBuildOrder = (folders)=>{
         }
     }
     return result;
-};
-const createBannerComment = (banner)=>{
+}
+function createBannerComment(banner) {
     const bannerParts = [];
     if (banner.text) {
         bannerParts.push(" * " + banner.text);
@@ -1113,7 +1337,7 @@ ${bannerText}
 */`;
     }
     return undefined;
-};
+}
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1121,5 +1345,5 @@ var index = /*#__PURE__*/Object.freeze({
     buildFoldersWatch: buildFoldersWatch
 });
 
-export { buildFolders as b, index as i, logPackageMessage as l };
-//# sourceMappingURL=index-0caf1a6e.mjs.map
+export { PackageVersion as P, consoleReporter as a, buildFolders as b, createPackageScopedReporter as c, index as i };
+//# sourceMappingURL=index-CqUHGUfc.mjs.map