@cabin-icarus/tooltip_generator 1.7.15 → 1.8.2

package/README.md

@@ -37,3 +37,42 @@ To test: in the resource folder, go to `resource/localization`, open `localizati
 ```
 * Save as any name like `dota_ts.sublime-build`
 * Have `fsWatcher.ts` or `package.json` or any other file from the project open -> press Ctrl + Shift + B -> select `dota_ts` -> console opens and it is run, is closed with esc, will still continue to compile everything until sublime is closed.
+
+
+## Include use
+```ts
+Folder Tree
+- resource/langs/addon_schinese.txt     kv: "hello" "hello china！"
+- resource/langs/addon_english.txt      kv: "hello" "hello english!"
+- resource/langs/addon_russian.txt      kv: "hello" "hello russian!"
+
+
+
+export function GenerateLocalizationData(): LocalizationData
+{
+    const info: LocalizationData =
+    {
+        Include:new Map()
+    };
+    
+    
+    info.Include.set(Language.Schinese, [
+        "langs/addon_schinese.txt",
+    ])
+
+    info.Include.set(Language.English, [
+        "langs/addon_english.txt",
+    ])
+
+    info.Include.set(Language.Russian, [
+        "langs/addon_russian.txt",
+    ])
+    
+    return info
+}
+
+out file:
+- resource/addon_schinese.txt   kv: "hello" "hello china！"
+- resource/addon_english.txt    kv: "hello" "hello english!"
+- resource/addon_russian.txt    kv: "hello" "hello russian!"
+```

package/fsWatcher.ts

@@ -1,4 +1,5 @@
 const fs = require('fs');
+const path = require("path");
 import { LocalizationCompiler } from './localizationCompiler';
 const watch = require("node-watch");
 
@@ -6,57 +7,69 @@ let completeData: {[path: string]: LocalizationData} = {};
 const resourcePath = "node_modules/~resource";
 const generatorPath = "node_modules/~generator";
 
-console.log(fs.realpathSync(generatorPath));
+const folderPath = resourcePath + "/localization";
 
-let watcher = watch([resourcePath + "/localization"], {recursive: true})
+let watcher = watch([folderPath], {recursive: true})
 watcher.on("change", (eventType ?: 'update' | 'remove' | undefined, filePath ?: string) => {
-	if (!filePath) return;
-	if (filePath.includes("localizationCompiler.ts")) {
-		compiler = loadCompiler();
-	}
-	let match = /(node_modules[\\/])?(.*[\/|\\](\w+)).ts/g.exec(filePath);
-	if (eventType == "update" && filePath && match) {
-		const curpath = match[2];
-		const data = getDataFromFile(curpath + ".ts");
-		if (data) {
-			completeData[curpath] = data;
-			combineData();
-		}
-	} else if (eventType == "remove" && match) {
-		if (completeData.hasOwnProperty(match[2])) {
-			delete completeData[match[2]];
-			combineData();
-		}
-	}
+    if (!filePath) return;
+    if (filePath.includes("localizationCompiler.ts")) {
+        compiler = loadCompiler();
+    }
+    let match = /(node_modules[\\/])?(.*[\/|\\](.+)).ts/g.exec(filePath);
+    if (eventType == "update" && filePath && match) {
+        const curpath = match[2];
+        const data = getDataFromFile(curpath + ".ts");
+        if (data) {
+            completeData[curpath] = data;
+            combineData();
+        }
+    } else if (eventType == "remove" && match) {
+        if (completeData.hasOwnProperty(match[2])) {
+            delete completeData[match[2]];
+            combineData();
+        }
+    }
 })
 
 // not really neccessarry:
 watcher.on("error", (error: Error) => {
-	console.log("\x1b[31m%s\x1b[0m", "Something went wrong!");
-	console.log(error);
+    console.log("\x1b[31m%s\x1b[0m", "Something went wrong!");
+    console.log(error);
 })
 
 watcher.on("ready", () => {
-	console.log("\x1b[32m%s\x1b[0m", "Ready!");
+    console.log("\x1b[32m%s\x1b[0m", "Ready!");
+
+    const files = __getAllFiles(folderPath);
+
+    Promise.all(files.map(x =>
+        {
+            const temp = fs.readFileSync(x);
+            fs.writeFile(x, ' ', err =>
+            {
+                fs.writeFileSync(x, temp);
+            });
+        }
+    ))
 })
 
 let compiler = loadCompiler();
 
 function getDataFromFile(filePath: string): LocalizationData | undefined {
-	if (!fs.existsSync("node_modules/" + filePath)){
-		return;
-	}
-	delete require.cache[require.resolve(filePath)]
-	let file = require(filePath);
-	if (file["GenerateLocalizationData"]) {
-		const localizationArr: LocalizationData = file["GenerateLocalizationData"]();
-		return localizationArr;
-	}
-	return;
+    if (!fs.existsSync("node_modules/" + filePath)){
+        return;
+    }
+    delete require.cache[require.resolve(filePath)]
+    let file = require(filePath);
+    if (file["GenerateLocalizationData"]) {
+        const localizationArr: LocalizationData = file["GenerateLocalizationData"]();
+        return localizationArr;
+    }
+    return;
 }
 
 function combineData() {
-	compiler.OnLocalizationDataChanged(completeData);
+    compiler.OnLocalizationDataChanged(completeData);
 }
 
 function loadCompiler(): LocalizationCompiler
