create-lt-adventure 0.0.1

package/templates/vite/lang/en.json

@@ -0,0 +1 @@
+{}

package/templates/vite/module.json

@@ -0,0 +1,36 @@
+{
+	"id": "module-template",
+	"title": "Module Template",
+	"description": "",
+	"authors": [
+		{
+			"name": "Vauxs",
+			"discord": "vauxs",
+			"twitter": "@ThatVauxs",
+			"email": "mrvauxs@gmail.com",
+			"ko-fi": "MrVauxs",
+			"patreon": "MrVauxs"
+		}
+	],
+	"version": "dev",
+	"compatibility": {
+		"minimum": "13",
+		"verified": "13"
+	},
+	"esmodules": [],
+	"styles": [],
+	"relationships": {},
+	"packs": [],
+	"packFolders": [],
+	"flags": {
+		"canUpload": true,
+		"hotReload": {
+			"extensions": ["css", "json"],
+			"paths": ["styles"]
+		}
+	},
+	"url": "",
+	"bugs": "",
+	"manifest": "",
+	"download": ""
+}

package/templates/vite/package.json

@@ -0,0 +1,29 @@
+{
+	"name": "my-new-module",
+	"type": "module",
+	"private": true,
+	"license": "MIT",
+	"scripts": {
+		"build": "vite build",
+		"dev": "vite",
+		"extract": "node scripts/extractPacks.mjs",
+		"symlink": "node scripts/symlink.mjs"
+	},
+	"devDependencies": {
+		"@clack/prompts": "^1.0.0-alpha.9",
+		"@foundryvtt/foundryvtt-cli": "^3.0.2",
+		"@types/jquery": "^3.5.33",
+		"dotenv": "^17.2.3",
+		"foundry-pf2e": "github:7H3LaughingMan/foundry-pf2e",
+		"foundryvtt-sync": "https://github.com/MrVauxs/FoundryVTT-Sync",
+		"kolorist": "^1.8.0",
+		"postcss-preset-env": "^10.6.0",
+		"postcss-replace": "^2.0.1",
+		"typescript": "^5.9.3",
+		"vite": "^7.3.0"
+	},
+	"browserslist": [
+		">5%",
+		"not IE 11"
+	]
+}

package/templates/vite/scripts/extractPacks.mjs

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import { extractPack } from "@foundryvtt/foundryvtt-cli";
+import { yellow } from "kolorist";
+// import moduleJSON from "../module.json" with { type: "json" };
+
+const foundryDataDir = "packs/";
+const jsonDataDir = "data/";
+
+p.intro(`Extracting ${foundryDataDir} into ${jsonDataDir}...`)
+
+const outDir = path.resolve(process.cwd());
+const packsCompiled = path.resolve(outDir, foundryDataDir);
+if (!existsSync(packsCompiled)) {
+	p.log.warn("Packs directory does not exist in the build!")
+}
+
+const packFolders = await fs.readdir(packsCompiled);
+
+if (packFolders.length === 0) p.log.info("No packs to extract!")
+
+await p.tasks(
+	packFolders.map(pack => ({
+		title: `Extracting ${pack}...`,
+		task: async () => {
+			if (!existsSync(`${jsonDataDir}/${pack}`)) {
+				await fs.mkdir(`${jsonDataDir}/${pack}`);
+			}
+			await extractPack(
+				path.resolve(packsCompiled, pack),
+				`${jsonDataDir}/${pack}`,
+				{
+					expandAdventures: true,
+					omitVolatile: true,
+					folders: false,
+					clean: true,
+					log: false
+				},
+			);
+			return `Extracted ${yellow(pack)}!`
+		}
+	})),
+	{}
+);
+
+p.outro("Finished!");

package/templates/vite/scripts/onCreate.mjs

@@ -0,0 +1,14 @@
+const mod = (await Bun.file("../module.json").json());
+const pack = (await Bun.file("../package.json").json());
+
+// Module
+mod.esmodules = [`dist/${mod.id}.js`];
+mod.styles = [`dist/${mod.id}.css`];
+
+// Package
+pack.name = mod.id;
+
+await Bun.write("../module.json", JSON.stringify(mod, null, "\t"));
+await Bun.write("../package.json", JSON.stringify(pack, null, "\t"));
+
+export { };

package/templates/vite/scripts/symlink.mjs

