minecraft-LBNG-types

• refined disclaimer in README.md
• localStorage in definition (no java.utils class definition yet)
• multiChoose in manually maintained patch

and the generated script was reverted to a state where it was not as readable as the following example (for correctness) but still largely remained the same.

Now it can kinda generate a working script, but the ts file has a few squiggles.

template.ts

// imports
import {
    Setting,
    Vec3i,
    Vec3d,
    MathHelper,
    BlockPos,
    Hand,
    RotationAxis,
    mc,
    Client,
    RotationUtil,
    ItemUtil,
    NetworkUtil,
    InteractionUtil,
    BlockUtil,
    MovementUtil,
    ReflectionUtil,
    ParameterValidator,
    UnsafeThread,
    registerScript
} from "@embedded";

import { ScriptModule } from "@minecraft-yarn-definitions/types/net/ccbluex/liquidbounce/script/bindings/features/ScriptModule";
import { Matrix2d } from "@minecraft-yarn-definitions/types/org/joml/Matrix2d";


const script = registerScript.apply({
    name: "template",
    version: "1.0.0",
    authors: ["commandblock2"]
});

script.registerModule({
    // @ts-ignore   
    name: "example-from-template",
    // @ts-ignore   
    description: "Ths is an example module generated in ts",
    // @ts-ignore   
    category: "Client"

}, (mod: ScriptModule) => {
    mod.on("enable", () => {
        Client.displayChatMessage(`${mc.player}`)
        Client.displayChatMessage(`${new Vec3i(1, 2, 3)}`)
        Client.displayChatMessage(`${new Matrix2d(1.2, 1.3, 1.4, 15)}`)
        Client.displayChatMessage("enabled")
    })
    mod.on("disable", () => Client.displayChatMessage("disabled"))
})

compiled template.js

function __require(path) {
    if (path.startsWith("@embedded")) {
        return {
            _embedded: globalThis
        }
    }

    if (path.startsWith("@minecraft-yarn-definitions/types/")) {
        return {
            [path.substring(path.lastIndexOf("/") + 1)]: Java.type(path
                .replaceAll("@minecraft-yarn-definitions/types/", "")
                .replaceAll("/", ".")
            )
        }
    }
    return require(path);
}
var exports = {}

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const { _embedded } = __require("@embedded");
const { Matrix2d } = __require("@minecraft-yarn-definitions/types/org/joml/Matrix2d");
const script = _embedded.registerScript.apply({
    name: "template",
    version: "1.0.0",
    authors: ["commandblock2"]
});
script.registerModule({
    // @ts-ignore   
    name: "example-from-template",
    // @ts-ignore   
    description: "Ths is an example module generated in ts",
    // @ts-ignore   
    category: "Client"
}, (mod) => {
    mod.on("enable", () => {
        _embedded.Client.displayChatMessage(`${_embedded.mc.player}`);
        _embedded.Client.displayChatMessage(`${new Vec3i(1, 2, 3)}`);
        _embedded.Client.displayChatMessage(`${new Matrix2d(1.2, 1.3, 1.4, 15)}`);
        _embedded.Client.displayChatMessage("enabled");
    });
    mod.on("disable", () => _embedded.Client.displayChatMessage("disabled"));
});

// Import required Java classes

// type: array
/** @type any[]*/
var globalEntries = Object.entries(this);

const System = Java.type("java.lang.System");
const URLClassLoader = Java.type("java.net.URLClassLoader");
const File = Java.type("java.io.File");
const URL = Java.type("java.net.URL");
const Thread = Java.type("java.lang.Thread");
const Paths = Java.type("java.nio.file.Paths");
const Map = Java.type("java.util.HashMap");
const ArrayList = Java.type("java.util.ArrayList");
const JvmClassMappingKt = Java.type("kotlin.jvm.JvmClassMappingKt");
const Class = Java.type("java.lang.Class");

// Function to create a URLClassLoader from a JAR path
function createClassLoaderFromJar(jarPath) {
    try {
        // Create File object for the JAR
        const jarFile = new File(jarPath);

        // Convert File to URL
        const jarUrl = jarFile.toURI().toURL();

        // Create URLClassLoader with the system class loader as parent
        return new URLClassLoader(
            [jarUrl],
            Thread.currentThread().getContextClassLoader()
        );
    } catch (e) {
        console.error("Error creating ClassLoader:", e);
        throw e;
    }
}

// Function to load a class from a given ClassLoader
function loadClassFromJar(classLoader, className) {
    try {
        return classLoader.loadClass(className);
    } catch (e) {
        console.error(`Error loading class ${className}:`, e);
        throw e;
    }
}

const script = registerScript({
    name: "for-repl",
    version: "1.0.0",
    authors: ["commandblock2"],
});

script.registerModule(
    {
        name: "for-repl",
        category: "Client",
        description: "Sausage",
        settings: {
            path: Setting.text({
                name: "Path",
                default:
                    "/mnt/old-linux/home/commandblock2/git_repo/MultiMC5/build/instances/LBNG-Production/minecraft/LiquidBounce/scripts",
            }),
            packageName: Setting.text({
                name: "NPMPackageName",
                default: "minecraft-yarn-definitions",
            }),
        },
    },
    (mod) => {
        mod.on("enable", (event) => {
            const loader = createClassLoaderFromJar(
                mod.settings.path.value + "/ts-generator-1.0.0.jar"
            );
            const NPMGen = loadClassFromJar(
                loader,
                "me.commandblock2.tsGenerator.NPMPackageGenerator"
            );
            const TsGen = loadClassFromJar(
                loader,
                "me.ntrrgc.tsGenerator.TypeScriptGenerator"
            );
            const VoidType = loadClassFromJar(
                loader,
                "me.ntrrgc.tsGenerator.VoidType"
            );
            const NULL = VoidType.getEnumConstants()[0];

            const javaClasses = globalEntries
                .filter((entry) => entry[1] != undefined)
                .map((entry) => (entry[1] instanceof Class ? entry[1] : entry[1].class))
                .filter((entry) => entry != undefined);

            const kotlinClasses = javaClasses.map((entry) =>
                JvmClassMappingKt.getKotlinClass(entry)
            );

            const classes = new ArrayList(kotlinClasses);

            try {
                const generated = new TsGen(
                    classes,
                    new Map(),
                    new ArrayList(),
                    new ArrayList(),
                    "number",
                    NULL
                );
                const npmPack = new NPMGen(generated, mod.settings.packageName.value);
                npmPack.writePackageTo(
                    Paths.get(mod.settings.path.value + "/types-gen")
                );

                const embeddedDefinition = `
// imports
${javaClasses
                        .map((clazz) => {
                            return `import { ${clazz.simpleName} } from "@${mod.settings.packageName.value}/types/${clazz.name.replaceAll(".", "/")}";`;
                        })
                        .join("\n")}


// definitions for objects
${globalEntries
                        .filter((entry) => entry[1] != undefined)
                        .filter((entry) => !(entry[1] instanceof Class))
                        .filter((entry) => entry[1].class != undefined)
                        .map((entry) => `export var ${entry[0]}: ${entry[1].class.simpleName};`)
                        .join("\n\n")}

`;
                console.log(embeddedDefinition)
            } catch (e) {
                e.printStackTrace();
                console.error(e);
                throw e;
            }

            // ReflectionUtil.invokeMethod(mc.player, "getName")
            // event.context.drawGuiTexture(RenderLayer.getGuiTextured, CLOSE_TEXTURE, 0, 0, 16, 16, -1);
        });
    }
);