@@ -67,3 +80,23 @@ function loadCompiler(): LocalizationCompiler
     const compilerClass: new () => LocalizationCompiler = require("~generator/localizationCompiler").LocalizationCompiler;
     return new compilerClass();
 }
+
+const __getAllFiles = (dirPath: string, arrayOfFiles?: string[]) =>
+{
+    const files = fs.readdirSync(dirPath)
+
+    arrayOfFiles = arrayOfFiles ?? []
+
+    files.forEach(function (file)
+    {
+        if (fs.statSync(dirPath + "/" + file).isDirectory())
+        {
+            arrayOfFiles = __getAllFiles(path.join(dirPath, file), arrayOfFiles)
+        } else
+        {
+            arrayOfFiles?.push(path.join(dirPath, file))
+        }
+    })
+
+    return arrayOfFiles
+}

package/install.ts

@@ -10,7 +10,7 @@ interface packageSnippet {
 
 // define package insertions
 const devScripts = [
-	["dev:runlocalizationWatcher", "ts-node node_modules/~generator/fsWatcher.ts"]
+	["dev:runlocalizationWatcher", "ts-node -P node_modules/~resource/tsconfig.json node_modules/~generator/fsWatcher.ts"]
 ]
 const initSCript = ["init", "link-module-alias && ts-node node_modules/~generator/init.ts"]
 const aliases = [

package/localizationCompiler.ts

@@ -1,11 +1,12 @@
 const fs = require('fs');
 const path = require('path');
-import { KVObject, serialize } from 'valve-kv'
+import { KVObject, serialize,deserializeFile } from 'valve-kv'
 import { Language } from "~resource/languages"
 
 export class LocalizationCompiler
 {
-	addon_filepath: string = path.join("node_modules/~resource", "addon_");
+	folderPath: string = path.join("node_modules/~resource");
+	addon_filepath: string = path.join(this.folderPath, "addon_");
 	filepath_format: string = ".txt";
 	currentWrites: Set<string> = new Set();
 	writeTimeout?: NodeJS.Timeout;
@@ -29,7 +30,7 @@ export class LocalizationCompiler
 			text = text.replace(/\{(\w*)}($|[^%])/g, "%$1%$2")
 			text = text.replace(/\{(\w*)}%/g, "%$1%%%");
 			text = text.replace(/%\{(\w*)}/g, "%%%$1%");
-			
+
 			return text;
 		}
 	}
@@ -43,12 +44,14 @@ export class LocalizationCompiler
 		//let Talents: Array<HeroTalents> = new Array<HeroTalents>();
 
 		const localization_info: LocalizationData =
-		{
-			AbilityArray: Abilities,
-			ModifierArray: Modifiers,
-			StandardArray: StandardTooltips,
-			// TalentArray: Talents,
-		};
+				  {
+					  AbilityArray: Abilities,
+					  ModifierArray: Modifiers,
+					  StandardArray: StandardTooltips,
+					  // TalentArray: Talents,
+				  };
+
+		const refMap: Map<Language, string[]> = new Map<Language, string[]>();
 
 		for (const [key, data] of Object.entries(allData)) {
 			if (data.AbilityArray) {
@@ -60,16 +63,29 @@ export class LocalizationCompiler
 			if (data.StandardArray) {
 				Array.prototype.push.apply(StandardTooltips, data.StandardArray);
 			}
+			if (data.Include)
+			{
+				for (const [lang, includes] of data.Include.entries())
+				{
+					if (!refMap.has(lang)) {
+						refMap.set(lang, []);
+					}
+					const existingIncludes = refMap.get(lang);
+					if (existingIncludes) {
+						existingIncludes.push(...includes);
+					}
+				}
+			}
 		}
 
 		// Generate information for every language
 		const languages = Object.values(Language).filter(v => typeof v !== "number");
 		for (const language of languages)
-		{            
+		{
 			if (language !== Language.None)
 			{
 				const tokens: KVObject = this.GenerateContentStringForLanguage(language, localization_info);
-				this.WriteContentToAddonFile(language, tokens);
+				this.WriteContentToAddonFile(language, tokens, refMap.get(language));
 			}
 		}
 	}
@@ -96,7 +112,7 @@ export class LocalizationCompiler
 					}
 				}
 
-				tokens[standardLocalization.classname] = standard_tooltip_string;                
+				tokens[standardLocalization.classname] = standard_tooltip_string;
 			}
 		}
 
@@ -138,7 +154,7 @@ export class LocalizationCompiler
 							// Check for reimagined effect overrides
 							//if (language_override.reimagined_effects_override)
 							//{
