@platforma-sdk/tengo-builder 2.4.24 → 2.4.26

package/dist/compiler/compiler.cjs

@@ -1,317 +1,244 @@
-'use strict';
+const require_util = require('./util.cjs');
+const require_package = require('./package.cjs');
+const require_template = require('./template.cjs');
+const require_artifactset = require('./artifactset.cjs');
+const require_compileroptions = require('./compileroptions.cjs');
 
-var template = require('./template.cjs');
-var _package = require('./package.cjs');
-var artifactset = require('./artifactset.cjs');
-var util = require('./util.cjs');
-var compileroptions = require('./compileroptions.cjs');
-
-class TengoTemplateCompiler {
-    compileMode;
-    libs = new artifactset.ArtifactStore((src) => src.fullName);
-    software = new artifactset.ArtifactStore((src) => src.fullName);
-    assets = new artifactset.ArtifactStore((src) => src.fullName);
-    templates = new artifactset.ArtifactStore((tpl) => tpl.fullName);
-    constructor(compileMode) {
-        this.compileMode = compileMode;
-    }
-    /** Recursively add dependencies to the template. */
-    populateTemplateDataFromDependencies(fullName, data, deps, trace) {
-        for (const dep of deps) {
-            switch (dep.type) {
-                case "library": {
-                    const lib = this.getLibOrError(dep);
-                    const recursionStart = trace.indexOf(_package.artifactNameToString(dep));
-                    if (recursionStart >= 0) {
-                        const errorMessage = `library import recursion detected: ` +
-                            `${trace.slice(recursionStart).join(" -> ")} -> ${_package.artifactNameToString(dep)}`;
-                        throw new Error(errorMessage);
-                    }
-                    const tplLib = {
-                        ..._package.formatArtefactNameAndVersion(lib.fullName),
-                        sourceHash: lib.sourceHash,
-                    };
-                    compileroptions.applyLibraryCompilerOptions(lib.compilerOptions);
-                    data.template.libs[_package.artifactNameToString(dep)] = tplLib;
-                    data.hashToSource[tplLib.sourceHash] = lib.src;
-                    // populate with transient library dependencies
-                    this.populateTemplateDataFromDependencies(fullName, data, lib.dependencies, [
-                        ...trace,
-                        _package.artifactNameToString(dep),
-                    ]);
-                    break;
-                }
-                case "software": {
-                    const software = this.getSoftwareOrError(dep);
-                    data.template.software[_package.artifactNameToString(dep)] = {
-                        ..._package.formatArtefactNameAndVersion(software.fullName),
-                        sourceHash: software.sourceHash,
-                    };
-                    data.hashToSource[software.sourceHash] = software.src;
-                    break;
-                }
-                case "asset": {
-                    const asset = this.getAssetOrError(dep);
-                    // Yes, we temporarily put assets into 'software' section of template, so controller can
-                    // handle it the right way without updates
-                    data.template.software[_package.artifactNameToString(dep)] = {
-                        ..._package.formatArtefactNameAndVersion(asset.fullName),
-                        sourceHash: asset.sourceHash,
-                    };
-                    data.hashToSource[asset.sourceHash] = asset.src;
-                    break;
-                }
-                case "template": {
-                    if (_package.typedArtifactNamesEquals(fullName, dep))
-                        // skipping self reference
-                        continue;
-                    const tpl = this.getTemplateOrError(dep);
-                    data.template.templates[_package.artifactNameToString(dep)] = tpl.data.template;
-                    data.hashToSource[tpl.data.template.sourceHash] = tpl.source;
-                    // add all the sources of transitivedependencies to the resulted hashToSource
-                    for (const [hash, src] of Object.entries(tpl.data.hashToSource)) {
-                        data.hashToSource[hash] = src;
-                    }
-                    break;
-                }
-                case "test":
-                    throw new Error(`dependencies tree error: tests should never be part of template: ` +
-                        `${_package.typedArtifactNameToString(dep)} is dependency of ${_package.artifactNameToString(fullName)}`);
-                default:
-                    util.assertNever(dep.type);
-            }
-        }
-    }
-    /** This method assumes that all dependencies are already added to the compiler's context */
-    compileAndAddTemplate(tplSrc) {
-        if (tplSrc.fullName.type !== "template")
-            throw new Error("unexpected source type");
-        // creating template with unpopulated dependencies
-        const tplData = {
-            type: "pl.tengo-template.v3",
-            hashToSource: {
-                [tplSrc.sourceHash]: tplSrc.src,
-            },
-            template: {
-                ..._package.formatArtefactNameAndVersion(tplSrc.fullName),
-                templates: {},
-                libs: {},
-                software: {},
-                assets: {},
-                sourceHash: tplSrc.sourceHash,
-            },
-        };
-        compileroptions.applyTemplateCompilerOptions(tplSrc.compilerOptions, tplData.template);
-        // collecting dependencies in output format
-        this.populateTemplateDataFromDependencies(tplSrc.fullName, tplData, tplSrc.dependencies, []);
-        return tplData;
-    }
-    addLib(lib) {
-        const libFromMap = this.libs.add(lib.compileMode, lib, false);
-        if (libFromMap && !_package.fullNameEquals(lib.fullName, libFromMap.fullName))
-            throw new Error(`compiler already contain such library: adding = ${_package.fullNameToString(lib.fullName)}, contains = ${_package.fullNameToString(libFromMap.fullName)}`);
-    }
-    allLibs() {
-        return this.libs.array(this.compileMode);
-    }
-    getLib(name) {
-        if (name.type !== "library")
-            throw new Error(`illegal artifact type: got ${name.type} instead of 'library`);
-        return this.libs.get(this.compileMode, name);
-    }
-    getLibOrError(name) {
-        const lib = this.getLib(name);
-        if (!lib)
-            throw new Error(`library not found: ${_package.artifactNameToString(name)}`);
-        return lib;
-    }
-    checkLibs() {
-        this.libs.forEach(this.compileMode, (lib) => {
-            for (const dep of lib.dependencies) {
-                if (dep.type === "test")
-                    throw new Error(`test should never be dependency of production code: ${_package.typedArtifactNameToString(dep)} test is dependency of ${_package.fullNameToString(lib.fullName)}`);
-                if (!this.getArtefact(dep))
-                    throw new Error(`unresolved dependency ${_package.typedArtifactNameToString(dep)} for ${_package.fullNameToString(lib.fullName)}`);
-            }
-        });
-    }
-    addSoftware(software) {
-        const swFromMap = this.software.add(software.compileMode, software, false);
-        if (swFromMap && !_package.fullNameEquals(software.fullName, swFromMap.fullName))
-            throw new Error(`compiler already contain info for software: adding = ${_package.fullNameToString(software.fullName)}, contains = ${_package.fullNameToString(swFromMap.fullName)}`);
-    }
-    allSoftware() {
-        return this.software.array(this.compileMode);
-    }
-    getSoftware(name) {
-        if (name.type !== "software")
-            throw new Error(`illegal artifact type: got ${name.type} instead of 'software`);
-        return this.software.get(this.compileMode, name);
-    }
-    getSoftwareOrError(name) {
-        const software = this.getSoftware(name);
-        if (!software)
-            throw new Error(`software info not found: ${_package.artifactNameToString(name)}`);
-        return software;
-    }
-    addAsset(asset) {
-        const assetFromMap = this.assets.add(asset.compileMode, asset, false);
-        if (assetFromMap && !_package.fullNameEquals(asset.fullName, assetFromMap.fullName))
-            throw new Error(`compiler already contain info for asset: adding = ${_package.fullNameToString(asset.fullName)}, contains = ${_package.fullNameToString(assetFromMap.fullName)}`);
-    }
-    allAssets() {
-        return this.assets.array(this.compileMode);
-    }
-    getAsset(name) {
-        if (name.type !== "asset")
-            throw new Error(`illegal artifact type: got ${name.type} instead of 'asset`);
-        return this.assets.get(this.compileMode, name);
-    }
-    getAssetOrError(name) {
-        const asset = this.getAsset(name);
-        if (!asset)
-            throw new Error(`asset info not found: ${_package.artifactNameToString(name)}`);
-        return asset;
-    }
-    addTemplate(tpl) {
-        const tplFromMap = this.templates.add(tpl.compileMode, tpl, false);
-        if (tplFromMap && !_package.fullNameEquals(tpl.fullName, tplFromMap.fullName))
-            throw new Error(`compiler already contain such template: adding = ${_package.fullNameToString(tpl.fullName)}, contains = ${_package.fullNameToString(tplFromMap.fullName)}`);
-    }
-    allTemplates() {
-        return this.templates.array(this.compileMode);
-    }
-    getTemplate(name) {
-        if (name.type !== "template")
-            throw new Error(`illegal artifact type: got ${name.type} instead of 'template`);
-        return this.templates.get(this.compileMode, name);
-    }
-    getTemplateOrError(name) {
-        const tpl = this.getTemplate(name);
-        if (!tpl)
-            throw new Error(`template not found: ${_package.artifactNameToString(name)}`);
-        return tpl;
-    }
-    getArtefact(name) {
-        switch (name.type) {
-            case "template":
-                return this.getTemplate(name);
-            case "library":
-                return this.getLib(name);
-            case "software":
-                return this.getSoftware(name);
-            case "asset":
-                return this.getAsset(name);
-            case "test":
-                // Tests are ignored by the complier. They should never be compiled into templates or libs and
-                // should never be a dependency.
-                return undefined;
-            default:
-                util.assertNever(name.type);
-        }
-    }
-    compileAndAdd(sources) {
-        const result = {
-            templates: [],
-            libs: [],
-            software: [],
-            assets: [],
-        };
-        let current = [];
-        for (const src of sources) {
-            if (src.fullName.type === "library") {
-                // add libraries 'as-is' to be able to resolve them as dependencies
-                this.addLib(src);
-                result.libs.push(src);
-            }
-            else if (src.fullName.type === "software") {
-                // add software 'as-is' to be able to resolve them as dependencies
-                this.addSoftware(src);
-                result.software.push(src);
-            }
-            else if (src.fullName.type === "asset") {
-                // add assets 'as-is' to be able to resolve them as dependencies
-                this.addAsset(src);
-                result.assets.push(src);
-            }
-            else {
-                current.push(src);
-            }
-        }
-        while (current.length > 0) {
-            const unprocessed = [];
-            for (const src of current) {
-                //
-                // If one of the dependencies can't be resolved with current compiler context,
-                // we put aside the source until next iteration, in hope that the dependency
-                // will be satisfied then.
-                //
-                // This is equivalent to topological sorting of input sources.
-                //
-                const unsatisfied = src.dependencies.filter((dep) => !this.getArtefact(dep) &&
-                    // allow self reference for templates
-                    !(src.fullName.type === "template" && _package.typedArtifactNamesEquals(src.fullName, dep)));
-                if (unsatisfied.length > 0) {
-                    let errorMessage = `Unsatisfied dependencies in ${_package.fullNameToString(src.fullName)}:\n`;
-                    for (const dep of unsatisfied) {
-                        errorMessage += `  - ${_package.typedArtifactNameToString(dep)}\n`;
-                    }
-                    unprocessed.push({ src, err: new Error(errorMessage) });
-                    continue;
-                }
-                // type specific processing
-                switch (src.fullName.type) {
-                    case "library":
-                        // libraries are added as is
-                        this.addLib(src);
-                        result.libs.push(src);
-                        break;
-                    case "software":
-                        // software dependencies are added as is
-                        this.addSoftware(src);
-                        result.software.push(src);
-                        break;
-                    case "asset":
-                        // software dependencies are added as is
-                        this.addAsset(src);
-                        result.assets.push(src);
-                        break;
-                    case "template":
-                        // templates are compiled and then added
-                        try {
-                            const tpl = this.compileAndAddTemplate(src);
-                            const tplWithSrc = template.newTemplateWithSource(src.compileMode, src.fullName, tpl, src.src);
-                            this.addTemplate(tplWithSrc);
-                            result.templates.push(tplWithSrc);
-                        }
-                        catch (error) {
-                            const err = error;
-                            let errorMessage = `Unsatisfied dependencies in ${_package.fullNameToString(src.fullName)}:\n`;
-                            errorMessage += `  - ${err.message}\n`;
-                            unprocessed.push({ src, err: Error(errorMessage) }); // one or more dependencies are not resolvable yet
-                        }
-                        break;
-                    case "test":
-                        // Ignore tests: they never should be part of compiled code or be a dependency.
-                        break;
-                    default:
-                        util.assertNever(src.fullName.type);
-                }
-            }
-            // checking that we successfully added at least one source,
-            // if not all the source files in unprocessed array have unmet dependencies
-            if (current.length === unprocessed.length) {
-                let errorMessage = "";
-                for (const u of unprocessed) {
-                    errorMessage += `\n${u.err.message}`;
-                }
-                throw new Error(errorMessage);
-            }
-            current = unprocessed.map(({ src: ArtifactSource }) => ArtifactSource);
-        }
-        return result;
-    }
-}
+//#region src/compiler/compiler.ts
+var TengoTemplateCompiler = class {
+	libs = new require_artifactset.ArtifactStore((src) => src.fullName);
+	software = new require_artifactset.ArtifactStore((src) => src.fullName);
+	assets = new require_artifactset.ArtifactStore((src) => src.fullName);
+	templates = new require_artifactset.ArtifactStore((tpl) => tpl.fullName);
+	constructor(compileMode) {
+		this.compileMode = compileMode;
+	}
+	/** Recursively add dependencies to the template. */
+	populateTemplateDataFromDependencies(fullName, data, deps, trace) {
+		for (const dep of deps) switch (dep.type) {
+			case "library": {
+				const lib = this.getLibOrError(dep);
+				const recursionStart = trace.indexOf(require_package.artifactNameToString(dep));
+				if (recursionStart >= 0) {
+					const errorMessage = `library import recursion detected: ${trace.slice(recursionStart).join(" -> ")} -> ${require_package.artifactNameToString(dep)}`;
+					throw new Error(errorMessage);
+				}
+				const tplLib = {
+					...require_package.formatArtefactNameAndVersion(lib.fullName),
+					sourceHash: lib.sourceHash
+				};
+				require_compileroptions.applyLibraryCompilerOptions(lib.compilerOptions, tplLib);
+				data.template.libs[require_package.artifactNameToString(dep)] = tplLib;
+				data.hashToSource[tplLib.sourceHash] = lib.src;
+				this.populateTemplateDataFromDependencies(fullName, data, lib.dependencies, [...trace, require_package.artifactNameToString(dep)]);
+				break;
+			}
+			case "software": {
+				const software = this.getSoftwareOrError(dep);
+				data.template.software[require_package.artifactNameToString(dep)] = {
+					...require_package.formatArtefactNameAndVersion(software.fullName),
+					sourceHash: software.sourceHash
+				};
+				data.hashToSource[software.sourceHash] = software.src;
+				break;
+			}
+			case "asset": {
+				const asset = this.getAssetOrError(dep);
+				data.template.software[require_package.artifactNameToString(dep)] = {
+					...require_package.formatArtefactNameAndVersion(asset.fullName),
+					sourceHash: asset.sourceHash
+				};
+				data.hashToSource[asset.sourceHash] = asset.src;
+				break;
+			}
+			case "template": {
+				if (require_package.typedArtifactNamesEquals(fullName, dep)) continue;
+				const tpl = this.getTemplateOrError(dep);
+				data.template.templates[require_package.artifactNameToString(dep)] = tpl.data.template;
+				data.hashToSource[tpl.data.template.sourceHash] = tpl.source;
+				for (const [hash, src] of Object.entries(tpl.data.hashToSource)) data.hashToSource[hash] = src;
+				break;
+			}
+			case "test": throw new Error(`dependencies tree error: tests should never be part of template: ${require_package.typedArtifactNameToString(dep)} is dependency of ${require_package.artifactNameToString(fullName)}`);
+			default: require_util.assertNever(dep.type);
+		}
+	}
+	/** This method assumes that all dependencies are already added to the compiler's context */
+	compileAndAddTemplate(tplSrc) {
+		if (tplSrc.fullName.type !== "template") throw new Error("unexpected source type");
+		const tplData = {
+			type: "pl.tengo-template.v3",
+			hashToSource: { [tplSrc.sourceHash]: tplSrc.src },
+			template: {
+				...require_package.formatArtefactNameAndVersion(tplSrc.fullName),
+				templates: {},
+				libs: {},
+				software: {},
+				assets: {},
+				sourceHash: tplSrc.sourceHash
+			}
+		};
+		require_compileroptions.applyTemplateCompilerOptions(tplSrc.compilerOptions, tplData.template);
+		this.populateTemplateDataFromDependencies(tplSrc.fullName, tplData, tplSrc.dependencies, []);
+		return tplData;
+	}
+	addLib(lib) {
+		const libFromMap = this.libs.add(lib.compileMode, lib, false);
+		if (libFromMap && !require_package.fullNameEquals(lib.fullName, libFromMap.fullName)) throw new Error(`compiler already contain such library: adding = ${require_package.fullNameToString(lib.fullName)}, contains = ${require_package.fullNameToString(libFromMap.fullName)}`);
+	}
+	allLibs() {
+		return this.libs.array(this.compileMode);
+	}
+	getLib(name) {
+		if (name.type !== "library") throw new Error(`illegal artifact type: got ${name.type} instead of 'library`);
+		return this.libs.get(this.compileMode, name);
+	}
+	getLibOrError(name) {
+		const lib = this.getLib(name);
+		if (!lib) throw new Error(`library not found: ${require_package.artifactNameToString(name)}`);
+		return lib;
+	}
+	checkLibs() {
+		this.libs.forEach(this.compileMode, (lib) => {
+			for (const dep of lib.dependencies) {
+				if (dep.type === "test") throw new Error(`test should never be dependency of production code: ${require_package.typedArtifactNameToString(dep)} test is dependency of ${require_package.fullNameToString(lib.fullName)}`);
+				if (!this.getArtefact(dep)) throw new Error(`unresolved dependency ${require_package.typedArtifactNameToString(dep)} for ${require_package.fullNameToString(lib.fullName)}`);
+			}
+		});
+	}
+	addSoftware(software) {
+		const swFromMap = this.software.add(software.compileMode, software, false);
+		if (swFromMap && !require_package.fullNameEquals(software.fullName, swFromMap.fullName)) throw new Error(`compiler already contain info for software: adding = ${require_package.fullNameToString(software.fullName)}, contains = ${require_package.fullNameToString(swFromMap.fullName)}`);
+	}
+	allSoftware() {
+		return this.software.array(this.compileMode);
+	}
+	getSoftware(name) {
+		if (name.type !== "software") throw new Error(`illegal artifact type: got ${name.type} instead of 'software`);
+		return this.software.get(this.compileMode, name);
+	}
+	getSoftwareOrError(name) {
+		const software = this.getSoftware(name);
+		if (!software) throw new Error(`software info not found: ${require_package.artifactNameToString(name)}`);
+		return software;
+	}
+	addAsset(asset) {
+		const assetFromMap = this.assets.add(asset.compileMode, asset, false);
+		if (assetFromMap && !require_package.fullNameEquals(asset.fullName, assetFromMap.fullName)) throw new Error(`compiler already contain info for asset: adding = ${require_package.fullNameToString(asset.fullName)}, contains = ${require_package.fullNameToString(assetFromMap.fullName)}`);
+	}
+	allAssets() {
+		return this.assets.array(this.compileMode);
+	}
+	getAsset(name) {
+		if (name.type !== "asset") throw new Error(`illegal artifact type: got ${name.type} instead of 'asset`);
+		return this.assets.get(this.compileMode, name);
+	}
+	getAssetOrError(name) {
+		const asset = this.getAsset(name);
+		if (!asset) throw new Error(`asset info not found: ${require_package.artifactNameToString(name)}`);
+		return asset;
+	}
+	addTemplate(tpl) {
+		const tplFromMap = this.templates.add(tpl.compileMode, tpl, false);
+		if (tplFromMap && !require_package.fullNameEquals(tpl.fullName, tplFromMap.fullName)) throw new Error(`compiler already contain such template: adding = ${require_package.fullNameToString(tpl.fullName)}, contains = ${require_package.fullNameToString(tplFromMap.fullName)}`);
+	}
+	allTemplates() {
+		return this.templates.array(this.compileMode);
+	}
+	getTemplate(name) {
+		if (name.type !== "template") throw new Error(`illegal artifact type: got ${name.type} instead of 'template`);
+		return this.templates.get(this.compileMode, name);
+	}
+	getTemplateOrError(name) {
+		const tpl = this.getTemplate(name);
+		if (!tpl) throw new Error(`template not found: ${require_package.artifactNameToString(name)}`);
+		return tpl;
+	}
+	getArtefact(name) {
+		switch (name.type) {
+			case "template": return this.getTemplate(name);
+			case "library": return this.getLib(name);
+			case "software": return this.getSoftware(name);
+			case "asset": return this.getAsset(name);
+			case "test": return;
+			default: require_util.assertNever(name.type);
+		}
+	}
+	compileAndAdd(sources) {
+		const result = {
+			templates: [],
+			libs: [],
+			software: [],
+			assets: []
+		};
+		let current = [];
+		for (const src of sources) if (src.fullName.type === "library") {
+			this.addLib(src);
+			result.libs.push(src);
+		} else if (src.fullName.type === "software") {
+			this.addSoftware(src);
+			result.software.push(src);
+		} else if (src.fullName.type === "asset") {
+			this.addAsset(src);
+			result.assets.push(src);
+		} else current.push(src);
+		while (current.length > 0) {
+			const unprocessed = [];
+			for (const src of current) {
+				const unsatisfied = src.dependencies.filter((dep) => !this.getArtefact(dep) && !(src.fullName.type === "template" && require_package.typedArtifactNamesEquals(src.fullName, dep)));
+				if (unsatisfied.length > 0) {
+					let errorMessage = `Unsatisfied dependencies in ${require_package.fullNameToString(src.fullName)}:\n`;
+					for (const dep of unsatisfied) errorMessage += `  - ${require_package.typedArtifactNameToString(dep)}\n`;
+					unprocessed.push({
+						src,
+						err: new Error(errorMessage)
+					});
+					continue;
+				}
+				switch (src.fullName.type) {
+					case "library":
+						this.addLib(src);
+						result.libs.push(src);
+						break;
+					case "software":
+						this.addSoftware(src);
+						result.software.push(src);
+						break;
+					case "asset":
+						this.addAsset(src);
+						result.assets.push(src);
+						break;
+					case "template":
+						try {
+							const tpl = this.compileAndAddTemplate(src);
+							const tplWithSrc = require_template.newTemplateWithSource(src.compileMode, src.fullName, tpl, src.src);
+							this.addTemplate(tplWithSrc);
+							result.templates.push(tplWithSrc);
+						} catch (error) {
+							const err = error;
+							let errorMessage = `Unsatisfied dependencies in ${require_package.fullNameToString(src.fullName)}:\n`;
+							errorMessage += `  - ${err.message}\n`;
+							unprocessed.push({
+								src,
+								err: Error(errorMessage)
+							});
+						}
+						break;
+					case "test": break;
+					default: require_util.assertNever(src.fullName.type);
+				}
+			}
+			if (current.length === unprocessed.length) {
+				let errorMessage = "";
+				for (const u of unprocessed) errorMessage += `\n${u.err.message}`;
+				throw new Error(errorMessage);
+			}
+			current = unprocessed.map(({ src: ArtifactSource }) => ArtifactSource);
+		}
+		return result;
+	}
+};
 
+//#endregion
 exports.TengoTemplateCompiler = TengoTemplateCompiler;
-//# sourceMappingURL=compiler.cjs.map
+//# sourceMappingURL=compiler.cjs.map