@intelligentgraphics/ig.gfx.packager 3.0.27 → 3.1.0-alpha.0

package/lib/lib.mjs

@@ -1,6 +1,8 @@
 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 { createWriteStream, createReadStream } from 'fs';
 import resolve from 'resolve';
@@ -8,18 +10,17 @@ import 'write-pkg';
 import glob from 'glob';
 import 'write-json-file';
 import axios, { AxiosError } 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 { EOL } from 'os';
 import { pipeline } from 'stream/promises';
 import { exec } from 'child_process';
 import { promisify } from 'util';
 import simpleGit from 'simple-git';
 import JSZip from 'jszip';
 import { buffer } from 'node:stream/consumers';
+import { resolveNamespaces, resolveNamespaceFullName } from '@intelligentgraphics/declarationbundler';
 
 const stripUtf8Bom = (text)=>{
     // Catches EFBBBF (UTF-8 BOM) because the buffer-to-string
@@ -59,13 +60,16 @@ const isErrorEPERM = (error)=>getNodeErrorCode(error) === "EPERM";
 const PACKAGE_FILE = "_Package.json";
 const INDEX_FILE = "_Index.json";
 const ANIMATION_FILE_SUFFIX = ".animation.json";
-const parseCreatorPackageName = (manifest)=>{
+function parseCreatorPackageName(manifest) {
     const [domain, subdomain] = manifest.Package.split(".");
+    if (subdomain === undefined) {
+        throw new Error(`Expected "Package" field of the _Package.json file to contain a value in the form of Domain.SubDomain`);
+    }
     return {
         domain,
         subdomain
     };
-};
+}
 const readPackageCreatorManifest = (location)=>{
     const packageJsonPath = path.join(location.manifestDir, PACKAGE_FILE);
     const packageJson = stripUtf8Bom(fs.readFileSync(packageJsonPath, {
@@ -301,7 +305,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,
@@ -315,7 +319,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") {
@@ -338,7 +342,7 @@ const closeSession = async (session)=>{
         baseURL: session.url
     });
 };
-const uploadPackageFromBuffer = async (session, { name , version  }, buffer)=>{
+const uploadPackageFromBuffer = async (session, { name, version }, buffer)=>{
     try {
         await uploadPackageToUrl(session.url, `UploadPackage/${session.sessionId}/${name}_${version}`, buffer);
     } catch (err) {
@@ -354,7 +358,7 @@ const uploadPackageFromBuffer = async (session, { name , version  }, buffer)=>{
     }
 };
 const uploadPackageToUrl = async (url, path, buffer)=>{
-    const { data , status  } = await axios.post(path, buffer, {
+    const { data, status } = await axios.post(path, buffer, {
         baseURL: url
     });
     let objectBody;
@@ -389,7 +393,7 @@ const uploadPackageToUrl = async (url, path, buffer)=>{
     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)=>{
@@ -398,8 +402,37 @@ const getExistingPackages = async (session)=>{
     return data;
 };
 
+function resolveScriptPackageEntryModule(location, manifest) {
+    let candidates = [
+        "index.ts"
+    ];
+    if (manifest.Type === "Context") {
+        candidates.push("Context.ts");
+    }
+    for (const candidate of candidates){
+        const candidatePath = path.join(location.scriptsDir, candidate);
+        if (fs.existsSync(candidatePath)) {
+            return candidatePath;
+        }
+    }
+}
+function readScriptPackageTSConfig(location) {
+    const { config } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
+        try {
+            return fs.readFileSync(path, "utf8");
+        } catch  {
+            return undefined;
+        }
+    });
+    const parsedTsConfig = ts.parseJsonConfigFileContent(config, ts.sys, location.scriptsDir);
+    return parsedTsConfig;
+}
+function isScriptPackageModules(options) {
+    return options.module === ts.ModuleKind.ES2015;
+}
+
 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  {
@@ -410,19 +443,6 @@ const tryReadTsConfig = (location)=>{
 };
 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");
@@ -460,7 +480,7 @@ const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
                     type: "success",
                     artefacts: {
                         js: js.replace(`//# sourceMappingURL=out.js.map`, ""),
-                        definitions,
+                        declarations: definitions,
                         sourceMap
                     }
                 });
@@ -479,7 +499,7 @@ const createTSCBuildParticipant = (location, outputDir)=>(env)=>{
         };
     };
 const createTSCWatchBuildParticipant = (location, outputDir)=>{
-    return ({ onBuildStart , onBuildEnd  })=>{
+    return ({ onBuildStart, onBuildEnd })=>{
         let state = {
             diagnostics: [],
             js: undefined,
@@ -553,7 +573,7 @@ const createTSCWatchBuildParticipant = (location, outputDir)=>{
                         type: "success",
                         artefacts: {
                             js: emitState.js.replace(`//# sourceMappingURL=out.js.map`, ""),
-                            definitions: emitState.definitions,
+                            declarations: emitState.definitions,
                             sourceMap: emitState.sourceMap
                         }
                     });
@@ -567,17 +587,6 @@ const createTSCWatchBuildParticipant = (location, outputDir)=>{
             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();
@@ -663,12 +672,7 @@ const toposort = (packages)=>{
 
 class BuildManager extends EventEmitter {
     constructor(manifest, writer, reporter){
-        super();
-        this.manifest = manifest;
-        this.writer = writer;
-        this.reporter = reporter;
-        this.participants = new Map();
-        this.states = new Map();
+        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);
@@ -741,14 +745,16 @@ class BuildManager extends EventEmitter {
                                 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);
@@ -759,13 +765,13 @@ class BuildManager extends EventEmitter {
                 }
                 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();
@@ -1122,8 +1128,7 @@ const createAnimationBuildParticipant = (location, manifest)=>{
         };
     };
 };
-const createAnimationWatchBuildParticipant = (location, manifest)=>{
-    return (env)=>{
+const createAnimationWatchBuildParticipant = (location, manifest)=>(env)=>{
         env.onBuildStart();
         bundleAnimations(location, manifest, env.log).then((result)=>{
             env.onBuildEnd({
@@ -1164,7 +1169,6 @@ const createAnimationWatchBuildParticipant = (location, manifest)=>{
             destroy: ()=>{}
         };
     };
-};
 const bundleAnimations = async (location, manifest, logStep)=>{
     const animations = new Map();
     for (const scriptFilePath of readPackageAnimationList(location)){
@@ -1227,7 +1231,183 @@ 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 #_2 = 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
@@ -1244,7 +1424,7 @@ 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 reporter = options.preparedReporter ?? createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
         const outputDirectory = options.outDir || location.scriptsDir;
@@ -1255,7 +1435,18 @@ const buildFolders = async (options)=>{
         if (options.banner) {
             manager.addParticipant("banner", createBannerCommentBuildParticipant(options.banner));
         }
-        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-BITLKeAN.mjs');
+                manager.addParticipant("rollup", createRollupBuildParticipant(location, data, outputDirectory));
+            } else {
+                manager.addParticipant("tsc", createTSCBuildParticipant(location, outputDirectory));
+            }
+        }
         manager.addParticipant("animation", createAnimationBuildParticipant(location, data));
         await new Promise((resolve, reject)=>{
             manager.addListener("start", ()=>{
@@ -1276,8 +1467,8 @@ const buildFolders = async (options)=>{
         }
         index++;
     }
-};
-const buildFoldersWatch = async (options)=>{
+}
+async function buildFoldersWatch(options) {
     if (options.outDir !== undefined && options.clean) {
         await fs$1.rm(options.outDir, {
             recursive: true
@@ -1293,7 +1484,7 @@ 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 reporter = createPackageScopedReporter(baseReporter, data.Package, index, folders.length, maxNameLength);
@@ -1305,7 +1496,18 @@ const buildFoldersWatch = async (options)=>{
         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-BITLKeAN.mjs');
+                manager.addParticipant("rollup", createRollupWatchBuildParticipant(location, data, outputDirectory));
+            } else {
+                manager.addParticipant("tsc", createTSCWatchBuildParticipant(location, outputDirectory));
+            }
+        }
         manager.addParticipant("animation", createAnimationWatchBuildParticipant(location, data));
         await new Promise((resolve, reject)=>{
             manager.addListener("start", ()=>{
@@ -1324,8 +1526,8 @@ const buildFoldersWatch = async (options)=>{
         index++;
     }
     await new Promise(()=>{});
-};
-const writeBuildResult = async (buildResult, manifest, location, workspace, outputDirectory, minimize, reporter)=>{
+}
+async function writeBuildResult(buildResult, manifest, location, workspace, outputDirectory, minimize, reporter) {
     let js = buildResult.js;
     if (buildResult.sourceMap) {
         js += `\n//# sourceMappingURL=${manifest.Package}.js.map`;
@@ -1333,8 +1535,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"
         });
     }
@@ -1362,54 +1564,95 @@ 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
         });
         reporter.log("Copying basics definition file to the lib folder");
-        await fs$1.writeFile(path.join(workspace.path, "lib", `${manifest.Package}.d.ts`), buildResult.definitions, {
+        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);
+        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);
+        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) {
+    var _data_compilerOptions_module, _data_compilerOptions;
+    if ((_data_compilerOptions = data.compilerOptions) == null ? void 0 : (_data_compilerOptions_module = _data_compilerOptions.module) == null ? void 0 : _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) {
@@ -1449,8 +1692,8 @@ const sortPackagesByBuildOrder = (folders)=>{
         }
     }
     return result;
-};
-const createBannerComment = (banner)=>{
+}
+function createBannerComment(banner) {
     const bannerParts = [];
     if (banner.text) {
         bannerParts.push(" * " + banner.text);
@@ -1484,7 +1727,7 @@ ${bannerText}
 */`;
     }
     return undefined;
-};
+}
 
 const getVersionInformationFromGit = async (workspaceLocation, packageLocation)=>{
     try {
@@ -1535,186 +1778,6 @@ const getWorkspaceBannerText = (manifest)=>{
     return bannerText;
 };
 
-// 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 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);
-};
-
 const parseVersionFromString = (input)=>{
     if (input === undefined) {
         throw new Error(`Can not parse version from undefined`);
@@ -1766,10 +1829,11 @@ const parseVersionFromNumericVersion = (version)=>{
 // https://regex101.com/r/LtGAu5/1
 const logRegex = /console\.log\(\s*"([\w\s\.\(\)]+)\ *Copyright[\w\s\(\)\.]+(\d{4}|\d{4} - \d{4})([\w\s\(\)\.]+)?",?\s*\)/i;
 const currentYear = new Date(Date.now()).getFullYear();
-const getVersionFileHandler = (location)=>{
+function getVersionFileHandler(location) {
     const filePath = path.join(location.scriptsDir, "Version.ts");
-    const invalidVersionFile = (versionFile)=>({
-            version: undefined,
+    function invalidVersionFile(versionFile, exists) {
+        return {
+            exists,
             write: (name, newVersion)=>{
                 const scriptsContent = fs.readdirSync(location.scriptsDir);
                 const tsFiles = scriptsContent.filter((file)=>file.endsWith(".ts"));
@@ -1794,10 +1858,12 @@ const getVersionFileHandler = (location)=>{
                     }
                 }
             }
-        });
-    const createVersionFileWriter = (copyright = [
+        };
+    }
+    function createVersionFileWriter(copyright = [
         currentYear
-    ], copyrightStuff = "")=>(name, newVersion)=>{
+    ], copyrightStuff = "") {
+        return (name, newVersion)=>{
             const descriptionText = newVersion.toDescriptionString(name);
             const copyrightText = createYearString(copyright);
             const result = `console.log("${descriptionText}. Copyright (C) ${copyrightText}${copyrightStuff}");`;
@@ -1805,14 +1871,15 @@ const getVersionFileHandler = (location)=>{
                 encoding: "utf-8"
             });
         };
+    }
     let rawVersionFile = readStringFromFileOrUndefined(filePath);
     if (rawVersionFile === undefined) {
-        return invalidVersionFile(rawVersionFile);
+        return invalidVersionFile(rawVersionFile, false);
     }
     const versionFile = rawVersionFile.replace(/\n/g, "");
     const match = versionFile.match(logRegex);
     if (!match) {
-        return invalidVersionFile(versionFile);
+        return invalidVersionFile(versionFile, true);
     }
     const [_full, _description, copyright, copyrightStuff] = match;
     const copyrightYears = copyright.match(/^(\d+)( ?- ?(\d+))?$/);
@@ -1828,6 +1895,7 @@ const getVersionFileHandler = (location)=>{
         ];
     }
     return {
+        exists: true,
         write: createVersionFileWriter(years, copyrightStuff),
         reset: ()=>{
             fs.writeFileSync(filePath, versionFile, {
@@ -1835,7 +1903,7 @@ const getVersionFileHandler = (location)=>{
             });
         }
     };
-};
+}
 const createYearString = (years)=>{
     if (years[1] === undefined || years[0] === years[1]) {
         return years[0].toString();
@@ -1856,7 +1924,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":
@@ -1881,7 +1949,7 @@ const notRuntimeScripts = [
     "Evaluator"
 ];
 const buildArchiveFromPackage = async (reporter, packageLocation, data, binDir, minified = true)=>{
-    const { domain  } = parseCreatorPackageName(data);
+    const { domain } = parseCreatorPackageName(data);
     const scriptDirectories = [
         packageLocation.path,
         packageLocation.scriptsDir
@@ -1936,7 +2004,7 @@ const buildArchiveFromPackage = async (reporter, 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":
@@ -2113,11 +2181,11 @@ const execAsync = promisify(exec);
 const releaseFolder = async (options)=>{
     const workspace = options.workspace;
     const location = options.directory;
-    const { write: writeVersionFile , reset: resetVersionFile  } = getVersionFileHandler(location);
+    const versionFile = getVersionFileHandler(location);
     const packageDescription = readPackageCreatorManifest(location);
     const fullPackageName = packageDescription.Package;
     const reporter = options.reporter ?? createPackageScopedReporter(consoleReporter, 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);
@@ -2142,13 +2210,15 @@ const releaseFolder = async (options)=>{
             version: newVersion.buildNumber - 100
         };
     }
-    if (sharedPackageJson !== undefined) {
-        reporter.log(`Running npm install to make sure all dependencies are up to date`);
-        await execAsync(`npm install`, {
-            encoding: "utf-8",
-            cwd: workspace.path
-        });
-    }
+    // if (sharedPackageJson !== undefined) {
+    // 	reporter.log(
+    // 		`Running npm install to make sure all dependencies are up to date`,
+    // 	);
+    // 	await execAsync(`npm install`, {
+    // 		encoding: "utf-8",
+    // 		cwd: workspace.path,
+    // 	});
+    // }
     const binDir = options.outDir ?? getWorkspaceOutputPath(workspace);
     await fs$1.mkdir(binDir, {
         recursive: true
@@ -2184,7 +2254,9 @@ const releaseFolder = async (options)=>{
             }
         } else {
             const gitVersionInformation = await getVersionInformationFromGit(workspace, location);
-            writeVersionFile(fullPackageName, newVersion);
+            if (versionFile.exists) {
+                versionFile.write(fullPackageName, newVersion);
+            }
             const bannerText = sharedPackageJson !== undefined ? getWorkspaceBannerText(sharedPackageJson) : undefined;
             await buildFolders({
                 ...options,
@@ -2271,7 +2343,7 @@ const releaseFolder = async (options)=>{
             }
         }
     } catch (err) {
-        resetVersionFile();
+        versionFile.reset();
         throw err;
     }
     if (newVersion.buildNumber >= 100 && !options.pushOnly) {
@@ -2289,64 +2361,91 @@ const releaseFolder = async (options)=>{
  * 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  }) {
-    const files = getPackageTypescriptFiles(location);
-    const filtered = files.filter((path)=>{
-        return !ignore.some((suffix)=>path.endsWith(suffix));
-    });
+ */ function generateIndex({ location, ignore = [], strictOptional = false }) {
     const arr = [];
     const existingIndex = readPackageCreatorIndex(location) ?? [];
-    const program = ts.createProgram(filtered, {
-        allowJs: true
-    });
+    const manifest = readPackageCreatorManifest(location);
+    const compilerOptions = readScriptPackageTSConfig(location).options;
+    const isModule = compilerOptions.module === ts.ModuleKind.ES2015 || compilerOptions.module === ts.ModuleKind.ESNext;
+    const files = getPackageTypescriptFiles(location).filter((path)=>!ignore.some((suffix)=>path.endsWith(suffix)));
+    let program;
+    let namespaces;
+    if (isModule) {
+        const entryFilePath = resolveScriptPackageEntryModule(location, manifest);
+        if (entryFilePath === undefined) {
+            throw new Error(`Could not resolve entry module`);
+        }
+        const host = ts.createCompilerHost({}, true);
+        program = ts.createProgram([
+            entryFilePath
+        ], {
+            allowJs: true,
+            ...compilerOptions
+        }, host);
+        const entryFile = program.getSourceFile(entryFilePath);
+        if (entryFile === undefined) {
+            throw new Error(`Failed to find entry module`);
+        }
+        namespaces = resolveNamespaces(entryFile, program, host, manifest.Scope ?? manifest.Package);
+    } else {
+        program = ts.createProgram(files, {
+            allowJs: true
+        });
+        namespaces = [];
+    }
     const typeChecker = program.getTypeChecker();
-    filtered.forEach((file)=>{
+    files.forEach((file)=>{
         // Create a Program to represent the project, then pull out the
         // source file to parse its AST.
         const sourceFile = program.getSourceFile(file);
+        const namespace = namespaces.find((namespace)=>namespace.files.includes(sourceFile));
         // Loop through the root AST nodes of the file
-        ts.forEachChild(sourceFile, (node)=>{
-            for (const scriptingClass of findScriptingClasses(node)){
-                if (scriptingClass.node.name === undefined) {
-                    throw new Error(`Expected ${scriptingClass.type} class to have a name`);
-                }
-                const name = typeChecker.getFullyQualifiedName(typeChecker.getSymbolAtLocation(scriptingClass.node.name));
-                if (name.length > 45) {
-                    throw new Error(`Package name length >45 '${name}'`);
-                }
-                const parameterDeclaration = getScriptingClassParameterdeclaration(scriptingClass);
-                const parametersType = parameterDeclaration === undefined ? undefined : typeChecker.getTypeAtLocation(parameterDeclaration);
-                if (parametersType === undefined) {
-                    console.log(`Failed to find parameters type declaration for ${scriptingClass.type} ${name}. Skipping parameter list generation`);
-                }
-                const existingIndexEntry = existingIndex.find((entry)=>entry.Name === name);
-                const obj = {
-                    Name: name,
-                    Description: (existingIndexEntry == null ? void 0 : existingIndexEntry.Description) ?? name,
-                    Type: scriptingClass.type === "evaluator" ? "Evaluator" : "Interactor",
-                    Parameters: []
-                };
-                const rawDocTags = ts.getJSDocTags(scriptingClass.node);
-                const dict = getTagDict(rawDocTags);
-                if (dict.summary) {
-                    obj.Description = dict.summary;
-                } else {
-                    const comment = typeChecker.getTypeAtLocation(scriptingClass.node).symbol.getDocumentationComment(typeChecker).map((comment)=>comment.text).join(" ");
-                    if (comment) {
-                        obj.Description = comment;
-                    }
+        for (const scriptingClass of findScriptingClasses(sourceFile)){
+            if (scriptingClass.node.name === undefined) {
+                throw new Error(`Expected ${scriptingClass.type} class to have a name`);
+            }
+            let name;
+            if (isModule && namespace !== undefined) {
+                const moduleNamespace = resolveNamespaceFullName(namespace);
+                name = `${moduleNamespace}.${scriptingClass.node.name.text}`;
+            } else {
+                name = typeChecker.getFullyQualifiedName(typeChecker.getSymbolAtLocation(scriptingClass.node.name));
+            }
+            if (name.length > 45) {
+                throw new Error(`Package name length >45 '${name}'`);
+            }
+            const parameterDeclaration = getScriptingClassParameterdeclaration(scriptingClass);
+            const parametersType = parameterDeclaration === undefined ? undefined : typeChecker.getTypeAtLocation(parameterDeclaration);
+            if (parametersType === undefined) {
+                console.log(`Failed to find parameters type declaration for ${scriptingClass.type} ${name}. Skipping parameter list generation`);
+            }
+            const existingIndexEntry = existingIndex.find((entry)=>entry.Name === name);
+            const obj = {
+                Name: name,
+                Description: (existingIndexEntry == null ? void 0 : existingIndexEntry.Description) ?? name,
+                Type: scriptingClass.type === "evaluator" ? "Evaluator" : "Interactor",
+                Parameters: []
+            };
+            const rawDocTags = ts.getJSDocTags(scriptingClass.node);
+            const dict = getTagDict(rawDocTags);
+            if (dict.summary) {
+                obj.Description = dict.summary;
+            } else {
+                const comment = typeChecker.getTypeAtLocation(scriptingClass.node).symbol.getDocumentationComment(typeChecker).map((comment)=>comment.text).join(" ");
+                if (comment) {
+                    obj.Description = comment;
                 }
-                if (parametersType !== undefined) {
-                    obj.Parameters = parseParametersList(typeChecker.getPropertiesOfType(parametersType), strictOptional);
-                    if (obj.Parameters.length === 0 && parametersType.getStringIndexType() !== undefined) {
-                        obj.Parameters = (existingIndexEntry == null ? void 0 : existingIndexEntry.Parameters) ?? [];
-                    }
-                } else if (existingIndexEntry !== undefined) {
-                    obj.Parameters = existingIndexEntry.Parameters;
+            }
+            if (parametersType !== undefined) {
+                obj.Parameters = parseParametersList(typeChecker.getPropertiesOfType(parametersType), strictOptional);
+                if (obj.Parameters.length === 0 && parametersType.getStringIndexType() !== undefined) {
+                    obj.Parameters = (existingIndexEntry == null ? void 0 : existingIndexEntry.Parameters) ?? [];
                 }
-                arr.push(obj);
+            } else if (existingIndexEntry !== undefined) {
+                obj.Parameters = existingIndexEntry.Parameters;
             }
-        });
+            arr.push(obj);
+        }
     });
     arr.sort((a, b)=>a.Name.localeCompare(b.Name));
     writePackageCreatorIndex(location, arr);
@@ -2509,28 +2608,18 @@ const isScriptingClassParameterDeclaration = (scriptingClass, memberNode, parame
  *
  * @param {ts.Node} node
  * @return {*}
- */ const findScriptingClasses = (node)=>{
-    let body;
-    if (ts.isModuleDeclaration(node)) {
-        body = node.body;
-    }
-    if (body !== undefined && ts.isModuleDeclaration(body)) {
-        body = body.body;
-    }
-    const classes = [];
-    if (body !== undefined) {
-        ts.forEachChild(body, (child)=>{
-            if (!ts.isClassDeclaration(child)) {
-                return;
-            }
-            const scriptingClass = detectScriptingClass(child);
-            if (scriptingClass !== undefined) {
-                classes.push(scriptingClass);
-            }
-        });
+ */ function* findScriptingClasses(node) {
+    for (const child of node.getChildren()){
+        if (!ts.isClassDeclaration(child)) {
+            yield* findScriptingClasses(child);
+            continue;
+        }
+        const scriptingClass = detectScriptingClass(child);
+        if (scriptingClass !== undefined) {
+            yield scriptingClass;
+        }
     }
-    return classes;
-};
+}
 const detectScriptingClass = (node)=>{
     var _node_heritageClauses, _node_heritageClauses1;
     const isEvaluator = (_node_heritageClauses = node.heritageClauses) == null ? void 0 : _node_heritageClauses.some((clause)=>{
@@ -2559,5 +2648,5 @@ const detectScriptingClass = (node)=>{
     }
 };
 
-export { buildFolders, buildFoldersWatch, createAssetServiceSessionManager, generateIndex, releaseFolder, synchronizeDependencies };
+export { buildFolders, buildFoldersWatch, createAssetServiceSessionManager, generateIndex, isScriptPackageModules, readScriptPackageTSConfig, releaseFolder, resolveScriptPackageEntryModule, synchronizeDependencies };
 //# sourceMappingURL=lib.mjs.map