+
+
+
+
+
\ No newline at end of file
diff --git a/script.js b/script.js
new file mode 100644
index 0000000..50b5dcd
--- /dev/null
+++ b/script.js
@@ -0,0 +1,182 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import init, { create_state, generate, is_valid_mod_id, list_all_minecraft_versions, supports_neoforge, to_mod_id, validate_mod_id } from "./templateer.js";
+await init();
+
+const state = create_state();
+
+// Set up Minecraft version dropdown with contents
+const mcSelect = document.getElementById("minecraft-version-select");
+mcSelect.onchange = refreshAvailablePlatforms;
+
+for (const version of list_all_minecraft_versions().reverse()) {
+ const option = document.createElement("option");
+ option.textContent = version;
+ mcSelect.appendChild(option);
+}
+
+// Hide multiplatform settings when deselected
+const projectTypeToggles = document.getElementById("project-type-toggles").getElementsByTagName("input");
+const multiplatformInput = document.getElementById("multiplatform-input");
+const multiplatformSettings = document.getElementById("multiplatform-settings");
+
+for (const input of projectTypeToggles) {
+ input.onchange = refreshDisplayedProjectType;
+};
+
+// Add listeners to Fabric and Quilt checkboxes for controlling the Fabric-like checkbox,
+// and refresh the Fabric-like status according to the default state.
+document.getElementById("fabric-loader-input").onchange = refreshFabricLikeCheckbox;
+document.getElementById("quilt-loader-input").onchange = refreshFabricLikeCheckbox;
+refreshFabricLikeCheckbox();
+
+// Add generated mod id placeholder when not specified manually
+const modNameInput = document.getElementById("mod-name-input");
+const modIdInput = document.getElementById("mod-id-input");
+
+modNameInput.oninput = () => {
+ refreshModIdPlaceholder();
+ validateModId();
+};
+
+function refreshModIdPlaceholder() {
+ modIdInput.placeholder = to_mod_id(modNameInput.value) ?? "";
+}
+
+// Validate mod ids
+const modIdLabel = document.getElementById("mod-id-label");
+modIdInput.oninput = validateModId;
+
+function validateModId() {
+ const validation = validate_mod_id(getModId());
+
+ if (validation[0]) {
+ modIdLabel.removeAttribute("error");
+ } else {
+ modIdLabel.setAttribute("error", validation[1]);
+ }
+}
+
+function isModIdValid() {
+ return is_valid_mod_id(getModId());
+}
+
+function getModId() {
+ let value = modIdInput.value;
+ if (value === "") {
+ value = modIdInput.placeholder;
+ }
+ return value;
+}
+
+function getProjectType() {
+ for (const input of projectTypeToggles) {
+ if (input.checked) {
+ return input.getAttribute("projecttype");
+ }
+ }
+}
+
+function getMappingSet() {
+ for (const input of document.getElementsByTagName("input")) {
+ if (input.name !== "mappings") continue;
+ if (input.checked) {
+ return input.getAttribute("mappingset");
+ }
+ }
+}
+
+function updateState() {
+ state.mod_name = modNameInput.value;
+ state.mod_id = getModId();
+ state.package_name = document.getElementById("package-input").value;
+ state.game_version = mcSelect.value;
+ state.project_type = getProjectType();
+ state.mapping_set = getMappingSet();
+ state.subprojects.fabric = document.getElementById("fabric-loader-input").checked;
+ state.subprojects.forge = document.getElementById("forge-loader-input").checked;
+ state.subprojects.neoforge = document.getElementById("neoforge-loader-input").checked && isNeoForgeAvailable();
+ state.subprojects.quilt = document.getElementById("quilt-loader-input").checked;
+ state.subprojects.fabric_likes = document.getElementById("fabric-like-input").checked && isFabricLikeAvailable();
+ state.dependencies.architectury_api = document.getElementById("architectury-api-input").checked;
+}
+
+function showError(error) {
+ let container = document.getElementById("error-message-container");
+ container.textContent = error;
+ container.classList.remove("hidden");
+}
+
+function clearError() {
+ let container = document.getElementById("error-message-container");
+ container.textContent = "";
+ container.classList.add("hidden");
+}
+
+function refreshDisplayedProjectType() {
+ if (multiplatformInput.checked) {
+ multiplatformSettings.classList.remove("hidden");
+ } else {
+ multiplatformSettings.classList.add("hidden");
+ }
+}
+
+function isFabricLikeAvailable() {
+ const fabricInput = document.getElementById("fabric-loader-input");
+ const quiltInput = document.getElementById("quilt-loader-input");
+ return fabricInput.checked && quiltInput.checked;
+}
+
+function isNeoForgeAvailable() {
+ const version = mcSelect.value;
+ return supports_neoforge(version);
+}
+
+function refreshAvailablePlatforms() {
+ const hasNeoForge = isNeoForgeAvailable();
+ const neoForgeProjectInput = document.getElementById("neoforge-project-input");
+ const neoForgeLoaderInput = document.getElementById("neoforge-loader-input");
+ neoForgeProjectInput.disabled = !hasNeoForge;
+ neoForgeLoaderInput.disabled = !hasNeoForge;
+
+ // Change project type if Neo is not available.
+ if (!hasNeoForge && neoForgeProjectInput.checked) {
+ multiplatformInput.checked = true;
+ neoForgeProjectInput.checked = false;
+ refreshDisplayedProjectType();
+ }
+}
+
+// Enables/disables the Fabric-like checkbox based on whether it can be selected for the current state.
+function refreshFabricLikeCheckbox() {
+ const hasFabricLike = isFabricLikeAvailable();
+ const fabricLikeInput = document.getElementById("fabric-like-input");
+ fabricLikeInput.disabled = !hasFabricLike;
+}
+
+document.getElementById("generate-button").onclick = async () => {
+ updateState();
+
+ if (state.mod_name === "") {
+ showError("Mod name is empty");
+ return;
+ } else if (!isModIdValid()) {
+ showError("Mod ID is not valid");
+ return;
+ } else if (state.package_name === "") {
+ showError("Package name is empty");
+ return;
+ }
+
+ clearError();
+ await generate(state);
+};
+
+// Apply initial state
+modNameInput.value = state.mod_name;
+modIdInput.value = state.mod_id;
+refreshModIdPlaceholder();
+document.getElementById("package-input").value = state.package_name;
+document.getElementById("architectury-api-input").checked = state.dependencies.architectury_api;
diff --git a/style.css b/style.css
new file mode 100644
index 0000000..3196add
--- /dev/null
+++ b/style.css
@@ -0,0 +1,190 @@
+/*
+ This Source Code Form is subject to the terms of the Mozilla Public
+ License, v. 2.0. If a copy of the MPL was not distributed with this
+ file, You can obtain one at https://mozilla.org/MPL/2.0/.
+*/
+
+:root {
+ font-family: sans-serif;
+ cursor: default;
+ user-select: none;
+ background-color: var(--canvas-color);
+ color: var(--text-color);
+
+ --error-color: #BB0000;
+ --border-color: #888888;
+ --canvas-color: #F0F0F0;
+ --card-color: white;
+ --text-color: black;
+ --button-accent-color: blue;
+ --active-button-text-color: white;
+ --disable-button-color: #CCCCCC;
+ --text-field-background: white;
+}
+
+fieldset {
+ border-radius: 1ex;
+ margin: 1ex;
+}
+
+fieldset, fieldset > legend {
+ background-color: var(--card-color);
+ border: solid 1px var(--border-color);
+}
+
+fieldset > legend {
+ padding: 0.7ex;
+ border-radius: 0.5ex;
+}
+
+fieldset h2 {
+ margin-bottom: 0.5ex;
+}
+
+fieldset > h2:first-of-type, h3:first-of-type {
+ margin-top: 0;
+}
+
+input[type = "text"] {
+ display: block;
+ width: 24em;
+ padding: 0.8ex;
+
+ background-color: var(--text-field-background);
+ color: var(--text-color);
+ border: solid 1px var(--border-color);
+}
+
+select {
+ padding: 1ex;
+}
+
+.label-heading {
+ font-weight: bold;
+}
+
+.property-description {
+ display: block;
+ margin-top: 1ex;
+ margin-bottom: 1ex;
+}
+
+.multicol, .horizontal-flow {
+ display: flex;
+ flex-direction: row;
+}
+
+.vertical-flow {
+ display: flex;
+ flex-direction: column;
+ align-items: stretch;
+}
+
+.multicol > * {
+ margin: 1ex;
+}
+
+h1 {
+ text-align: center;
+}
+
+.horizontal-flow {
+ align-items: start;
+ justify-content: center;
+}
+
+.toggle-button {
+ display: inline-block;
+ margin: 0.5ex;
+ padding: 0.7ex;
+ border: solid 1px var(--button-accent-color);
+ border-radius: 0.5ex;
+ transition: background-color 0.1s;
+}
+
+.toggle-button:hover {
+ background-color: color-mix(in srgb, var(--button-accent-color), transparent 75%);
+}
+
+.toggle-button:has(input:checked) {
+ background-color: var(--button-accent-color);
+ color: var(--active-button-text-color);
+}
+
+.toggle-button:has(input:disabled) {
+ background-color: var(--disable-button-color);
+ border-color: var(--border-color);
+}
+
+.toggle-button input {
+ appearance: none;
+ margin: 0;
+}
+
+.hidden {
+ display: none;
+}
+
+label[error]::after {
+ display: block;
+ content: "❌ " attr(error);
+ color: var(--error-color);
+}
+
+#error-message-container::before {
+ content: "❌ ";
+ color: var(--error-color);
+}
+
+#error-message-container {
+ color: var(--error-color);
+}
+
+button {
+ width: 100%;
+ height: 3em;
+ font-size: 1em;
+
+ border: solid 1px var(--border-color);
+ border-radius: 0.5ex;
+}
+
+@media (prefers-color-scheme: dark) {
+ :root {
+ /* Overridden properties */
+ --border-color: #464666;
+ --canvas-color: #1D1D2A;
+ --card-color: #2A2A3D;
+ --text-color: #DADADF;
+ --button-accent-color: #3259CC;
+ --active-button-text-color: white;
+ --disable-button-color: #35354A;
+ --text-field-background: #232333;
+
+ /* Properties unique to dark mode */
+ --button-hover-color: #2948a5;
+ --select-background: var(--text-field-background);
+ --select-hover: color-mix(in srgb, var(--text-field-background), var(--card-color));
+ }
+
+ button {
+ border-color: var(--button-accent-color);
+ background-color: var(--button-accent-color);
+ color: var(--active-button-text-color);
+ }
+
+ button:hover {
+ background-color: var(--button-hover-color);
+ }
+
+ select {
+ background-color: var(--select-background);
+ color: var(--text-color);
+ border: solid 1px var(--border-color);
+ border-radius: 0.5ex;
+ }
+
+ select:hover {
+ background-color: var(--select-hover);
+ }
+}
diff --git a/templateer.js b/templateer.js
new file mode 100644
index 0000000..b683428
--- /dev/null
+++ b/templateer.js
@@ -0,0 +1,911 @@
+let wasm;
+
+const heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+function getObject(idx) { return heap[idx]; }
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+ if (idx < 132) return;
+ heap[idx] = heap_next;
+ heap_next = idx;
+}
+
+function takeObject(idx) {
+ const ret = getObject(idx);
+ dropObject(idx);
+ return ret;
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8Memory0 = null;
+
+function getUint8Memory0() {
+ if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
+ cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
+ }
+ return cachedUint8Memory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+ ptr = ptr >>> 0;
+ return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
+}
+
+function addHeapObject(obj) {
+ if (heap_next === heap.length) heap.push(heap.length + 1);
+ const idx = heap_next;
+ heap_next = heap[idx];
+
+ heap[idx] = obj;
+ return idx;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+ ? function (arg, view) {
+ return cachedTextEncoder.encodeInto(arg, view);
+}
+ : function (arg, view) {
+ const buf = cachedTextEncoder.encode(arg);
+ view.set(buf);
+ return {
+ read: arg.length,
+ written: buf.length
+ };
+});
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+ if (realloc === undefined) {
+ const buf = cachedTextEncoder.encode(arg);
+ const ptr = malloc(buf.length, 1) >>> 0;
+ getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
+ WASM_VECTOR_LEN = buf.length;
+ return ptr;
+ }
+
+ let len = arg.length;
+ let ptr = malloc(len, 1) >>> 0;
+
+ const mem = getUint8Memory0();
+
+ let offset = 0;
+
+ for (; offset < len; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+
+ if (offset !== len) {
+ if (offset !== 0) {
+ arg = arg.slice(offset);
+ }
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+ const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
+ const ret = encodeString(arg, view);
+
+ offset += ret.written;
+ }
+
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+}
+
+function isLikeNone(x) {
+ return x === undefined || x === null;
+}
+
+let cachedInt32Memory0 = null;
+
+function getInt32Memory0() {
+ if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
+ cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
+ }
+ return cachedInt32Memory0;
+}
+
+let cachedFloat64Memory0 = null;
+
+function getFloat64Memory0() {
+ if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
+ cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
+ }
+ return cachedFloat64Memory0;
+}
+
+function debugString(val) {
+ // primitive types
+ const type = typeof val;
+ if (type == 'number' || type == 'boolean' || val == null) {
+ return `${val}`;
+ }
+ if (type == 'string') {
+ return `"${val}"`;
+ }
+ if (type == 'symbol') {
+ const description = val.description;
+ if (description == null) {
+ return 'Symbol';
+ } else {
+ return `Symbol(${description})`;
+ }
+ }
+ if (type == 'function') {
+ const name = val.name;
+ if (typeof name == 'string' && name.length > 0) {
+ return `Function(${name})`;
+ } else {
+ return 'Function';
+ }
+ }
+ // objects
+ if (Array.isArray(val)) {
+ const length = val.length;
+ let debug = '[';
+ if (length > 0) {
+ debug += debugString(val[0]);
+ }
+ for(let i = 1; i < length; i++) {
+ debug += ', ' + debugString(val[i]);
+ }
+ debug += ']';
+ return debug;
+ }
+ // Test for built-in
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+ let className;
+ if (builtInMatches.length > 1) {
+ className = builtInMatches[1];
+ } else {
+ // Failed to match the standard '[object ClassName]'
+ return toString.call(val);
+ }
+ if (className == 'Object') {
+ // we're a user defined class or Object
+ // JSON.stringify avoids problems with cycles, and is generally much
+ // easier than looping through ownProperties of `val`.
+ try {
+ return 'Object(' + JSON.stringify(val) + ')';
+ } catch (_) {
+ return 'Object';
+ }
+ }
+ // errors
+ if (val instanceof Error) {
+ return `${val.name}: ${val.message}\n${val.stack}`;
+ }
+ // TODO we could test for more things here, like `Set`s and `Map`s.
+ return className;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+ const state = { a: arg0, b: arg1, cnt: 1, dtor };
+ const real = (...args) => {
+ // First up with a closure we increment the internal reference
+ // count. This ensures that the Rust closure environment won't
+ // be deallocated while we're invoking it.
+ state.cnt++;
+ const a = state.a;
+ state.a = 0;
+ try {
+ return f(a, state.b, ...args);
+ } finally {
+ if (--state.cnt === 0) {
+ wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
+
+ } else {
+ state.a = a;
+ }
+ }
+ };
+ real.original = state;
+
+ return real;
+}
+function __wbg_adapter_36(arg0, arg1) {
+ wasm.wasm_bindgen__convert__closures__invoke0_mut__hff116f4730a514d0(arg0, arg1);
+}
+
+function __wbg_adapter_39(arg0, arg1, arg2) {
+ wasm.wasm_bindgen__convert__closures__invoke1_mut__h1f9a9e3d2a14eab2(arg0, arg1, addHeapObject(arg2));
+}
+
+/**
+* @returns {any}
+*/
+export function create_state() {
+ try {
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+ wasm.create_state(retptr);
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
+ if (r2) {
+ throw takeObject(r1);
+ }
+ return takeObject(r0);
+ } finally {
+ wasm.__wbindgen_add_to_stack_pointer(16);
+ }
+}
+
+/**
+* @returns {Array