@ui5/webcomponents-tools 0.0.0-037d08c67

package/lib/generate-json-imports/i18n.js

@@ -0,0 +1,93 @@
+const fs = require("fs").promises;
+const path = require('path');
+
+const isTypeScript = process.env.UI5_TS;
+const ext = isTypeScript ? 'ts' : 'js';
+
+
+const getContent = function(caseLines, languagesKeysStringArray, packageName) {
+	return `// @ts-nocheck
+import { registerI18nLoader } from "@ui5/webcomponents-base/dist/asset-registries/i18n.js";
+
+const importMessageBundle = async (localeId) => {
+	switch (localeId) {
+		${caseLines}
+		default: throw "unknown locale"
+	}
+}
+
+const importAndCheck = async (localeId) => {
+	const data = await importMessageBundle(localeId);
+	if (typeof data === "string" && data.endsWith(".json")) {
+		throw new Error(\`[i18n] Invalid bundling detected - dynamic JSON imports bundled as URLs. Switch to inlining JSON files from the build. Check the \"Assets\" documentation for more information.\`);
+	}
+	return data;
+}
+
+const localeIds = [${languagesKeysStringArray}];
+
+localeIds.forEach(localeId => {
+	registerI18nLoader(${ packageName.split("").map(c => `"${c}"`).join (" + ") }, localeId, importAndCheck);
+});
+`;
+}
+
+const generate = async (argv) => {
+
+	const packageName = JSON.parse(await fs.readFile("package.json")).name;
+
+	const inputFolder = path.normalize(argv[2]);
+	const outputFileDynamic = path.normalize(`${argv[3]}/i18n.${ext}`);
+	const outputFileFetchMetaResolve = path.normalize(`${argv[3]}/i18n-fetch.${ext}`);
+	const outputFileDynamicImportJSONImport = path.normalize(`${argv[3]}/i18n-node.${ext}`);
+
+	// All languages present in the file system
+	const files = await fs.readdir(inputFolder);
+	const languages = files.map(file => {
+		const matches = file.match(/messagebundle_(.+?).properties$/);
+		return matches ? matches[1] : undefined;
+	}).filter(key => !!key);
+
+	let contentDynamic;
+	let contentFetchMetaResolve;
+	let contentDynamicImportJSONAttr;
+
+	// No i18n - just import dependencies, if any
+	if (languages.length === 0) {
+		contentDynamic = "";
+		contentFetchMetaResolve = "";
+		contentDynamicImportJSONAttr = "";
+	// There is i18n - generate the full file
+	} else {
+		// Keys for the array
+		const languagesKeysStringArray = languages.map(key => `"${key}",`).join("\n\t");
+
+		// Actual imports for json assets
+		const dynamicImportsString = languages.map(key => `		case "${key}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-messagebundle-${key}" */ "../assets/i18n/messagebundle_${key}.json")).default;`).join("\n");
+		const fetchMetaResolveString = languages.map(key => `		case "${key}": return (await fetch(new URL("../assets/i18n/messagebundle_${key}.json", import.meta.url))).json();`).join("\n");
+		const dynamicImportJSONAttrString = languages.map(key => `		case "${key}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-messagebundle-${key}" */ "../assets/i18n/messagebundle_${key}.json", {with: { type: 'json'}})).default;`).join("\n");
+
+		// Resulting file content
+
+		contentDynamic = getContent(dynamicImportsString, languagesKeysStringArray, packageName);
+		contentFetchMetaResolve = getContent(fetchMetaResolveString, languagesKeysStringArray, packageName);
+		contentDynamicImportJSONAttr = getContent(dynamicImportJSONAttrString, languagesKeysStringArray, packageName);
+	}
+
+	await fs.mkdir(path.dirname(outputFileDynamic), { recursive: true });
+	return Promise.all([
+		fs.writeFile(outputFileDynamic, contentDynamic),
+		fs.writeFile(outputFileFetchMetaResolve, contentFetchMetaResolve),
+		fs.writeFile(outputFileDynamicImportJSONImport, contentDynamicImportJSONAttr),
+	]).then(() => {
+		if (process.env.UI5_VERBOSE === "true") {
+			console.log("Generated i18n JSON imports.");
+		}
+	});
+}
+
+if (require.main === module) {
+	generate(process.argv)
+}
+
+exports._ui5mainFn = generate;

package/lib/generate-json-imports/themes.js