-								//reimagined_effects = language_override.reimagined_effects_override;
+							//reimagined_effects = language_override.reimagined_effects_override;
 							//}
 
 							// Check for lore override
@@ -178,20 +194,20 @@ export class LocalizationCompiler
 				if (ability_name)
 				{
 					tokens[ability_string] = ability_name;
-				}                
+				}
 
 				// Add description localization
 				if (ability_description)
 				{
 					ability_description = this.TransformForLocalization(ability_description, false);
 					tokens[`${ability_string}_description`] = ability_description;
-				}                
+				}
 
 				// Lore, if any
 				if (ability_lore)
 				{
 					const transformed_lore = this.TransformForLocalization(ability_lore, false);
-					tokens[`${ability_string}_Lore`] = transformed_lore;                    
+					tokens[`${ability_string}_Lore`] = transformed_lore;
 				}
 
 				// Notes, if any
@@ -201,7 +217,7 @@ export class LocalizationCompiler
 					for (const note of ability_notes)
 					{
 						const transformed_note = this.TransformForLocalization(note, false);
-						tokens[`${ability_string}_Note${counter}`] = transformed_note;                        
+						tokens[`${ability_string}_Note${counter}`] = transformed_note;
 
 						counter++;
 					}
@@ -211,14 +227,14 @@ export class LocalizationCompiler
 				if (scepter_description)
 				{
 					const ability_scepter_description = this.TransformForLocalization(scepter_description, false);
-					tokens[`${ability_string}_scepter_description`] = ability_scepter_description;                    
+					tokens[`${ability_string}_scepter_description`] = ability_scepter_description;
 				}
 
 				// Shard, if any
 				if (shard_description)
 				{
 					const ability_shard_description = this.TransformForLocalization(shard_description, false);
-					tokens[`${ability_string}_shard_description`] = ability_shard_description;                    
+					tokens[`${ability_string}_shard_description`] = ability_shard_description;
 				}
 
 				// Ability specials, if any
@@ -240,7 +256,7 @@ export class LocalizationCompiler
 
 						ability_special_text += ability_special.text;
 
-						tokens[`${ability_string}_${ability_special.ability_special}`] = ability_special_text;                        
+						tokens[`${ability_string}_${ability_special.ability_special}`] = ability_special_text;
 					}
 				}
 			}
@@ -281,21 +297,21 @@ export class LocalizationCompiler
 				if (modifier_name)
 				{
 					tokens[modifier_string] = modifier_name;
-				}                
+				}
 
 				// Add description to localization string
 				if (modifier_description)
 				{
 					modifier_description = this.TransformForLocalization(modifier_description, true);
 					tokens[`${modifier_string}_description`] = modifier_description;
-				}                
+				}
 			}
 		}
 
 		return tokens;
 	}
 
-	WriteContentToAddonFile(language: string, tokens: KVObject)
+	WriteContentToAddonFile(language: string, tokens: KVObject, includes: string[] | undefined)
 	{
 		// Set based on language
 		const filepath = this.addon_filepath + language.toString() + this.filepath_format;
@@ -303,6 +319,24 @@ export class LocalizationCompiler
 		// Add the opening tokens        
 		const kv = {lang: { Language: language, Tokens: tokens}}
 
+		if (includes && includes.length > 0)
+		{
+			for(const include of includes)
+			{
+				try {
+					const itemData = deserializeFile(path.join(this.folderPath, include), "utf-8");
+					if (itemData && itemData.lang && itemData.lang.Tokens)
+					{
+						Object.assign(kv.lang.Tokens, itemData.lang.Tokens);
+					}
+				}
+				catch (e) 
+				{
+					console.warn(`${include} file processing failed, please check whether the file encoding is utf-8 errorMsg:${e}`)
+				}
+			}
+		}
+
 		// Serialize!        
 		let write_string = serialize(kv);
 

package/localizationInterfaces.d.ts

@@ -99,6 +99,7 @@ declare global
         AbilityArray?: Array<AbilityLocalization>;
         ModifierArray?: Array<ModifierLocalization>;
         StandardArray?: Array<StandardLocalization>;
+        Include?:Map<Language, string[]>;
         //TalentArray?: Array<HeroTalents>;
     }
 

package/package.json

@@ -41,8 +41,8 @@
   },
   "scripts": {
     "dev": "run-p dev:*",
-    "dev:runlocalizationWatcher": "ts-node node_modules/~generator/fsWatcher.ts",
+    "dev:runlocalizationWatcher": "ts-node -P node_modules/~resource/tsconfig.json node_modules/~generator/fsWatcher.ts",
     "init": "link-module-alias && ts-node node_modules/~generator/init.ts"
   },
-  "version": "1.7.15"
+  "version": "1.8.2"
 }

package/Helper.ts

@@ -1,4 +0,0 @@
-export function GetNodeXlsx()
-{
-    return require("node-xlsx");
-}