@@ -0,0 +1,79 @@
+import { lstatSync, rmSync, symlinkSync, unlinkSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import process from "node:process";
+import * as p from "@clack/prompts";
+import moduleJSON from "../module.json" with { type: "json" };
+import { yellow } from "kolorist";
+
+p.intro(`${moduleJSON.id} symlink script`)
+
+// Store config in user's home directory
+const configPath = resolve(homedir(), ".foundry-symlink-config.json");
+
+// Load last known path from config
+let lastPath = null;
+try {
+	const config = JSON.parse(readFileSync(configPath, "utf-8"));
+	lastPath = config.dataPath;
+} catch {
+	// Config doesn't exist yet, that's fine
+}
+
+const windowsInstructions = process.platform === "win32" ? " Start with a drive letter (\"C:\\\")." : "";
+const lastFolder = lastPath ? `(last: ${lastPath})` : "";
+const promptPath = await p.text({
+	message: `Enter the full path to your Foundry data folder.${windowsInstructions}`,
+	placeholder: lastPath,
+	initialValue: lastPath,
+	validate(val) {
+		const value = val.replace(/\W*$/, "").trim();
+		if (!value || !/\bData$/.test(value)) {
+			return (`"${value}" does not contain ${yellow('/Data')}`);
+		}
+	}
+});
+
+let dataPath = promptPath.replace(/\W*$/, "").trim();
+
+if (dataPath !== lastPath) {
+	// Ask if user wants to save the path
+	const shouldSave = await p.confirm({
+		initialValue: true,
+		message: `Save "${dataPath}" for future use?`,
+	});
+
+	if (shouldSave) {
+		writeFileSync(configPath, JSON.stringify({ dataPath }, null, 2));
+	}
+}
+
+const symlinkPath = resolve(dataPath, "modules", moduleJSON.id);
+const symlinkStats = lstatSync(symlinkPath, { throwIfNoEntry: false });
+if (symlinkStats) {
+	const atPath = symlinkStats.isDirectory() ? "folder" : symlinkStats.isSymbolicLink() ? "symlink" : "file";
+	const proceed = await p.confirm({
+		initialValue: false,
+		message: `A "${moduleJSON.id}" ${atPath} already exists in the "modules" subfolder. Replace with new symlink?`,
+	});
+	if (!proceed) {
+		p.cancel("Aborting.");
+		process.exit(0);
+	}
+}
+
+try {
+	if (symlinkStats?.isDirectory()) {
+		rmSync(symlinkPath, { recursive: true, force: true });
+	} else if (symlinkStats) {
+		unlinkSync(symlinkPath);
+	}
+	symlinkSync(resolve(process.cwd()), symlinkPath);
+} catch (error) {
+	if (error instanceof Error) {
+		console.error(`An error was encountered trying to create a symlink: ${error.message}`);
+		process.exit(1);
+	}
+}
+
+p.outro(`Symlink successfully created at "${symlinkPath}"!`);

package/templates/vite/src/adventureSheet/index.js

@@ -0,0 +1,498 @@
+import moduleJSON from "moduleJSON";
+
+const affectedDocuments = ["journal"];
+
+const backgrounds = [
+	{ maxWidth: 130, image: "bg-header-length-01.svg" },
+	{ maxWidth: 150, image: "bg-header-length-02.svg" },
+	{ maxWidth: 210, image: "bg-header-length-03.svg" },
+	{ maxWidth: 250, image: "bg-header-length-04.svg" },
+	{ maxWidth: 300, image: "bg-header-length-05.svg" },
+	{ maxWidth: 400, image: "bg-header-length-06.svg" },
+	{ maxWidth: Infinity, image: "bg-header-length-07.svg" },
+];
+
+const DnDSheet = CONFIG.JournalEntry.sheetClasses.base['dnd5e.JournalEntrySheet5e'].cls;
+
+export class LootTavernSheet extends DnDSheet {
+	static DEFAULT_OPTIONS = {
+		classes: [`${moduleJSON.id}-journal`],
+		actions: {
+			"openLootDevTools": this.openLootDevTools
+		},
+		window: {
+			controls: [
+				{
+					"icon": "fa-solid fa-wrench",
+					"label": "Loot Tavern Dev Tools",
+					"action": "openLootDevTools",
+					visible: () => moduleJSON.version === "dev",
+				}
+			]
+		}
+	}
+
+	static openLootDevTools(event) {
+		event.stopPropagation(); // Don't trigger other events
+		if (event.detail > 1) return; // Ignore repeated clicks
+		const docSheetConfigWidth = foundry.applications.apps.DocumentSheetConfig.DEFAULT_OPTIONS.position.width;
+		const fields = foundry.applications.fields;
+
+		const placeholder = `modules/${moduleJSON.id}/assets/setup.webp`
+
+		const headersInput = fields.createCheckboxInput({ name: "helianaHeaders", value: this.document.getFlag(moduleJSON.id, "helianaHeaders"), placeholder })
+		const selectGroup = fields.createFormGroup({
+			input: headersInput,
+			label: "Heliana-styled Headers",
+			hint: undefined
+		})
+
+		const imageInput = fields.createTextInput({ name: "image", value: this.document.getFlag(moduleJSON.id, "image"), placeholder })
+		const imageGroup = fields.createFormGroup({
+			input: imageInput,
+			label: "Main Image",
+			hint: undefined
+		})
+
+		const sidebarImageInput = fields.createTextInput({ name: "sidebarImage", value: this.document.getFlag(moduleJSON.id, "sidebarImage"), placeholder })
+		const sidebarImageGroup = fields.createFormGroup({
+			input: sidebarImageInput,
+			label: "Sidebar Background Image",
+			hint: undefined
+		})
+
+		const borderNumberInput = fields.createSelectInput({
+			options: Array(31).fill().map((x, i) => ({ label: i, value: i })),
+			name: 'borderNumber',
+			value: this.document.getFlag(moduleJSON.id, "borderNumber") || 26,
+		})
+		const borderNumberGroup = fields.createFormGroup({
+			input: borderNumberInput,
+			label: "Border Select",
+			hint: "Pick a style of border you want."
+		})
+
+		const formContent = [
+			selectGroup,
+			imageGroup,
+			sidebarImageGroup,
+			borderNumberGroup
+		]
+
+		const updateFlags = (flags) => this.document.update({ [`flags.${moduleJSON.id}`]: flags });
+
+		const dialog = new foundry.applications.api.DialogV2({
+			id: `${this.id}-dev-menu`,
+			classes: [],
+			window: {
+				title: `${this.document.name} Dev Config`,
+				resizable: true,
+			},
+			position: {
+				width: 550,
+				top: this.position.top + 40,
+				left: this.position.left + ((this.position.width - docSheetConfigWidth) / 2)
+			},
+			// ../../assets/Art/ReignOfIron-Landscape-Vertical.webp
+			content: formContent.map(x => x.outerHTML).join(""),
+			buttons: [
+				{
+					action: "submit",
+					label: "Submit",
+					default: true,
+					callback: async function (event, target) {
+						const flags = Object.fromEntries(Object.values(target.form.elements).map(x => [x.name, x.checked || x.value]).filter(x => x[0]))
+
+						await updateFlags(flags)
+					},
+				},
+			],
+		});
+		dialog.render(true);
+	}
+
+	async render(force, options) {
+		const doc = this.document;
+		const modFlags = doc.flags?.[moduleJSON.id] ?? {};
+		await super.render(force, options);
+
+		const html = this.element;
+
+		// Sidebar Background
+		const sidebarImg = this.document.getFlag(moduleJSON.id, "sidebarImage");
+		if (sidebarImg) html.style.setProperty("--sidebarImage", `url("/${sidebarImg}")`);
+
+		const borderNumber = this.document.getFlag(moduleJSON.id, "borderNumber");
+		if (!isNaN(borderNumber)) html.style.setProperty("--urlBorderImage", `url("/modules/${moduleJSON.id}/assets/journals/borders/panel-border-${("00" + Number(borderNumber)).slice(-3)}.webp")`);
+
+		let borderRadius = "7px";
+		let borderSizeMod = "0px";
+		let borderCut = "32";
+		let borderOutset = "32";
+		switch (Number(borderNumber)) {
+			case 0: {
+				borderRadius = `7px`;
+				borderSizeMod = `25px`;
+				break;
+			}
+			case 1: {
+				borderRadius = `15px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 2: {
+				borderRadius = `15px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 3: {
+				borderRadius = `0px`;
+				borderSizeMod = `35px`;
+				break;
+			}
+			case 4: {
+				borderRadius = `6px`;
+				borderSizeMod = `20px`;
+				break;
+			}
+			case 5: {
+				borderRadius = `0px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 6: {
+				borderRadius = `10px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 7: {
+				borderRadius = `15px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 8:
+			case 9: {
+				borderRadius = `10px`;
+				borderSizeMod = `12px`;
+				break;
+			}
+			case 10: {
+				borderRadius = `16px`;
+				borderSizeMod = `5px`;
+				break;
+			}
+			case 11:
+			case 12: {
+				borderRadius = `16px`;
+				borderSizeMod = `5px`;
+				break;
+			}
+			case 13: {
+				borderRadius = `12px`;
+				borderSizeMod = `5px`;
+				break;
+			}
+			case 14: {
+				borderRadius = `10px`;
+				borderSizeMod = `20px`;
+				break;
+			}
+			case 15: {
+				borderRadius = `0px`;
+				borderSizeMod = `5px`;
+				break;
+			}
+			case 16: {
+				borderRadius = `8px`;
+				borderSizeMod = `10px`;
+				break;
+			}
+			case 17: {
+				borderRadius = `11px`;
+				borderSizeMod = `10px`;
+				break;
+			}
+			case 18:
+			case 19: {
+				borderRadius = `16px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 20: {
+				borderRadius = `0px`;
+				borderSizeMod = `10px`;
+				borderCut = `40`
+				borderOutset = `46`
+				break;
+			}
+			case 21: {
+				borderRadius = `25px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 22: {
+				borderRadius = `10px`;
+				borderSizeMod = `6px`;
+				break;
+			}
+			case 23: {
+				borderRadius = `24px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 24: {
+				borderRadius = `0px`;
+				borderSizeMod = `50px`;
+				break;
+			}
+			case 25: {
+				borderRadius = `27px`;
+				borderSizeMod = `0px`;
+				borderCut = `40`
+				borderOutset = `32`
+				break;
+			}
+			case 26: {
+				borderRadius = `30px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			case 27: {
+				borderRadius = `0px`;
+				borderSizeMod = `8px`;
+				break;
+			}
+			case 28: {
+				borderRadius = `15px`;
+				borderSizeMod = `8px`;
+				break;
+			}
+			case 29: {
+				borderRadius = `15px`;
+				borderSizeMod = `8px`;
+				break;
+			}
+			case 30: {
+				borderRadius = `15px`;
+				borderSizeMod = `0px`;
+				break;
+			}
+			default: {
+				console.log("wtf??", borderNumber)
+			}
+		}
+
+		html.style.setProperty("--ltBorderRadius", borderRadius);
+		html.style.setProperty("--ltBorderSizeMod", borderSizeMod);
+		html.style.setProperty("--ltBorderCut", borderCut);
+		html.style.setProperty("--ltBorderOutset", borderOutset);
+
+		if (this.mode === 2) {
+			const imgPath = this.document.flags[moduleJSON.id]?.image;
+			if (!imgPath) return;
+			const scrollable = html.querySelector(".journal-entry-content .scrollable");
+
+			// Create and insert scenery element
+			const sceneryDiv = document.createElement("div");
+			sceneryDiv.className = "scenery mask upside-down";
+			sceneryDiv.innerHTML = `<img src="/${imgPath}">`;
+			scrollable.prepend(sceneryDiv);
+
+			const scenery = scrollable.querySelector(".scenery");
+
+			scrollable.addEventListener("scroll", ({ target }) => {
+				const opacity = Math.max(10, 100 - target.scrollTop / 2);
+				scenery.style.opacity = `${opacity}%`;
+				scenery.style.pointerEvents = opacity < 50 ? "none" : "auto";
+			});
+
+
+			const header = html.querySelector("header.journal-header");
+			header.remove();
+
+			const title = document.createElement('header');
+			title.textContent = this.document.name;
+			scenery.appendChild(title);
+		}
+
+		// Level Select
+		const levelSelect = html.querySelector("#level-select");
+
+		if (levelSelect) {
+			// Add radio inputs to each level
+			const levelOptions = levelSelect.querySelectorAll("[data-level]");
+			levelOptions.forEach((option) => {
+				const input = document.createElement("input");
+				input.type = "radio";
+				input.name = "level-selector";
+				option.prepend(input);
+			});
+
+			// Handle radio button clicks
+			const radioInputs = levelSelect.querySelectorAll("input[type='radio']");
+			radioInputs.forEach((radio) => {
+				radio.addEventListener("click", function () {
+					const radioElement = this;
+
+					if (radioElement.checked) {
+						// Uncheck all radios in the group
+						const groupName = radioElement.name;
+						const allRadios = levelSelect.querySelectorAll(`input[type='radio'][name='${groupName}']`);
+						allRadios.forEach((r) => {
+							(r).checked = false;
+						});
+
+						// Check the clicked radio
+						radioElement.checked = true;
+
+						// Get level and update
+						const parent = radioElement.parentElement;
+						const level = parseInt(parent.dataset.level || "0", 10);
+
+						ui.notifications.info(`Setting the adventure level to ${level}!`);
+						doc.update({ flags: { [moduleJSON.id]: { level } } });
+
+						// Determine changes based on level
+						let changes = [11, 3, 3, "1d6"];
+						switch (level) {
+							case 1:
+							case 2:
+								changes = [11, 3, 3, "1d6"];
+								break;
+							case 3:
+							case 4:
+								changes = [12, 4, 3, "1d6"];
+								break;
+							case 5:
+							case 6:
+								changes = [13, 5, 5, "2d4"];
+								break;
+							case 7:
+							case 8:
+								changes = [14, 6, 7, "2d6"];
+								break;
+							case 9:
+							case 10:
+							case 11:
+								changes = [15, 7, 10, "3d6"];
+								break;
+							case 12:
+							case 13:
+							case 14:
+								changes = [16, 8, 14, "4d6"];
+								break;
+							case 15:
+							case 16:
+							case 17:
+								changes = [17, 9, 21, "6d6"];
+								break;
+							case 18:
+							case 19:
+							case 20:
+								changes = [18, 10, 28, "8d6"];
+								break;
+						}
+
+						// Update all flags
+						doc.update({
+							flags: {
+								[moduleJSON.id]: {
+									level,
+									dc: changes[0],
+									mod: changes[1],
+									damage: changes[2],
+									damageDice: changes[3],
+								},
+							},
+						});
+					} else {
+						(this).checked = false;
+					}
+				});
+			});
+
+			// Set checked state for previously chosen level
+			const chosenLevel = modFlags.level;
+			if (chosenLevel) {
+				const chosenOption = levelSelect.querySelector(`[data-level="${chosenLevel}"]`);
+				if (chosenOption) {
+					const chosenInput = chosenOption.querySelector("input");
+					chosenInput.checked = true;
+				}
+			}
+		}
+	}
+
+	async _renderPageViews(context, options) {
+		const rendered = await super._renderPageViews(context, options);
+		this.applyHelianaHeaders()
+		return rendered;
+	}
+
+	applyHelianaHeaders(target = this.element) {
+		const headers = target.querySelectorAll("h2");
+		headers.forEach((h2) => {
+			const parent = h2.parentElement;
+			if (!parent) return;
+			parent.classList.add("heliana-style-bg");
+
+			// Find appropriate background based on header width
+			const background = backgrounds.find((bg) => h2.offsetWidth <= bg.maxWidth);
+
+			if (background) {
+				parent.style.backgroundImage = `url("/modules/${moduleJSON.id}/assets/journals/headers/${background.image}")`;
+			}
+		});
+	}
+
+	async deleteSelf() {
+		await this.close({ force: true });
+		// @ts-expect-error Intentional for purposes of HMR
+		this.document._sheet = null;
+	}
+}
+
+function registerSheet(sheet) {
+	foundry.applications.apps.DocumentSheetConfig.registerSheet(JournalEntry, moduleJSON.id, sheet, {
+		label: `${moduleJSON.title} Sheet`,
+		canBeDefault: false,
+	});
+}
+
+function unregisterSheet(sheet) {
+	foundry.applications.apps.DocumentSheetConfig.unregisterSheet(JournalEntry, moduleJSON.id, sheet);
+}
+
+// Assuming we are inside a Hooks.on("ready")
+registerSheet(LootTavernSheet)
+
+if (import.meta.hot) {
+	import.meta.hot.accept(async (newModule) => {
+		if (!newModule) return;
+		let reopenedDocuments = [];
+
+		unregisterSheet(LootTavernSheet);
+
+		for (const type of affectedDocuments) {
+			for (const doc of game[type].contents) {
+				// @ts-expect-error Custom function for LootTavernSheets
+				if (doc.sheet.deleteSelf) {
+					// @ts-expect-error Custom function for LootTavernSheets
+					await doc.sheet.deleteSelf();
+					reopenedDocuments.push(doc.uuid);
+				}
+			}
+		};
+
+		registerSheet(newModule.LootTavernSheet);
+		console.log(`Registered new ${newModule.LootTavernSheet.name} sheet.`)
+
+		reopenedDocuments.forEach(async (uuid) => {
+			const doc = await fromUuid(uuid);
+			if (!doc) return;
+
+			doc?.sheet?.render(true);
+		});
+		reopenedDocuments = [];
+	});
+}