@@ -0,0 +1,75 @@
+const fs = require("fs").promises;
+const path = require('path');
+const assets = require("../../assets-meta.js");
+
+const isTypeScript = process.env.UI5_TS;
+const ext = isTypeScript ? 'ts' : 'js';
+
+const CSS_VARIABLES_TARGET = process.env.CSS_VARIABLES_TARGET === "host";
+
+const generate = async (argv) => {
+	const inputFolder = path.normalize(argv[2]);
+	const outputFileDynamic = path.normalize(`${argv[3]}/Themes.${ext}`);
+	const outputFileDynamicImportJSONAttr = path.normalize(`${argv[3]}/Themes-node.${ext}`);
+	const outputFileFetchMetaResolve = path.normalize(`${argv[3]}/Themes-fetch.${ext}`);
+
+	// All supported optional themes
+	const allThemes = assets.themes.all;
+
+	// All themes present in the file system
+	const dirs = await fs.readdir(inputFolder);
+	const themesOnFileSystem = dirs.map(dir => {
+		const matches = dir.match(/sap_.*$/);
+		return matches ? dir : undefined;
+	}).filter(key => !!key && allThemes.includes(key));
+
+	const packageName = JSON.parse(await fs.readFile("package.json")).name;
+
+	const availableThemesArray = `[${themesOnFileSystem.map(theme => `"${theme}"`).join(", ")}]`;
+	const dynamicImportLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-${theme.replace("_", "-")}-parameters-bundle" */"../assets/themes/${theme}/parameters-bundle.css.json")).default;`).join("\n");
+	const dynamicImportJSONAttrLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await import(/* webpackChunkName: "${packageName.replace("@", "").replace("/", "-")}-${theme.replace("_", "-")}-parameters-bundle" */"../assets/themes/${theme}/parameters-bundle.css.json", {with: { type: 'json'}})).default;`).join("\n");
+	const fetchMetaResolveLines = themesOnFileSystem.map(theme => `\t\tcase "${theme}": return (await fetch(new URL("../assets/themes/${theme}/parameters-bundle.css.json", import.meta.url))).json();`).join("\n");
+
+	// dynamic imports file content
+	const contentDynamic = function (lines) {
+		return `// @ts-nocheck
+import { registerThemePropertiesLoader } from "@ui5/webcomponents-base/dist/asset-registries/Themes.js";
+
+const loadThemeProperties = async (themeName) => {
+	switch (themeName) {
+${lines}
+		default: throw "unknown theme"
+	}
+};
+
+const loadAndCheck = async (themeName) => {
+	const data = await loadThemeProperties(themeName);
+	if (typeof data === "string" && data.endsWith(".json")) {
+		throw new Error(\`[themes] Invalid bundling detected - dynamic JSON imports bundled as URLs. Switch to inlining JSON files from the build. Check the \"Assets\" documentation for more information.\`);
+	}
+	return data;
+};
+
+${availableThemesArray}
+  .forEach(themeName => registerThemePropertiesLoader(${packageName.split("").map(c => `"${c}"`).join(" + ")}, themeName, loadAndCheck${CSS_VARIABLES_TARGET ? ', "host"' : ''}));
+`;
+	}
+
+	await fs.mkdir(path.dirname(outputFileDynamic), { recursive: true });
+	return Promise.all([
+		fs.writeFile(outputFileDynamic, contentDynamic(dynamicImportLines)),
+		fs.writeFile(outputFileDynamicImportJSONAttr, contentDynamic(dynamicImportJSONAttrLines)),
+		fs.writeFile(outputFileFetchMetaResolve, contentDynamic(fetchMetaResolveLines)),
+	]).
+		then(() => {
+			if (process.env.UI5_VERBOSE === "true") {
+				console.log("Generated themes JSON imports.");
+			}
+		})
+};
+
+if (require.main === module) {
+	generate(process.argv)
+}
+
+exports._ui5mainFn = generate;

package/lib/hbs2lit/index.js

@@ -0,0 +1,3 @@
+const hbs2lit = require("./src/compiler");
+
+module.exports = hbs2lit;

package/lib/hbs2lit/src/compiler.js

@@ -0,0 +1,60 @@
+const HTMLLitVisitor = require("./litVisitor2");
+const PartialsVisitor = require("./partialsVisitor");
+const Handlebars = require("handlebars/dist/handlebars.min.js");
+const includesReplacer = require("./includesReplacer");
+const svgProcessor = require("./svgProcessor");
+
+const removeWhiteSpaces = (source) => {
+	return source
+		.replace(/\s*\r*\n+\s*/g, " ") // Replace new lines and all whitespace between them with a space
+		.replace(/\s*<\s*/g, "<") // Strip whitespace round <
+		.replace(/\s*>\s*/g, ">") // Strip whitespace round >
+		.replace(/}}\s+{{/g, "}}{{"); // Remove whitespace between }} and {{
+};
+
+const hbs2lit = async (file, componentName) => {
+	let sPreprocessed = await includesReplacer.replace(file);
+
+	sPreprocessed = removeWhiteSpaces(sPreprocessed);
+
+	const blockSignature = process.env.UI5_TS ? `this: ${componentName}` : ""
+
+	// icons hack
+	if (sPreprocessed.startsWith("<g ") || sPreprocessed.startsWith("<g>")) {
+		return `
+		function block0 (${blockSignature}) {
+			return svg\`${sPreprocessed}\`
+		}`;
+	}
+
+	const ast = Handlebars.parse(sPreprocessed);
+
+	const pv = new PartialsVisitor();
+	const lv = new HTMLLitVisitor(componentName);
+
+	let result = "";
+
+	pv.accept(ast);
+	pv.modify(ast);
+
+	lv.accept(ast);
+
+	for (let key in lv.blocks) {
+		let block = lv.blocks[key];
+
+		if (block.match(/scopeTag/)) {
+			// const matches = block.match(/^(.*?)( => )(.*?);$/);
+			const matches = block.match(/^(function .*? \{ return )(.*?);\}$/);
+			const scopedCode = matches[2];
+			const normalCode = scopedCode.replace(/\${scopeTag\("/g, "").replace(/", tags, suffix\)}/g, "");
+			block = `${matches[1]}suffix ? ${scopedCode} : ${normalCode};}`;
+		}
+
+		result += block + "\n";
+	}
+
+	result = svgProcessor.process(result);
+	return result;
+};
+
+module.exports = hbs2lit;

package/lib/hbs2lit/src/extendedAttributeMapping.js

@@ -0,0 +1,12 @@
+function replaceEqualities(hbs) {
+	// converts the boolean attributes to lit like boolean attributes
+	return hbs.replace(/(\s+)(disabled|hidden|checked|readonly)\s*=\s*/g, " ?$2 = ")
+	// maps all the propertis to attributes
+		.replace(/([a-zA-Z][\w\-]*?)\s*=\s*"{{/g, "$1 = \"{{")
+		// maps the value attribute to property
+		.replace(/(value\s*=)/g, ".value =");
+}
+
+module.exports = {
+	map: replaceEqualities
+};

package/lib/hbs2lit/src/includesReplacer.js

@@ -0,0 +1,31 @@
+const path = require("path");
+const fs = require("fs").promises;
+
+const replaceIncludes = async (file) => {
+	const filePath = path.dirname(file);
+	let fileContent = await fs.readFile(file, "utf-8");
+
+	const inclRegex = /{{>\s*include\s*["'](.+?)["']}}/g;
+	let match;
+
+	while((match = inclRegex.exec(fileContent)) !== null) {
+		inclRegex.lastIndex = 0;
+
+		let targetFile = match[1];
+		if (targetFile.startsWith(".")) {
+			// Relative path, f.e. {{>include "./Popup.hbs"}} or {{>include "../partials/Header.hbs"}}
+			targetFile = path.join(filePath, targetFile);
+		} else {
+			// Node module path, f.e. {{>include "@ui5/webcomponents/src/Popup.hbs"}}
+			targetFile = require.resolve(targetFile);
+		}
+
+		fileContent = fileContent.replace(match[0], await replaceIncludes(targetFile));
+	}
+
+	return fileContent;
+};
+
+module.exports = {
+	replace: replaceIncludes
+};

package/lib/hbs2lit/src/litVisitor2.js

@@ -0,0 +1,278 @@
+const Handlebars = require("handlebars/dist/handlebars.min.js");
+const path = require("path");
+const Visitor = Handlebars.Visitor;
+
+// skip ifDefined for event handlers and boolean attrs
+let skipIfDefined = false;
+
+// when true => an HTML node value, when false => an attribute value
+let isNodeValue = false;
+
+// when true => the current attribute is "style"
+let isStyleAttribute = false;
+
+// matches event handlers @click= and boolean attrs ?disabled=
+const dynamicAttributeRgx = /\s(\?|@)([a-zA-Z|-]+)="?\s*$/;
+
+if (!String.prototype.replaceAll) {
+	String.prototype.replaceAll = function(str, newStr){
+
+		// If a regex pattern
+		if (Object.prototype.toString.call(str).toLowerCase() === '[object regexp]') {
+			return this.replace(str, newStr);
+		}
+
+		// If a string
+		return this.replace(new RegExp(str, 'g'), newStr);
+
+	};
+}
+
+function HTMLLitVisitor(componentName, debug) {
+	this.blockCounter = 0;
+	this.keys = [];
+	this.blocks = {};
+	this.result = "";
+	this.mainBlock = "";
+	this.blockLevel = 0;
+	this.componentName = componentName
+	const blockParametersDefinitionTS = [`this: ${componentName}`, "context: UI5Element", "tags: string[]", "suffix: string | undefined"];
+	const blockParametersDefinitionJS = ["context", "tags", "suffix"];
+	this.blockParametersDefinition = process.env.UI5_TS ? blockParametersDefinitionTS : blockParametersDefinitionJS;
+	this.blockParametersUsage = ["this", "context", "tags", "suffix"];
+	this.paths = []; //contains all normalized relative paths
+	this.debug = debug;
+	if (this.debug) {
+		this.blockByNumber = [];
+	}
+}
+
+HTMLLitVisitor.prototype = new Visitor();
+
+HTMLLitVisitor.prototype.Program = function(program) {
+	let key = `block${this.blockCounter++}`;
+
+	this.keys.push(key);
+	this.debug && this.blockByNumber.push(key);
+
+	// this.blocks[this.currentKey()] = "function " + this.currentKey() + ` (this: any, ` + this.blockParametersDefinition.join(", ") + ") { ";
+	this.blocks[this.currentKey()] = `function ${this.currentKey()} (${this.blockParametersDefinition.join(", ")}) { `;
+
+	if (this.keys.length > 1) { //it's a nested block
+		this.blocks[this.prevKey()] += this.currentKey() + ".call(" + this.blockParametersUsage.join(", ") + ")";
+	} else {
+		this.mainBlock = this.currentKey();
+	}
+
+	this.blocks[this.currentKey()] += "return html`";
+	Visitor.prototype.Program.call(this, program);
+	this.blocks[this.currentKey()] += "`;}";
+
+	this.keys.pop(key);
+};
+
+HTMLLitVisitor.prototype.ContentStatement = function(content) {
+	Visitor.prototype.ContentStatement.call(this, content);
+	// let content = content.orgiinal; // attribute="__ attribute = "__  attribute ="__
+
+	let contentStatement = content.original;
+	skipIfDefined = !!dynamicAttributeRgx.exec(contentStatement);
+
+	const closingIndex = contentStatement.lastIndexOf(">");
+	const openingIndex = contentStatement.lastIndexOf("<");
+	if (closingIndex !== -1 || openingIndex !== -1) { // Only change isNodeValue whenever < or > is found in the content statement
+		isNodeValue = closingIndex > openingIndex;
+	}
+
+	isStyleAttribute = !isNodeValue && contentStatement.match(/style *= *["']? *$/);
+
+	if (!isStyleAttribute && contentStatement.match(/style=/)) {
+		console.log("WARNING: style hard-coded", contentStatement);
+	}
+
+	// Scope custom element tags
+	contentStatement = contentStatement.replaceAll(/(<\/?\s*)([a-zA-Z0-9_]+-[a-zA-Z0-9_-]+)/g, "$1\${scopeTag(\"$2\", tags, suffix)}");
+
+	this.blocks[this.currentKey()] += contentStatement;
+};
+
+HTMLLitVisitor.prototype.MustacheStatement = function(mustache) {
+	Visitor.prototype.MustacheStatement.call(this, mustache);
+
+	if (mustache.path.original === "@index") {
+		this.blocks[this.currentKey()] += "${index}";
+	} else {
+		const path = normalizePath.call(this, mustache.path.original);
+		const hasCalculatingClasses = path.includes("this.classes");
+
+		let parsedCode = "";
+
+		if (isNodeValue && !mustache.escaped) {
+			parsedCode = `\${unsafeHTML(${path})}`;
+		} else if (hasCalculatingClasses) {
+			if (process.env.UI5_TS) {
+				parsedCode = `\${classMap(${path} as ClassMapValue)}`;
+			} else {
+				parsedCode = `\${classMap(${path})}`;
+			}
+		} else if (isStyleAttribute) {
+			parsedCode = `\${styleMap(${path})}`;
+		} else if (skipIfDefined){
+			parsedCode = `\${${path}}`;
+		} else {
+			parsedCode = `\${ifDefined(${path})}`;
+		}
+
+		this.blocks[this.currentKey()] += parsedCode;
+	}
+};
+
+HTMLLitVisitor.prototype.BlockStatement = function(block) {
+	if (block.path.original === "if") {
+		visitIfBlock.call(this, block);
+	} else if (block.path.original === "unless") {
+		visitUnlessBlock.call(this, block);
+	} else if (block.path.original === "each") {
+		visitEachBlock.call(this, block);
+	}
+};
+
+HTMLLitVisitor.prototype.currentKey = function() {
+	return this.keys[this.keys.length - 1];
+};
+
+HTMLLitVisitor.prototype.prevKey = function() {
+	return this.keys[this.keys.length - 2];
+};
+
+function visitSubExpression(mustache) {
+	this.acceptRequired(mustache, "path");
+	this.acceptArray(mustache.params);
+	this.acceptKey(mustache, "hash");
+}
+
+function visitIfBlock(block) {
+	visitSubExpression.call(this, block);
+
+	let params = normalizePath.call(this, block.params[0].original);
+	this.blocks[this.currentKey()] += "${ " + params + " ? ";
+	this.acceptKey(block, "program");
+	this.blocks[this.currentKey()] += " : ";
+	if (block.inverse) {
+		this.acceptKey(block, "inverse");
+	} else {
+		this.blocks[this.currentKey()] += "undefined";
+	}
+	this.blocks[this.currentKey()] += " }";
+}
+
+function visitUnlessBlock(block) {
+	visitSubExpression.call(this, block);
+
+	let params = normalizePath.call(this, block.params[0].original);
+	this.blocks[this.currentKey()] += "${ !" + params + " ? ";
+	this.acceptKey(block, "program");
+	this.blocks[this.currentKey()] += " : undefined }";
+}
+
+function visitEachBlock(block) {
+	var bParamAdded = false;
+	visitSubExpression.call(this, block);
+
+	const reapeatDirectiveParamsTS = "(item, index) => (item as typeof item & {_id?: any})._id || index, (item, index: number)";
+	const reapeatDirectiveParamsJS = "(item, index) => item._id || index, (item, index)";
+	const repleatDirectiveParams = process.env.UI5_TS ? reapeatDirectiveParamsTS : reapeatDirectiveParamsJS;
+	this.blocks[this.currentKey()] += "${ repeat(" + normalizePath.call(this, block.params[0].original) + ", " + repleatDirectiveParams + " => ";
+	this.paths.push(normalizePath.call(this, block.params[0].original));
+	this.blockLevel++;
+
+	// block params is [this, context, tags, suffix] for top level blocks
+	// blcok params is [this, context, tags, suffix, item, index] for nested blocks
+	if (!this.blockParametersUsage.includes("index")) {
+		// last item is not index, but an each block is processed, add the paramters for further nested blocks
+		bParamAdded = true;
+		if (process.env.UI5_TS) {
+			this.blockParametersDefinition.push("item: any");
+			this.blockParametersDefinition.push("index: number");
+		} else {
+			this.blockParametersDefinition.push("item");
+			this.blockParametersDefinition.push("index");
+		}
+		this.blockParametersUsage.push("item");
+		this.blockParametersUsage.push("index");
+	}
+	this.acceptKey(block, "program");
+	if (bParamAdded) {
+		// if parameters were added at this step, remove the last two
+		this.blockParametersDefinition.pop();
+		this.blockParametersDefinition.pop();
+		this.blockParametersUsage.pop();
+		this.blockParametersUsage.pop();
+	}
+	this.blockLevel--;
+	this.blocks[this.currentKey()] += ") }";
+}
+
+function normalizePath(sPath) {
+	let result = replaceAll(replaceAll(replaceAll(sPath, ".this", ""), "this.", ""), "this", "");
+
+	//read carefully - https://github.com/wycats/handlebars.js/issues/1028
+	//kpdecker commented on May 20, 2015
+
+	if (result.indexOf("@root") === 0) {
+		// Trying to access root context via the HBS "@root" variable.
+		// Example: {{@root.property}} compiles to "context.property" - called from anywhere within the template.
+		result = result.replace("@root", "this");
+
+	} else if (result.indexOf("../") === 0) {
+		let absolutePath;
+		const levelsUp = (result.match(/..\//g) || []).length;
+
+		if (this.blockLevel <= levelsUp) {
+			// Trying to access root context from nested loops.
+			// Example: {{../../property}} compiles to "context.property" - when currently in a nested level loop.
+			// Example: {{../../../property}} compile to "context.property" - when requested levels are not present. fallback to root context.
+			absolutePath = `this.${replaceAll(result,"../", "")}`;
+		} else {
+			// Trying to access upper context (one-level-up) and based on the current lelev, that could be "context" or "item".
+			// Example: {{../property}} compiles to "context.property" - when called in a top level loop.
+			// Example: {{../property}} compiles to "item.property" - when called in a nested level loop.
+			// TODO: the second example, although correctly generated to "item.property", "item" will point to the current object within the nested loop,
+			// not the upper level loop as intended. So accessing the upper loop from nested loop is currently not working.
+			absolutePath = replaceAll(this.paths[this.paths.length - 1 - levelsUp], ".", "/") + "/" + result;
+		}
+
+		result = replaceAll(path.normalize(absolutePath), path.sep, ".");
+
+	} else {
+		// When neither "@root", nor "../" are used, use the following contexts:
+		// - use "context" - for the top level of execution, e.g "this.blockLevel = 0".
+		// - use "item" - for any nested level, e.g "this.blockLevel > 0".
+		// Example:
+		//
+		// {{text}} -> compiles to "context.text"
+		// {{#each items}}
+				// Item text: {{text}}</div> -> compiles to "item.text"
+				// 	{{#each words}}
+				// 			 Word text: {{text}}</div> -> compiles to "item.text"
+				// 	{{/each}}
+				// 	Item text: {{text}}</div> -> compiles to "item.text"
+		// {{/each}}
+		// {{text}} -> compiles to "context.text"
+
+		const blockPath = this.blockLevel > 0 ? "item" : "this";
+		result = result ? replaceAll(blockPath + "/" + result, "/", ".") : blockPath;
+	}
+
+	return result;
+}
+
+function replaceAll(str, find, repl) {
+	let sResult = str;
+	while (sResult.indexOf(find) !== -1) {
+		sResult = sResult.replace(find, repl);
+	}
+	return sResult;
+}
+
+module.exports = HTMLLitVisitor;

package/lib/hbs2lit/src/partials2.js

@@ -0,0 +1,51 @@
+//collects the partials defined with the inline mustache syntax
+//also cleans the handlebars template from the partials definitions
+function collectPartials(hbs) {
+	let oResult = {};
+
+	const re = RegExp("{{#\\*inline\\s* \"(\\w+)\"\\s*}}((.|\\s)*?){{\\/inline}}");
+	const regexGroups = {partialKey: 1, partialDefinition: 2};
+
+	let m;
+
+	do {
+		m = re.exec(hbs);
+		if (m) {
+			// This is necessary to avoid infinite loops with zero-width matches
+			if (m.index === re.lastIndex) {
+				re.lastIndex++;
+			}
+
+			// The result can be accessed through the `m`-variable.
+			oResult[m[regexGroups.partialKey]] = m[regexGroups.partialDefinition];
+
+			//remove the partial from the hbs
+			hbs = hbs.replace(m[0], "");
+		}
+	} while (m);
+
+	return {partials: oResult, hbs: hbs};
+}
+
+//replaces the partials usages with their actual definitions
+function replacePartials(hbs, mPartials) {
+	let sResultHbs = hbs;
+	for (let key in mPartials) {
+		if (mPartials.hasOwnProperty(key)) {
+			let val = mPartials[key];
+			let re = new RegExp("{{\\s*>\\s*" + key + "\\s*}}", "g"); //ex match: {{   >   controlData  }}
+			sResultHbs = sResultHbs.replace(re, val);
+		}
+	}
+
+	return sResultHbs;
+}
+
+module.exports = {
+	resolve: function(hbs) {
+		let oResult = collectPartials(hbs);
+		let sResultHbs = replacePartials(oResult.hbs, oResult.partials);
+
+		return sResultHbs;
+	}
+};