@cldmv/slothlet 2.10.0 → 3.0.0

package/dist/lib/processors/typescript.mjs

@@ -0,0 +1,188 @@
+/*
+	Copyright 2026 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+
+
+
+
+import fs from "fs";
+import path from "path";
+import { SlothletError } from "@cldmv/slothlet/errors";
+
+let esbuildInstance = null;
+let typescriptInstance = null;
+
+
+async function getEsbuild() {
+	if (!esbuildInstance) {
+		try {
+			esbuildInstance = await import("esbuild");
+			
+			
+			
+		} catch (error) {
+			throw new SlothletError("TYPESCRIPT_ESBUILD_NOT_INSTALLED", { mode: "fast" }, error);
+		}
+		
+	}
+	return esbuildInstance;
+}
+
+
+async function getTypeScript() {
+	if (!typescriptInstance) {
+		try {
+			typescriptInstance = await import("typescript");
+			
+			
+			
+		} catch (error) {
+			throw new SlothletError("TYPESCRIPT_TSC_NOT_INSTALLED", { mode: "strict" }, error);
+		}
+		
+	}
+	return typescriptInstance;
+}
+
+
+export async function transformTypeScript(filePath, options = {}) {
+	const esbuild = await getEsbuild(); 
+	const code = fs.readFileSync(filePath, "utf8");
+
+	const result = await esbuild.transform(code, {
+		loader: "ts",
+		format: options.format || "esm",
+		target: options.target || "es2020",
+		sourcemap: options.sourcemap || false,
+		...options
+	});
+
+	return result.code;
+}
+
+
+export function createDataUrl(code) {
+	
+	const encoded = encodeURIComponent(code);
+	const timestamp = Date.now();
+	return `data:text/javascript;charset=utf-8,${encoded}#t=${timestamp}`;
+}
+
+
+export async function transformTypeScriptStrict(filePath, options = {}) {
+	const ts = await getTypeScript(); 
+	const code = fs.readFileSync(filePath, "utf8");
+
+	
+	const targetMap = {
+		es3: ts.ScriptTarget.ES3,
+		es5: ts.ScriptTarget.ES5,
+		es6: ts.ScriptTarget.ES2015,
+		es2015: ts.ScriptTarget.ES2015,
+		es2016: ts.ScriptTarget.ES2016,
+		es2017: ts.ScriptTarget.ES2017,
+		es2018: ts.ScriptTarget.ES2018,
+		es2019: ts.ScriptTarget.ES2019,
+		es2020: ts.ScriptTarget.ES2020,
+		es2021: ts.ScriptTarget.ES2021,
+		es2022: ts.ScriptTarget.ES2022,
+		esnext: ts.ScriptTarget.ESNext,
+		latest: ts.ScriptTarget.Latest
+	};
+
+	
+	const moduleMap = {
+		none: ts.ModuleKind.None,
+		commonjs: ts.ModuleKind.CommonJS,
+		amd: ts.ModuleKind.AMD,
+		system: ts.ModuleKind.System,
+		umd: ts.ModuleKind.UMD,
+		es6: ts.ModuleKind.ES2015,
+		es2015: ts.ModuleKind.ES2015,
+		es2020: ts.ModuleKind.ES2020,
+		es2022: ts.ModuleKind.ES2022,
+		esnext: ts.ModuleKind.ESNext,
+		node16: ts.ModuleKind.Node16,
+		nodenext: ts.ModuleKind.NodeNext
+	};
+
+	const targetKey = (options.target || "es2020").toLowerCase();
+	const moduleKey = (options.module || "esnext").toLowerCase();
+
+	const compilerOptions = {
+		target: targetMap[targetKey] || ts.ScriptTarget.ES2020,
+		module: moduleMap[moduleKey] || ts.ModuleKind.ESNext,
+		strict: options.strict !== false,
+		esModuleInterop: true,
+		skipLibCheck: true,
+		noEmit: false, 
+		...(options.typeDefinitionPath && {
+			typeRoots: [path.dirname(options.typeDefinitionPath)],
+			types: [path.basename(options.typeDefinitionPath, ".d.ts")]
+		}),
+		...options.compilerOptions
+	};
+
+	
+	let diagnostics = [];
+	if (!options.skipTypeCheck) {
+		
+		const host = ts.createCompilerHost(compilerOptions);
+
+		
+		const originalReadFile = host.readFile;
+		host.readFile = (fileName) => {
+			if (fileName === filePath) {
+				return code;
+			}
+			return originalReadFile.call(host, fileName);
+		};
+
+		
+		const program = ts.createProgram([filePath], compilerOptions, host);
+
+		
+		const allDiagnostics = [...program.getSemanticDiagnostics(), ...program.getSyntacticDiagnostics()];
+
+		
+		diagnostics = allDiagnostics.filter((d) => d.file && d.file.fileName === filePath);
+	}
+
+	
+	const result = ts.transpileModule(code, {
+		compilerOptions,
+		fileName: filePath
+	});
+
+	return {
+		code: result.outputText,
+		diagnostics
+	};
+}
+
+
+export function formatDiagnostics(diagnostics, ts) {
+	return diagnostics.map((diagnostic) => {
+		const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+		if (diagnostic.file && diagnostic.start !== undefined) {
+			const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+			const fileName = diagnostic.file.fileName;
+			return `${fileName}:${line + 1}:${character + 1} - ${message}`;
+		}
+		return message;
+	});
+}